My first in-person Akademy: Thessaloniki 2023

This year, I was finally able to participate in-person at Akademy. Apart from meeting some familiar faces from the Plasma Spring in May this year, I also met lots of new people.

When waiting for the plane in Frankfurt, a group of KDE people formed. Meaning, we had a get-together even before the Akademy had started ;). On the plane to Thessaloniki, I made a merge requests to fix a Kickoff crash due to a KRunner change. Once that was done, everything was in place for the talks!

On Saturday, I talked once again with Nico and also Volker about KF6. This included topics like the remaining challenges, the estimated timeline for KF6 and some practical porting advice. I also gave a talk about KRunner. This was the conference talk of mine that I gave alone, meaning I was a bit nervous 😅. The title was “KRunner: Past, Present, and Future” and it focused on porting, new features and future plans for KF6. Thanks to everyone who was listening to the talk, both in person and online! Some things like the multithreading refactoring are worth their own blog post, which I will do in the next weeks.

The talks from other community members were also quite interesting. Sometimes it was hard to decide to which talk to go :). Multiple talks and BoFs were about energy efficiency and doing measurements. This perfectly aligned with me doing benchmarking of KRunner and the KCoreAddons plugin infrastructure.

The view of the city from the hotel balcony was also quite nice

Our KF6 and Qt6 porting BoFs were also quite productive. On Tuesday, we had our traditional KF6 weekly. Having this in person was definitely a nice refreshment! Apart from some general questions about documentation and KF6 Phabricator tasks, we discussed the release schedule. The main takeaway is that we want to improve the release automation and have created a small team to handle the KDE Frameworks releases. This includes Harald Sitter, Nicolas Fella, David Edmundson and me. Feel free to join the weeklies in our Big Blue Button room https://meet.kde.org/b/ada-mi8-aem at 17:00 CEST each Tuesday.

Since we had so many talented KDE people in one place, I decided to have a KRunner BoF on Tuesday morning. Subject of discussion was for example the sorting of KRunner, how to better organize the categories and the revival of the so-called “single runner mode”. This mode allows you to query only one specific plugin, instead of all available ones. This was previously only available from the D-Bus interface, but I have added a command line option to KRunner. To better visualize this special mode being in use, a tool-button was added as an indicator. This can also be used to go back to querying all runners. Kai will implement clickable categories that allow you to enable this mode without any command line options being necessary!

Finally, I would like to thank everyone who made this awesome experience possible! I am already looking forward to the next Akademy and the next sprints.

Quick reminder, that you can include a Mastodon or Matrix link to your AppStream file and that the link will then be displayed in your application page at apps.kde.org.

<custom>
 <value key="KDE::matrix">#merkuro:kde.org</value>
 <value key="KDE::mastodon">https://kde.social/@merkuro</value>
</custom>

Last week, I went to Akademy, the yearly KDE conference, in Thessaloniki. This is now my third in-person Akademy and fifth Akademy in total. As always, this is the occasion to meet old and new friends, learn about what others are hacking on and enjoy good food.

Friday

I arrived Friday afternoon, taking my flight from Nuremberg with a few others. Getting out of the airport, we could immediately feel the heat. After leaving our stuff at the hotel, we went to join the rest of the KDE folks at the welcome event in a frindly and cozy bar.

Saturday

On Saturday, I talked about the current state of the Accessibility (a.k.a KDE For All) goal. In short, we are making progress on that and fixing bugs everywhere in the stack, but we desperately need more community involvement as the task is big. Hopefully, the Selemiun AT-SPI bridge can be helpful, as it makes it possible to write integration tests using the accessibility API which require some accessibility support in your application to work. (Slides)

I also presented the Fundraising WG report. We had two successful fundraising campaigns this year: Kdenlive and the end of the year campaign. (Slides)

My highlight for the day was the KDE Embedded talk from Andreas. The talk explained the progress in getting the whole KDE software packaged as Yocto layers, which already allows us to build images for RISC-V and ARM devices with Plasma BigScreen. There is definitively a lot of potential there to get KDE technologies in a wide varieties of devices. A recent example is KWin being integrated inside Mercedes cars’ infotainment system, resulting in various upstream improvements. (Slides)

Sunday

On Sunday, I had a talk with Tobias Fella about Matrix and Mastodon and how we can integrate these protocols inside our applications in various ways. First, by providing clients for these protocols: NeoChat (Matrix) and Tokodon (Mastodon), but also with less oblivious ways like using Mastodon as a comment system on your blog or by using Matrix to share your KDE Itinerary live data end-to-end encrypted with your friend without requiring a centralized server. (Slides)

My highlight for Sunday was the Selenium GUI Testing talk from Harald, which is closely related to my Accessibility goal and Automatisation goal from Nate. (Slides)

The lightning talks were also excellent. Kai showed off his integration of AlphaCloud inside Plasma to get his solar pannel stats. (Slides)

Jean-Baptiste Kempf (from VLC) presented his cross-platform remote control software stack in Rust, which promises very low latency.

Fabian Kosmale from the Qt Company Group presented the qmllint tool, which should really helps improve the quality of our software and reduces the risk to accidentally create regressions in our QML applications. I’m looking forward to using it on my applications and to building custom plugins for it. (Slides)

Finally, Nate presented the new Plasma Welcome wizard, which is great! (Slides)

Bofs

The rest of the week, we had “Birds of a Feather” (or BoF) which were particularly productive. I (co-)hosted multiple BoFs this year: Plasma Mobile, NeoChat, KDE PIM and Accessibility, but I also enjoyed a few other BoFs: the fundraising BoF where Victoria gave us a lot of advice on how to do fundraising for non-profit and the KDE e.V. board office hour or the Selemiun BoFs from Harald and a few others.

Day trip

We went to Mount Olympus, Dion, and a beach for our day trip. As a ancient Greece nerd, I enjoyed it! Here are some photos from the trip:

Trainings

We also had training at Akademy. I participated to the one from Nuno (thanks, KDAB for offering it) about Qt Design Studio, a very powerful QML visual editor and with a bridge to Figma. Unfortunately, I couldn’t attempt this training fully because it conflicted with a BoF I was hosting, but the bit I saw there was very interesting. It would be great if we could integrate Kirigami components inside this tool.

On Friday Akademy 2023 came to a close. This was the second time I attended the conference physically after the online editions of 2020 and 2021 and I want to give short retrospective this blog post.

Talks

Akademy started with two days full of talks on Saturday and Sunday and I have to say sometimes it was hard to choose between the two parallel tracks. Overall it provided a nice mixture between what happens in the community, learning how people solved problems and learning from them (for example Ingo fixing accessibility in Kleopatra) and insight into new technologies (I had never heard of Slint before). Apart from the two standout keynotes about Kdenlive and the Libre Space Foundation I want to highlight Joseph’s talk about Internal Communication at KDE which it turns out also projects outwards for example to new potential contributors. The talk itself was well structured and presented and had engaged with the audience nicely as well.

This year I did not submit a talk myself but stood in for Albert for an update about what’s happening in the KDE Free Qt Foundation and in the KDE e.V. KDE Free Qt Working Group during the KDE e.V. Working Group reports. since he had a talk at the same time in the other room.

I also tried something new and held a panel in the “KDE Wayland Fireside chat” together with Aleix, David Edmundson, Vlad and Xaver which was intended to be an opportunity to interact for people with their favourite KDE Wayland developers. I think it turned out nicely with very good online participation - probably half of the question came from chat! The size of the physically audience was maybe less than what I would expected beforehand but we had very strong opposition with the lighting talks happening at the same time in room 1 while we were the last session in room 2. Speaking of them, I am looking very much forward to watch the recording of them and all the other talks that I missed because I was in another room.

BoFs and all the other things

After the talks come the BoFs, where people meet, discuss, plan, roadmap and workshop together. My personal self-selected schedule consisted among other things of a whole lot of KF6, Plasma 6 and to round it out more KF6. We discussed what is left to do, challenges left, and even potential roadmaps to release. Here the strong presence of people from the Qt Group proved valuable as they could help with some challenges we are facing and were interested in some problems we faced along the way. We even discovered that we share common interest into improving some areas of Qt.

Thursday was dominated by Wayland discussions. It started with a discussion on input methods and virtual keyboards where we recapped what’s happening upstream, how this fits to our needs and vision of Plasma. Afterwards we discussed some challenges of Qt on Wayland with regards to its QInputDevice API. This session showed again how useful it is to have Qt and KDE people in the same room as the discussion switched quickly from outlining missing features to making gestures and scrolling work nicely in Qt and for application developers in a Wayland world using existing infrastructure.

But Akademy is not only the things that are on the official schedule. It’s meeting familiar and new faces at the welcome and social events. It’s going on to the day trip together. It’s having a spontaneous Itinerary almost BoF in hacking room. It’s going to and having dinner together after an exhausting day. And of course it’s sometimes also just hanging out and chilling with cool people. So thanks to the KDE e.V, the Akademy team and all the volunteers who made this awesome event possible.

Akademy, KDE’s annual conference, recently took place in Thessaloniki, Greece. Lots of people were super excited about the prospect of getting GUI Testing off the ground based on the Selenium tech I built last year. Since KDE produces cross-platform applications an obvious question arose though…

What about Windows?

It’s surprisingly easy! Indeed the most time consuming part is probably getting your hands on a Windows Development Virtual Machine. Once you have a Windows installation we need to only spin up our toolchain and off we go. Here’s a handy command list:

\# Download and install WinAppDriver: https://github.com/microsoft/WinAppDriver/releases

winget install openjs.nodejs
winget install python.python.3.11

npm install --location=global appium
# restart terminal to apply PATH change
set-executionpolicy -scope currentuser remotesigned # allow script execution
appium driver install --source=npm appium-windows-driver

pip install appium-python-client
appium # start server, needs firewall exception on first start

Before we go further into the nitty gritty of testing on Windows I suggest you read the earlier blog post Selenium + AT-SPI = GUI Testing, since a lot of the concepts are the same regardless of platform.

First let us get our ducks in a row.

What Accerciser is to Linux is inspect.exe to Windows, namely an inspector tool for applications. You can find it in your Windows SDK folder %ProgramFiles(x86)%\Windows Kits\10\bin\10.0.22000.0\x64\inspect.exe or there abouts. Opening it greets you with this beauty:

Ignoring the verbosity for a moment we’ll note that it contains similar information to Accerciser on Linux, albeit in a more flat overview. Most importantly what is called the AutomationId is constructed from QObject objectNames, similar to the Accessible IDs on Linux. This is insofar interesting as it means we have a couple of avenues for cross-platform element locating - specifically we could match elements by their name (e.g. the text of a Label or Button), or more uniquely by their objectName-based ID (applicable to all QObjects).

For the purposes of this post we’ll do some trivial testing on Filelight and try to make it work for both Linux and Windows by using the element names. Relying on objectNames is more reliable but unfortunately requires some retrofitting in the source code. To avoid having to build Filelight on Windows we’ll work with what we have got: names. Let’s write our test. Don’t forget to install Filelight first :)

First thing, as always, is our setup boilerplate

#!/usr/bin/env python3

# SPDX-License-Identifier: MIT
# SPDX-FileCopyrightText: 2023 Harald Sitter <sitter@kde.org>

import unittest
import sys
from appium import webdriver
from appium.options.windows import WindowsOptions
from appium.options.common import AppiumOptions
from appium.webdriver.common.appiumby import AppiumBy
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected\_conditions as EC

class SimpleFilelightTests(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        options = WindowsOptions()
        options.app('KDEe.V.Filelight\_7vt06qxq7ptv8!KDEe.V.Filelight')
        self.driver = webdriver.Remote(
            command\_executor='http://127.0.0.1:4723',
            options=options)

    @classmethod
    def tearDownClass(self):
        self.driver.quit()

if \_\_name\_\_ == '\_\_main\_\_':
    unittest.main()

The only really interesting bit here is how we specify the application on Windows. Since Filelight is a store application we can start it by the Application User Model ID (AUMID) instead of a path; this is pretty much the same as starting by-desktop-file-id on Linux.

Now then. With the boilerplate out of the way we can write an incredibly simple test that simply switches pages a bit: If we click on ‘Scan Home Folder’ it should take us to the scan page and clicking there on ‘Go to Overview’ should take us back to the overview page.

    def test\_scan(self):
        self.driver.find\_element(by=AppiumBy.NAME, value="Scan Home Folder").click()
        overview = WebDriverWait(self.driver, 120).until(
            EC.element\_to\_be\_clickable((AppiumBy.NAME, "Go to Overview"))
        )
        overview.click()
        WebDriverWait(self.driver, 4).until(
            EC.element\_to\_be\_clickable((AppiumBy.NAME, "Scan Home Folder"))
        )

Cool. We now can test Filelight on Windows. Next we should try to make this test also work for Linux. Thankfully we only need to switch out our app name for a desktop file id.

    def setUpClass(self):
        if sys.platform == 'nt':
            options = WindowsOptions()
            options.app = 'KDEe.V.Filelight\_7vt06qxq7ptv8!KDEe.V.Filelight'
        else:
            options = AppiumOptions()
            options.set\_capability('app', 'org.kde.filelight.desktop')

Putting it all together we get our final test which runs on both Linux and Windows.

\# Windows
# start appium in a terminal
python .\\test.py

# Linux selenium-webdriver-at-spi-run ./test.py

The complete test code:

#!/usr/bin/env python3

SPDX-License-Identifier: MIT

SPDX-FileCopyrightText: 2023 Harald Sitter sitter@kde.org

import unittest import sys from appium import webdriver from appium.options.windows import WindowsOptions from appium.options.common import AppiumOptions from appium.webdriver.common.appiumby import AppiumBy from selenium.webdriver.support.wait import WebDriverWait from selenium.webdriver.support import expected_conditions as EC

class SimpleCalculatorTests(unittest.TestCase):

@classmethod
def setUpClass(self):
    if sys.platform == 'nt':
        options = WindowsOptions()
        options.app = 'KDEe.V.Filelight\_7vt06qxq7ptv8!KDEe.V.Filelight'
    else:
        options = AppiumOptions()
        options.set\_capability('app', 'org.kde.filelight.desktop')

    self.driver = webdriver.Remote(
        command\_executor='http://127.0.0.1:4723',
        options=options)

@classmethod
def tearDownClass(self):
    self.driver.quit()

def test\_scan(self):
    self.driver.find\_element(by=AppiumBy.NAME, value="Scan Home Folder").click()
    overview = WebDriverWait(self.driver, 120).until(
        EC.element\_to\_be\_clickable((AppiumBy.NAME, "Go to Overview"))
    )
    overview.click()
    WebDriverWait(self.driver, 4).until(
        EC.element\_to\_be\_clickable((AppiumBy.NAME, "Scan Home Folder"))
    )

if __name__ == ‘__main__’: unittest.main()

Discuss this blog post on [KDE Discuss](https://discuss.kde.org/t/writing-selenium-appium-tests-on-windows/3145).

In my previous blog post I mentioned Akademy wasn’t completely over for me, I still had to hold an online training about the KDE Stack even though I left Thessaloniki already.

I had a few participants. Surprisingly some of them (but not all) were more experienced KDE developers than I expected. Since the training is more meant for people who want to get a feel on how to get around our stack I was a bit anxious they wouldn’t get bored… From the feedback I got immediately after the training it looks like it was well received even by the more experienced people. Apparently everybody learned quite a bit and had fun in the process. I’ll thus call it a success.

I made the slides of the KDE Stack training 2023 edition available online on my website and the page of the training in the Akademy program. Feel free to grab and go through them although I guess you’ll get most value with someone actually going through them with you.

And now? Well, we got the KDE e.V. general assembly coming in a few weeks. And hopefully we can setup another KDE PIM sprint in Toulouse around spring time if the community is interested.

As for the life of this KDE Stack training… I have this fantasy that next time I will be able to do it in-person and will make a major update of it since KF6 and Plasma 6 will be out by then. It’s not that I expect a lot of the content being invalidated by those releases. In fact quite the contrary since the 2023 edition already accounts for some of the expected changes. It’s more that an in-person format and the interest driven by major releases would be good reasons to re-think the way it is taught, probably bringing more labs and group activities.

We’ll see if I find time to actually fulfill this fantasy. 😊

As mentioned previously on this blog, I took a break from my vacations for the past couple of days. I attended Akademy 2023 over the week-end and I’m now typing this during my trip back home.

Of course it was nice to see the people. After all it’s the main reason to have such events. Still we had talks and it’s mainly what I will focus on here.

Saturday

Keynote: Libre Space Foundation - Empowering Open-Source Space Technologies

We started the day with a nice keynote about the Libre Space Foundation. It was very interesting and inspiring to see how open source can go into space. The project started in 2011 and despite all the regulation required they managed to get their first satellite in orbit in 2017. This is not a small feat. Of course, everything they produce is free and reusable by others. It was nice to touch upon some of their more specific constraints which impact quite a bit the cycles for producing software and hardware.

KDE Goals - a review and plans going forward

This was followed by a session about the KDE Goals. All three current community goals were covered.

First, the “Automation & Systematization” goal where a good chunk of tasks have been implemented around automated tests (in particular Selenium GUI testing) and the CI to ease some of our processes. It also meant updating quite some documentation.

Second, the Accessibility or “KDE For All” goal was covered. There’s been quite some effort put into adding automated tests using Selenium to check our software compatibility with screen readers and how the keyboard navigation fares. This obviously led to improvements all across the board: in Plasma, in application, in our frameworks, in Qt and in Orca.

Third, the “Sustainable Software” goal progress has been presented. It’s been quite a bit about documenting and presenting results of the efforts in various venues. But there has also been projects to setup labs to measure our software and automated tests using Selenium to implement user scenarios to measure. This can even be triggered on the CI to be executed in a permanent lab in Berlin.

Did you notice the recurring theme between the three goals? I’ll get back to it.

After this session about the KDE Goals, we split in two tracks and so obviously I couldn’t attend everything. I will write only about what I watched.

Measuring energy consumption of software

This session was a more in depth look at how the measurements of the KDE Eco effort are actually done. This is in fact an active research topic and it’s not necessarily easy to source hardware suitable for measuring properly the energy consumption of software.

The guidelines and best practices are still missing in this field.

Interestingly, we have several options available for measuring. I’d summarize it in three categories: cheap hardware, expensive specialized hardware and built-in sensors (accessible via perf if supported). Each category comes with its own set of trade-offs which need to be kept in mind.

In any case, it’s clear that the first thing to do is general profiling and optimizing. Then it’s time to focus on long-running processes, frequent workloads and idle behavior. At this stage, this is where the energy specific measurements become essential… but still difficult to do, the tools available are very basic.

KDE e.V. Board report

Lots was done on the side of the KDE e.V., the board report highlighted some of this work.

First we’re seeing the return of sprints, conferences and tradeshows. The presence and meetings of the community seem back to pre-COVID19 levels.

Also, the fundraising efforts are clearly bearing fruits. In particular a new platform has been put into place (Donorbox) which seems to work great for us. This lead to very successful fundraisers for the end of year and for Kdenlive (first fundraiser of its kind). Now, in the Kdenlive case it means we have to start spending this money to boost its progresses.

The KDE e.V. is professionalizing faster as well. All the “Make a Living” positions got filled. This is no longer a purely volunteers based organization, we have around 10 employees and contractors.

There is already great interest in our software among hardware and software vendors. Hopefully with all those efforts it will keep increasing.

Flatpak and KDE

I then attended a session about Flatpak. It was a quick recap of what it is. Hopefully a widespread adoption could reduce the amount of our users which run old outdated versions.

Interestingly, we seem to have more installations via Flatpak than I first thought. Our most successful software on FlatHub seems to be Kdenlive with around 575K installs. It’s followed by Okular with around 200K installs.

We also provide a KDE Runtime suitable for building our applications flatpaks on. There is one branch of it per Qt version.

Last but not least, we have our own Flatpak remote. This is meant for nightlies and not for stable use. Still if you want to help test the latest and greatest, it’s a nice option.

KF6 - Are we there yet?

This is the big question currently. How much time will we need to reach a port of KDE Frameworks, Plasma and our applications to Qt 6?

The work is on going with quite some progress made. Still there are a couple of challenges in particular in term of coexistence between 5 and 6 components. We’re not too bad in term of co-installability, but there are other dimensions which need catering to in this time of transition.

The talk also covered how to approach the port of our applications. So if you’re in this situation, I advise to get back to the recording and slides for details.

KDE Embedded - Where are we?

This was the last session of the day for me. It went back on what can be considered an embedded device. In this talk the definition was quite a bit reduced: we assumed a Linux kernel available but also a GPU and connectivity we’re kind of used to. A bit of a luxury embedded if you wish. 😉

In any case this is a nice challenge to invest in, it can also lead the way to more use of the KDE stack in the industry.

For such system integrations, we’re using the Yocto ecosystem as it is the industry standard. We provide several Yocto layers already: meta-kf5, meta-kf6, meta-kde and meta-kde-demo. This covers KDE Frameworks and Plasma but none of the apps.

The range of supported hardware is already interesting. It covers among others the Raspberry Pi 4, the Vision Five 2, the Beagle Play and the Beagle V. The RISC-V architecture is definitely becoming very interesting and getting quite some traction at the moment.

Plenty of dev boards have been produced during the last few years. The pain point on such devices is generally the GPU, even more so on RISC-V unfortunately.

Our stack has plenty to provide in this context. meta-kf5 or meta-kf6 could be used in industrial products of course, but Plasma and applications could be a good benchmark tool for new boards. We might want to provide extra frameworks and features for embedded use as well.

The biggest challenge for this effort is to make things approachable. The first Yocto build is not necessarily a walk in the park.

Sunday

Keynote: Kdenlive - what can we learn after 20 years of development?

This keynote gave a good overview of the Kdenlive project. This is in fact a much older project than I thought. It was started in 2003 but kind of got stuck until the actual maintainer revived it. Also it’s a good example of a project which had its own life before joining KDE officially. Indeed it became an official KDE application in 2015 only.

They explained how they keep the conversation open with the user base and how it feeds the vision for the project. It’s no surprise this is such a nice tool. The user base seems diverse, although the personal use is dominant. Still, its used in schools and by some professionals already, maybe we can expect those user groups to grow in the coming years.

They have a couple of challenges regarding testing and managing their dependencies. Clearly its on their radar and we can expect this to get better.

The fundraising effort paid off. It already allowed the maintainer to reduce the work time at his current job, he can devote one day a week to Kdenlive work.

Finally we got a tour of exciting new features they released. Most notably the nested timelines but also the support of speech to text to help creating subtitles. They won’t stop here though and they hope to bring more AI supported tools but also improve the GPU support and provide online collaborative spaces.

Make it talk: Adding speech to your application

The first lightning talk I’ve seen on Sunday was advocating for more text to speech uses in our applications. Indeed it can have some uses beyond accessibility.

It also made the case that it’s actually easy to do through Qt which provides the QtSpeech module for this with a simple API. The good news being that it is supported on almost all platforms.

The Community Working Group - Keeping a Healthy Community

Another lightning talk, this time about the Community Working Group. It didn’t a good job debunking some myths regarding that working group. It is indeed not a “community police” but it’s mainly here to help the community and provide assistance in case of issues.

They have a complex job aiming at maintaining healthy community channels. It involves making sure there is no misunderstanding between people. This is necessary to avoid loosing contributors due to a bad experience.

An OSS Tool for Comprehending Huge Codebases

Interesting talk about a tool allowing to explore codebases. Having a knack for this and having done it quite a few times in the past obviously I was eager to attend this one.

The tool is made by Codethink and funded by Bloomberg. It uses LLVM to parse C++ code and feed a model of the code stored in a relational database. In particular it takes care of finding all the C++ entities and their dependencies. There’s also traceability on which source and header files the entities and dependencies come from.

On top of this model they built visualizations allowing to track dependencies between packages. It also allows to inspect where dependencies are coming from and it makes the distinction between dependencies coming from tests or not. It also provides a plugin mechanism which allows to impact the behavior of steps in the pipeline. And last but not least, command line tools are provided to manipulate the database. This comes in handy for writing checks to enforce on the CI for instance.

They took the time to try the tool on KDE products. This is after all a big corpus of C++ code readily available to validate such a tool. This way they showed examples of cyclic dependencies in some places (like a Kate plugin). They’re not necessarily hard to fix but can go unnoticed. Another interesting thing they attempted was to use hooks to tag modules with their tiers. Which would then allow to differentiate tiers in the dependency graphs allowing to see if we have any violation of the KDE Framework model.

They have plans for providing more features out of the box like tracking unused includes, spotting entities used without being included directly, etc. This could be interesting, clearly it aroused interest in attendees.

Matrix and ActivityPub for everything

This short talk went over the Matrix and ActivityPub protocols. Both are federated but the speakers highlighted the main differences. In particular Matrix is end to end encrypted for personal communication uses, while ActivityPub is not encrypted and tailored for social media uses.

They also emphasized how both protocols are important for the KDE community and how they can be used. Some of the ideas are upcoming features which are already implemented.

In particular we’ve seen a couple of scenarios for location sharing over Matrix so that you can get it to and from Itinerary or share vie NeoChat. There’s also the future possibilities of synchronizing Itinerary data over Matrix or importing Mobilizon event in your calendar.

Selenium GUI Testing

Remember when I mentioned a recurring theme during the session about the KDE Goals? I hope that by now you realized this was about Selenium. So of course, it was to be expected that we would have a session about it. After all this effort to use Selenium for GUI testing helps push forward all of our current community goals.

What has been created so far allows to easily write GUI tests reproducible locally. This way we could catch up with industry standards, we were clearly falling behind in term of GUI testing.

Selenium is known for being web oriented, but it can be used in other contexts. What you need is mainly a WebDriver implementation and this is exactly what has been created. So we now have such an implementation bridging between Selenium and AT-SPI the protocol used for accessibility support.

One nice trait of all this which I noted is that the tests are run in a nested Wayland session. This avoids leakage with the host session. Also the session is screen recorded so we can see what happened in it after the fact if needed.

Now help is needed for more such tests to be written using this bridge. Doing so will help with all of our current goals.

Kyber: a new cross-platform high-quality remote control software

After lunch we had a whole series of lightning talk. The first one demoing Kyber. This is a new solution coming from VideoLAN to control machines remotely.

The results are so far impressive. You can play a game from Linux remotely controlling a Windows machine for instance. The delay over a 4G connection is spiking at 40ms maximum, but most of the time is close to 20ms. This means in most cases around a 1.5 frames delay if playing at 60 frame per seconds.

On the network level it uses QUIC and uses a few tricks to have crisp rendering of the image, including text, despite the compression. Of course it is portable and both the client and server are available for various platforms. It can also leverage hardware for better performances.

Impressive and exciting. Looks like we might have a very viable FOSS alternative to TeamViewer soon.

Fun with Charts: Green Energy in System Monitor

Next lightning talk was about a personal project bringing information from a solar panel installation all the way to a Plasma desktop. Indeed, those installations tend to be coupled to proprietary cloud applications, it’d be nice to not go through those to control your installation.

We were shown funny uses. Like a KInfoCenter module summarizing all the available data, or a KDED notifier which indicates the first ray of sun in the day, the storage battery status etc. And of course some command line tools to script the system allowing for instance to turn on and off services based on the amount of energy available.

What has qmllint ever done for us?

Another lightning talk, this time about qmllint. It went through the history of this tool which went from being only able to tell if a file was a QML one or not, to providing lots of warnings about missuses of the language.

Now it’s even possible to integrate it in the CI via a JSON file and it’s the base of the warnings we get in the QML LSP support. And last for not least, I learned it even has a plugin system nowadays allowing to extend it to provide more project specific checks.

It became quite powerful indeed.

Wait, are first-run wizards cool again?

The last lightning talk of the track was about our new first-run wizard. It has been introduced for good reasons, this time we’re not making it for users to configure some settings like look and feel.

This is about on-boarding the users on first use. For instances it helps them access the internet if needed, it introduces them to the important Plasma concepts, it gives them an opportunity to get involved, and it also remind them that donations are possible.

This is definitely done in a different spirit than the old wizard we had back in the days.

The End?

This was only over two days for me… But this is not over yet! The BoFs are going on strong for the rest of the week (even though I unfortunately won’t attend them this year).

Also there will be a training day. If you’re interested in how the KDE Stack is organized, make sure to not miss the training I will hold online on Thursday morning.

Make sure you commit anything you want to end up in the KDE Gear 23.08 releases to them

During this week Akademy 2023 is going on in Thessaloniki, Greece. It’s always awesome, to see many old friends and getting together with that amazing hacker community which is KDE.

There, me and Niccolò gave a talk about what;s happening in Plasma 6 and what will change, Noccolò on more visual things, about some changes we are cooking on the UI and on the visual themes. Here you can find a recording of the talk (alongside all the others of the day)

I talked more about the work I’ve bein doing in the Plasma shell during the last couple of months: code rafactors and how the API for writing plasmoids will change.

There were many things we were not quite happy about and now with the major release is the occasion for streamlining many things.

Now, It’s very important those changes are are well communicated, and easy to do for developes, because there are *a lot* of 3rd party plasmoids on the KDE store, which people are using and enjoying.

Let’s go trough the most important changes:

Dataengines

Dataengines were an API designed in early KDE 4 times, especially one of for our first offereings of Plasmoid API which was the pure JavaScript API, which existed long before the QML existed.

But now in a QML world, their API doesn’t really fit, instead is a much better fit having a QML extension which offers classes with all the needed properties, data models and signals that provide access to the needed data, such as tasks, notifications etc.

Dataengines are now deprecated and moved into a separed library, called “plasma5support” which will be still available for the time being, but consider porting away from it as we plan to eventually drop it.

Base Plasmoid API

The way plasmoids are declared in QML changed a bit: we used to have a magical “plasmoid” context property available from anywhere. This was an instance of a QQuickItem which was both the item where all the plasmoid contents were *and* a wrapper for some of the api for the central plasmoid object: the C++ class Plasma::Applet.

Now the access to plasmoid is an attahced property, the (uppercase) “Plasmoid”, which is directly the access to the instance of the central Plasma::Applet, without an in-between wrapper anymore.

The central QQuickItem is now called “PlasmoidItem”, and must be the root item of the plasmoid, just alike ApplicationWindow is for applications.

PlasmoidItem will have the purely graphical properties, such as the “compactRepresentation” or “fullRepresentation”

Here is a very minimal example of a plasmoid main file under plasma6:

import org.kde.plasma.plasmoid 2.0
PlasmoidItem {
    Plasmoid.title: i18n("hello")
    fullRepresentation: Item {....}
}

Actions

Plasmoids can export actions to their right mouse button menu, such as “mute” for the mixer plasmoid and so on.

In Plasma 5 we had an imperative API to add those actions, which was again coming from that old pure JS API, which really looked a bit out of tune in QML. In Plasma 6 the API has been replaced with a completely declarative API, in this form:

PlasmoidItem {
    Plasmoid.contextualActions: [
        PlasmaCore.Action {
            text: i18n("Foo")
            icon.name: "back"
            onTriggered: {...}
        },
        PlasmaCore.Action {
             ...
        }
    ]
}

PlasmaCore.Action is actually a binding to QAction (not the internal QML action type), so that it can be shared between C++ and QML easily

SVG theming

Plasma Themes don’t really have changed for now (and you can expect any old theme from the store to keep working), but the C++ and QML API for them has been moved to a standalone framework called KSvg. Plasma Svgs have quite some interesting features over the pure QtSvg API, such as disk caching of the rendered images, stylesheet recoloring to system colors and the 9 patch rectangular stretched images of FrameSvg.

Some applications were interested in using that, but couldn’t due to the long dependency chain of plasma-framework, so now they can be used as a much more manageable compact framework, offering both the usual C++, QPainter based api and QML bindings.

import org.kde.ksvg 1.0 as KSvg
FrameSvg {
    imagePath: "widgets/background"
}

Kirigami all the way down

Designing Kirigami in the beginning we lifted two concept from the Plasma API (which again we couldn’t use directly due to the dependency chain) Theme and Units

Theme gives access to the named system colors, and Units to standard spacing and animation durations.

Over the years the Kirigami version got way more advanced then the Plasma version, and having this code duplication didn’t make much more sense, to in Plasma6 whenever referring to a named color or an unit, the Kirigami version should be used, as the Plasma version is going away.

import org.kde.kirigami 2.20 as Kirigami
RowLayout {
    spacing: Kirigami.Units.smallSpacing
    Rectangle {
        color: Kirigami.Theme.backgroundColor
        bordere.color: Kirigami.Theme.textColor
    }
}