A couple of months ago I improved some of our dialogs and this time I worked on some more. Did you know that you can just paste the clipboard’s content into the Dolphin file manager or on the desktop to create a new file from it?

Tobias Fella added a proper “platform message dialog” for Qt to use. This replaces the hideous Qt Quick message dialogs you could see in some places. With that, we are also finally able to play our message box sounds for Qt-only applications using QMessageBox (instead of KMessageBox or KMessageDialog). To do this, Qt sends an QAccessible::Alert event that is then handled by the relevant platform accessibility integration. On Windows it for example calls the win32 PlaySound API. However, I didn’t want to mess with Qt’s AT-SPI¹ stack just for this. Now that we provide a custom dialog, we might as well play the sound from there.

Just like the “New File” dialog, the paste dialog mentioned above also displays the file icon now. It also tries to guess what kind of file it is and automatically suggests a matching file extension. For example, copying something that looks like HTML will suggest the name “pasted file.html”. You are of course still free to choose a different file name and extension.

An application can also suggest a name using the custom application/x-kde-suggestedfilename MIME type. Spectacle does this so a screenshot copied to clipboard and then pasted (rather than saved directly) will nevertheless use a “Screenshot_xyz” file name. The clipboard history now remembers the suggested name when it stores an entry so when you recall it later it will still use that name as expected.

When dropping a folder into Kate, all files contained within will be opened. Kate has always been able to open files on remote locations thanks to KIO but the drag and drop code only worked with local folders. This is now fixed and you can drop a folder from a SMB or other share into your Kate the same way as any local one.

A nifty addition to both the menu and settings page for choosing a syntax highlighting color scheme is a little preview icon similar to the application color scheme. This lets you roughly judge the appearance of the theme before selecting it.

Finally, KWin’s debug console (Open KRunner, type “KWin”) received a “Pick Window…” button. This way you can more easily find a particular window in the potentially long list of windows. The kwindowprop tool (KWin’s equivalent to xprop) now also includes the PID of the process owning the window.

1. Assistive Technology Service Provider Interface, a cross-desktop accessibility framework ︎

This week I shipped two new features for KeepSecret. KWallet XML Import (!34)

The Import menu on the wallet page is now a submenu with two options:

-KeepSecret…

-KWallet XML…

Both import formats are converted into the same internal format, allowing them to use the existing import code. I only implemented import support, since exporting to the old KWallet format wasn't necessary because KWallet is being deprecated.

Password Generator (!35)

I added a Generate button to the Create New Entry dialog. Clicking it generates a random 16-character password and fills the password field.

The password is generated in SecretItemProxy::generatePassword() using QRandomGenerator::global(), which uses the operating system's secure random source. A character set is built from the selected options (lowercase letters, uppercase letters, numbers, and symbols), and each character is chosen randomly from that set. This also allows passwords to include symbols like !@#$%^&*.

The function returns a QByteArray instead of a QString, matching the existing code and avoiding an unnecessary copy of the secret in C++.

During code review, Michael K83 pointed out that secrets stored in normal QByteArray or QString objects are not automatically erased from memory after use. He suggested looking at how ksecretd and KeePassXC handle secure memory.

Marco Martin explained that an even bigger challenge exists once the password reaches QML. The password becomes a QString inside the QML engine, where Qt may create multiple internal copies that cannot be explicitly cleared. It will be addressed separately in issue #25.

Over 180 individual programs plus dozens of programmer libraries and feature plugins are released simultaneously as part of KDE Gear.

Today they all get new bugfix source releases with updated translations, including:

• elisa: Change output device when global output is changed (Commit, fixes bug #512126)
• kdeconnect: Fix file transfers when notification sending is enabled (Commit, fixes bug #516765)
• kdenlive: Fix timeline playhead going out of view while playing (Commit, fixes bug #517494)

Distro and app store packagers should update their application packages.

• 26.04 release notes for information on tarballs and known issues.
• Package download wiki page
• 26.04.3 source info page
• 26.04.3 full changelog

At FOSDEM 2025 I presented my (intentionally controversial) proposal how to keep copyright and licensing info in minified JS/CSS and asked for feedback, including from front-end developers.

Two months later, I took the feedback from FOSDEM and held a small workshop session with a group consisting of OSPO leaders, FOSS lawyers and a handful of FOSS developers at LLW 2025.

This blog post was finished¹ more than a year after both, so I will not be summarizing my FOSDEM talk, and suggest you listen to it (esp. the Q&A part), if you are interested in the details.

But I will summarize the results of both sessions below.

Are SDPX IDs enough for compliance or not (given their templating)¶

Someone argued that for certain licenses – specifically, e.g. the MIT and BSD family – even the SPDX License List has a some templating in place, and as such identifying it with just an SPDX ID would not fulfil the license obligations, by strict reading of the license.

That is a concern that I identified already in my original proposal and I agree that my proposed approach has a certain amount of “handwaving”, which is not 100% risk-proof.

(Spoiler: we fix this issue in the final proposal. Wait for the next blog post in this series.)

Impact on size of the minifed code¶

A common concern from web developers was how much keeping the SPDX/REUSE tags in the minified code would impact the its size.

With the help of the wonderful Lukas Taegert-Atkinson of Rollup fame, we managed to get a good idea what the impact adding REUSE/SPDX tags to all the files would have on the size of the minified code.

As an PoC Lukas made the following change to the build process of Rollup Browser, so we could compare the size of the minified code before and after the diff.

diff --git a/rollup.config.ts b/rollup.config.ts

--- a/rollup.config.ts  (revision 384d5333fbc3d8918b41856822376da2a65ccaa3)
+++ b/rollup.config.ts  (date 1742569205307)
@@ -152,7 +152,22 @@
            collectLicensesBrowser(),
            writeLicenseBrowser(),
            cleanBeforeWrite('browser/dist'),
-           emitWasmFile()
+           emitWasmFile(),
+           {
+               name: 'add-fake-tags',
+               transform(code) {
+                   return {
+                       code: `/*!
+* SPDX-SnippetBegin
+* SPDX-SnippetCopyrightText: © 2021 Test Dummy <dummy@test.example>
+* SPDX-License-Identifier: BSD-2-Clause
+*/
+${code}
+/*! SPDX-SnippetEnd */`,
+                       map: { mappings: '' }
+                   };
+               }
+           }
        ],
        strictDeprecations: true,
        treeshake

If Rollup Browser was built as per default, the full minified code resulted in 374 KiB.

After the patch that caused (dummy) snippet-level SPDX tags to be inserted into all the code (Rollup itself and its dependencies), the size grew to 415 KiB though.

That is a 11% increase in size. Not exactly negligible, but definitely far from terrible. And if tooling were to be updated, with de-duplication we could possibly take that number down quite a bit too.

In the previous tiny Svelte + Rollup + Terser PoC, both with and without SPDX tags are 12 KiB, so we need take a magnifying glass to compare 12.681 bytes with tags, and 12.324 bytes without them – that is just a 3% difference.

And in the previous React Scripts (+ WebPack + Terser) PoC, the overall build size is virtually unchanged, but oddly enough while some files become bigger, others become smaller.

With REUSE tags, the total size of build/static/ is 536 KiB (specifically, 531.070 bytes):

build/static/css:
.rw-r--r-- 1.038 hook  3 apr 01:54  main.05c219f8.css
.rw-r--r-- 1.759 hook  3 apr 01:54  main.05c219f8.css.map

build/static/js:
.rw-r--r--   4.534 hook  3 apr 01:54  453.2a77899f.chunk.js
.rw-r--r--  10.597 hook  3 apr 01:54  453.2a77899f.chunk.js.map
.rw-r--r-- 143.544 hook  3 apr 01:54  main.608edf8e.js
.rw-r--r--   1.205 hook  3 apr 01:54  main.608edf8e.js.LICENSE.txt
.rw-r--r-- 368.393 hook  3 apr 01:54  main.608edf8e.js.map

and without the SPDX tags, the total size of build/static/ is also 536 KiB (specifically, 529.880 bytes):

build/static/css:
.rw-r--r--   779 hook  3 apr 01:53  main.f855e6bc.css
.rw-r--r-- 1.427 hook  3 apr 01:53  main.f855e6bc.css.map

build/static/js:
.rw-r--r--   4.534 hook  3 apr 01:53  453.2a77899f.chunk.js
.rw-r--r--  10.597 hook  3 apr 01:53  453.2a77899f.chunk.js.map
.rw-r--r-- 143.544 hook  3 apr 01:53  main.608edf8e.js
.rw-r--r--   1.070 hook  3 apr 01:53  main.608edf8e.js.LICENSE.txt
.rw-r--r-- 367.929 hook  3 apr 01:53  main.608edf8e.js.map

Which is a difference of measly 0.2%.

Lukas was also quick to point out that a ballpark estimation of how much extra space this would take is quite easy to calculate, as all it is needed is to count all files that would be included in the final JS (or CSS) bundle and multiply that with the size of the SPDX tags. As such, the impact would be bigger on projects that have many very short source code files, while smaller on those that have fewer, but longer source code files. Again, this is without taking any de-duplication into account.

So we can come up with a generic formula:

size = normal_minified_size + (number_of_files × 4_extra_lines)

What was the cause of the problem with the Snippet-Begin and Snippet-End tags?¶

You may recall in my original proposal that there was an issue with the SPDX-Snippet-Begin and SPDX-Snippet-End tags being jumbled in the resulting minified code.

According to Lucas, this is most likely something Terser caused when associating comments to functions and then optimizing the code. He is fairly positive it can be solved though.

(Again, spoiler: this will be a moot issue in the end. Wait for the next blog post.)

Do we need tags in the minified code?¶

Of course, a very good question is whether we need the REUSE/SPDX tags in the minified code itself. Especially, given that we do not require something as strict for other non-source code (e.g. compiled code).

I admit, I do not think we actually need to.

To be honest, why that is in the original proposal, is because I was trying to push just how far we can bring license compliance in client-side JS/CSS by just leveraging already existing standards and tools. It turns out we can push it very far – arguably ad absurdum ;)

So, no, I do not think we need that, but it was a good thought experiment and I think it was necessary to get discussion going².

Alternative proposal: SBOM¶

But if we do not keep it in the code we ship, where do we keep the license/copyright info then?

At LLW 2025 we had a pretty intense session where ultimately we came up with an alternative proposal to generate an SBOM and ship that instead. This solves a lot of issues and is something that license compliance officers are already familiar with. It would also bring it closer to how we manage licensing when shipping non-web software.

The SBOM approach would require use of tooling and by the end of the day we were left with a bunch of loose threads, but in general, this sounds like a good way forward.

Conclusion: plan B in the making¶

Was all the effort now wasted?

Not at all.

Web pages and (SaaS) web applications are still a bit of a different beast, so we learned a lot in the past two years due to this exercise.

I am pretty confident we now have a way how to fulfil the license obligations:

• without making the web page too heavy;
• burdening web developers any more than other programmers;
• shipping machine-readable compliance artifacts; as well as
• making the information ready for human consumption too.

In the next blog post I will present the final proposal.

hook out → I think we’re slowly onto something …

Welcome to another edition of “This month in KDE Linux” — KDE’s in-progress operating system.

This month was pretty smooth; we had no build delivery drama, and all OS images we shipped were of satisfactory quality. The project is maturing, and we’re 78% of the way towards completing the beta milestone.

QA & testing

Bhushan Shah and Thomas Duckworth continued working on the project to build a robust and modern automatic QA system. It’s really really close to being integrated at this point, and will act as a full-stack integration test for all of KDE Plasma in addition to a test system for KDE Linux specifically.

More user-friendly installation

Hadi Chokr did the huge amount of work necessary to transform KDE Linux’s .raw image file into a hybrid image that’s also a valid .iso file! This allows KDE Linux to be installed more easily using VM software that often expects to be given an .iso file.

Remember that you’ll still need to turn on UEFI mode, as KDE Linux still intentionally doesn’t support the legacy BIOS system!

Better audio CD ripping

Harald Sitter, Jan Rathmann, and I completed a small project to get KDE’s Audex app up on Flathub as a replacement for the audiocd-kio software we had previously been pre-installing on the image.

The problem with audiocd-kio is that it included two System Settings pages of questionable utility that offered a fairly old-fashioned UX. Now we don’t include those things, and instead we document how to download Audex and use it to rip CDs. And this way, you get automatic metadata lookup, too!

Easier log collection

Felix Araújo built a tool to ease the collection of logs called collect-logs. It also does some data sanitization. This will be very useful for bug reporting purposes!

Rudimentary “Developer Mode”

I created a very simple system to show and hide developer tools, and they’re hidden by default until you run toggle-developer-mode, which is documented here.

This reduces clutter in the launcher widgets of users who aren’t software developers. In the future we’ll add more to this script, and we might consider moving more tools off the base image and into Flatpak apps or even downloadable meta-packages, thereby coming full circle by re-inventing packaging. Go figure.

Documentation

I wrote documentation for how to configure input methods for Chinese, Japanese, Korean, and Vietnamese text input, in consultation with several speakers of these languages.

And in the near future, we plan to pre-install some of these tools to make things easier for the world’s 1.7 billion people who use one of them to communicate on their digital devices.

Grab bag

Thomas Duckworth made Plasma Browser Integration continue to be enabled by default with the latest version of Firefox.

I fixed ydotool, which I had previously broken by trying to force to run as a systemd service. Turns out it can’t do that. So now it’s at least disabled by default.

Yago Raña Gayoso enabled shell completions for kde-builder.

Aleix Pol Gonzalez removed a few pre-installed GTK libraries that it turns out weren’t used for anything.

Vishal Rao prevented the live session from writing to the system’s real-time clock, which could be a nuisance for people who don’t end up installing the OS and go back to their already-installed OS.

Clément Villemur made the Calamares installer not bug you to connect to the internet, because it doesn’t actually need internet access.

And that wraps up June! There are a lot of projects in flight right now, from finishing up the new QA system, to building moving the base OS with BuildStream, to hardening the kernel, to improving each image’s changelogs.

So there’s still lots to do! If you’re a fan of the project, please help out; there are many ways:

• User support: help support people on discuss.kde.org using KDE Linux.
• Issue reporting: install KDE Linux and report issues.
• Documentation: improve docs; submit merge requests here.
• Flatpak: fix packaging or code issues in Flatpak-packaged apps.
• OS development: help build KDE Linux! There’s plenty to do.

Rust has achieved something extraordinary: it genuinely excites people to write software. But when it comes to building a real user interface, the ecosystem is still finding its footing. There are numerous options to pick your Rust UI framework from, including those gaining traction, like Iced and egui. Most of the available UI frameworks, however, are still establishing themselves in production environments and fall short in feature-richness. Qt Bridges, a bridging technology in public beta for Rust, brings something different to the table: over three decades of real-world use, commercial support, and a framework that already runs in automotive dashboards, medical devices, and industrial systems worldwide. Qt Bridge for Rust makes that maturity available to Rust developers, providing access to a UI framework that lets you keep your Rust codebase while using Qt Quick’s feature-rich UI libraries and APIs, hardware acceleration, and genuine cross-platform support.

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

A while ago, Steam OS 3.8 was released. Among its many improvements, it includes a particularly important one for the Desktop Mode: it finally uses a Wayland session by default.

There are many reasons why this is important for both us and our users. It is more stable, more feature-rich, and does a better job showcasing what Plasma can do.

For now, though, I just want to highlight one neat little feature that is especially handy on a touchscreen device like the Steam Deck: touchscreen gestures.

Out of the box, a three-finger vertical swipe enters Overview mode, showing thumbnails of all open windows. This provides a much more touch-friendly way to multitask, and you can also close a window with a downward swipe gesture. Of course this is a feature available on any device with a touchscreen.

For a while now, my colleagues and I over in Techpaladin Software have been working on software support for the Steam Machine, so it’s so awesome to see the product released!

Like everyone else, I was surprised by the pricing… until I went out and looked at what other hardware costs these days. It seems like in the past 6 months, everything with RAM got 50-100% more expensive. It’s kinda nuts. In light of, shall we say, industry trends (ahem), the price seems reasonable to me.

…especially if you see it less as a single-purpose gaming console and more as a desktop computer that offers a 10-foot UI living room gaming experience. Its horsepower is competitive for the price, and it offers the flexibility of a well-integrated desktop PC user experience. But don’t take it from me; ask Linus Sebastian, who’s rapidly becoming one of the biggest KDE boosters on YouTube:

Some choice quotes from the video:

And from the moment I fired it up and said “goodbye Steam Big Picture Mode”, and started using it as a desktop, I went… “This is what I’ve been waiting for the whole time.”

– Linus Sebastian

Plasma’s great.

– Linus Sebastian

“Plasma on retail hardware” has been my long-term goal for KDE since I first got involved a decade ago. This product is another example that not only can it work, but it can be as good or better than competing offerings.

So congratulations to everyone in KDE and outside of it who helped make this a reality! I’m unbelievably happy at how well KDE software is working for this use case these days, and I see even greater things in the future.

When working on a software library which is targeting 3rd-party consumers, it is rather of self-interest to make the library uncomplicated to use. Unless perhaps there is opportunity seen in having to help out in the process

And to know if it is uncomplicated to use, best before learning otherwise the hard way, one has to take the position of the consumers. Even better if this can be automated, after all that is why people developed machines, like computers, to pass on the dull part.

Many things of a library can be tested during the build, based on the sources and build artifacts. Like functionality of methods, proper export/visibility of their public entry points or the code any special pre-processor macros are resolved to. Here CMake’s VERIFY_INTERFACE_HEADER_SETS also offers a solution to verify that headers can be included on their own, though being bound to the build interface of the library.

Now, the consumer will only see the installed files, and there are for one things that can go wrong when installing even already tested files, as are there files which only work in the installation location or might work differently there, so can be only properly tested there.

Public Header Fails

When about to use a feature of a library, one would see to apply the documented needed include statement. E.g. when writing code dealing with the class KContacts::Picture of the KDE Frameworks module KContacts, the docs hint to use the following include to have any needed declarations available:

#include <KContacts/Picture>

So what could go wrong with such header file (e.g. Picture in the example above):

• the header file is not installed
• the header file is not placed in the relative location as by the documented include statement and the official include search directories
• the header file includes another header from the same library that is not installed (e.g. for test utils)
• the header file includes another header from the same library which is placed in a relative location not resolvable by the official include search directories
• the header file includes another header from a private dependency, so not resolvable by the inherited official include search directories
• the header file uses language features unconditionally of a standard not enforced in the public build flags
• the header file relies on macro definitions not provided correctly, either missing or with wrong value
• the header file is not self-contained with the variants of the headers part of the installation (violating C++ Core Guidelines, SF.11: Header files should be self-contained)
• (… possibly more, please mention in comments)

All these can be mainly checked by simply creating a C++ source file which only includes the very header file, by the documented include statement, and testing for its successful compilation/code parsing, applying the official include search directories and build flags (and the inherited ones of public dependencies).

CMake Config Fails

When about to use a library at all, one would see to use the meta data blobs which also integrate with one’s (meta) build system. E.g. in case of using CMake and as in the example above KF module KContacts, one would for setting up building against the library do as documented, relying on the CMake config files provided:

find_package(KF6 REQUIRED COMPONENTS Contacts)
target_link_libraries(MySoftwareProject PRIVATE KF6::Contacts)

So what could go wrong with those CMake config files:

• the CMake config files are not installed
• the CMake config files are not installed by the correct name and in the correct location
• the library target is not provided by the CMake config files at all
• the library target is not provided by the documented name and the optional namespace
• the library target does not have the correct include search directories set
• the library target does not have the correct build flags set
• the library target misses some documented properties
• the library target misses a dependency in the public link interface, to inherit as needed include search directories and build flags
• the library target has an item in the public link interface not checked for by the CMake config files
• other documented utility targets or variables are not defined or have wrong values
• (… possibly more, please mention in comments)

Most of these issues can be simply checked by creating a CMake project which searches for the library and links some dummy software to it, and testing for its successful configuration and build.

Other Fails

There are further library-related artifacts which should see checks after installation.

Any resources used from a library which are installed as separate files, like translation catalogs, images, sounds, or domain-specific data, could again be missed to be installed, installed by a wrong name or into the wrong location, or otherwise be badly processed before or during the installation process. Those are not specific to libraries though, thus not looked at more here.

Other artifacts are some which themselves are to be built against the library, such as project templates (like the KAppTemplate ones, e.g. for plugins) or examples for using the library. Those are not critical to the direct usage of a library though, thus also not looked at more here.

Continuous Integration As Limited Safe Guard

Software libraries are usually not developed in a void, but based on needs by other software. Changes in the public interface are made together with the respective changes in at least one consumer. So many issues would be detected in the process.

Then the library and many of its consumers, not just the ones a changes was made for, might be part of the same CI setup, where all these consumers would see at least some regular rebuild against the latest version of a library and thus would catch further regressions before the next release of the library.

But not all API of a library might be used by those known consumers, instead only by 3rd-party without any integration into the library development. And some issues of API while used can be shadowed by the usage pattern. So for a more complete check some generic own solution is needed.

Some Automation: ECMInstalledLibraryCheck

Combining the simple check ideas for headers and CMake config files above, some addition to KDE’s Extra CMake Modules is proposed in this merge request: ECMInstalledLibraryCheck. That module provides a macro to add checks for the installed library artifacts, from consumer POV. Currently it covers the public headers (includability) & CMake config files (proper data delivery needed for compiling). It adds one global target all_installed_library_check, to run the checks for all libraries, and a target per library, <library_target>_installed_library_check. Those targets would be used after installation only, obviously.

For the example used above, KF’s KContacts library, the check would be deployed like this:

# use the module from ECM
include(ECMInstalledLibraryCheck)
# for the library target KF6Contacts set up the check
ecm_add_installed_library_check(KF6Contacts
    PACKAGE_NAME "KF6Contacts"
    PACKAGE_VERSION ${KCONTACTS_VERSION}
    PACKAGE_TARGET_NAMESPACE "KF6::"
)
# register the official include statements for the check
ecm_installed_library_check_include_strings(KF6Contacts
    HEADERS ${KContacts_CamelCase_HEADERS}
    PREFIX KContacts
)

Given the library target KF6Contacts thus this adds the target named KF6Contacts_installed_library_check. This target generates and builds a separate CMake-based project for a dummy library linking against the installed library, whose sources are one source file per passed include string, with a single code line #include <include_string>. The check is considered passed if the builds completes without an error.

Additionally the checks can be extended to also cover CMake variables or preprocessor defines, by functions like ecm_installed_library_check_cmake_variable(), ecm_installed_library_check_compile_definition() and ecm_installed_library_check_preprocessor_macro(). The last also has some convenience variant ecm_installed_library_check_version_preprocessor_macros(), in our example deployed like this:

# check all includes also have the usual version macros defined afterwards, only report errors
ecm_installed_library_check_version_preprocessor_macros(KF6Contacts
    PREFIX KCONTACTS
    VERSION ${KCONTACTS_VERSION}
    SILENT
)

The current state of the prototype has already found a number of existing issues in a number of libraries, which so far had not yet been uncovered by consumers’ usage pattern, and first fixes have been rolled out to prevent consumers hitting them in the future.

It also has exposed a principal issues with projects like some KF modules that provide multiple libraries, yet only a single CMake config file for their module. Such file would need to ensure the combined dependencies of all libraries, which then adds unneeded burden to consumers of just one library. Currently the dependency checks in KF CMake config files are rather pragmatically added, when existing consumers stumble over something missing.

Hurdles To Adopting The Check Automation

Checks can only return value for the cost of integrating them if they are also routinely applied and their results considered. Worse, if not used they run chance of bit-rot and actually clutter a project.

Typically a library has a suite of auto-tests, covering all the features. While developers are encouraged to use them on their local system during development, they are at least used on the central CI system, against as many platforms and configurations as possible.

A first challenge with merging post-installation checks to the other checks and tests is that auto-tests are usually designed or at least prepared to be run pre-installation. KDE has had some “Running apps uninstalled” initiative, which resulted at least for auto-tests of KDE Frameworks to be also run on CI before installation. CMake only has the concept of one suite of tests, without an idea of pre-installation and post-installation test times. So one would have e.g. to create some custom system on top, e.g. by using CMake/CTest test labels. And for CI do extra work to run and process the two sets of tests separately.

Another challenge is that like all tests the ECMInstalledLibraryCheck checks come at a cost. While their creation is quickly done (generating a buildsystem file), the execution is taking some time. Because it mainly consists of a full compilation per each tested include statement, which despite just being a simple include line still results in lot of processing due to all the implicit overhead, even more when transitively including many template-ridden headers. And being a new system with some people the cost will scale the normal “don’t need this, never done that, no changes wanted” reaction.

Collaboration Wanted

The author is currently done when it comes to own immediate desires for the features of ECMInstalledLibraryCheck and uses it in personal projects as is. It has been though developed in the (KDE) public with the intent to share it, to have it be useful to others like KDE projects and gain from common usage and feedback.

Not being a CI system person, the author now is mainly looking for someone who can work on integrating the execution of ECMInstalledLibraryCheck checks with KDE CI (or also their own projects’ CI). The idea would be that the check of the installed library artifacts is as useful as any unit test, to catch issues with new code and regressions immediately, so should be run along the normal unit tests, just in its own post-installation stage. This stage could also later see the addition of post-install checks for templates and examples as well as other things which are found useful to test post-install. Ideally the check result would be integrated into the test result display, but for a start just successfully completing the build target should be already useful as indication. Possibly projects would opt in to the test using some configuration flag, or in case of KF could default to it. Perhaps CI integration will also require certain things from the macros, so ideally the CI deployment can be sorted out before ECMInstalledLibraryCheck gets merged and released. So if you find this kind of check useful and are experienced with (KDE) CI setup, please get in contact.

Then post-installation check of library artifacts might have further constraints or desires with some. Would people need doing parallel test of the installed library with different configurations or usage flags? Would people like to use this in cross-compilation (so far no generated code is executed, so in theory should be usable) and does that need further support? Are there other aspects of the installed artifacts you would like to see covered? Please give the current state of the check module a try for your own library projects and get in contact.

Try ECMInstalledLibraryCheck: Does Your Library Pass?

The file ECMInstalledLibraryCheck.cmake should only depend on CMake, so can be just copied into your own project:

• download the raw file from https://invent.kde.org/frameworks/extra-cmake-modules/-/blob/work/kossebau/ECMInstalledLibraryCheck/modules/ECMInstalledLibraryCheck.cmake
• create subdir cmake/ecmcopy in your project, place ECMInstalledLibraryCheck.cmake inside
• make subdir known to CMake: list(APPEND CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/ecmcopy)
• include module: include(ECMInstalledLibraryCheck)
• setup check for your library targets, see docs at begin of module file how to do that
• run the installation target, then the target all_installed_library_check
• see how per library a project “InstalledLibraryCheck” is generated and build, the build log serves as success report
• if the check build fails, try to fix it, install (easy to forget ) and run the check target again
• if curious, peek into the build directory and look at the generated file ${library_target}_ECMInstalledLibraryCheck/CMakeLists.txt, it holds the complete check and can be also played directly with
  

The author has done this with many projects already, in KDE for all of KF modules as well as some graphics, games, multimedia, utility and education software libraries.

Now go and check your own library, and report back how useful ECMInstalledLibraryCheck is for you, what issues it discovered and what your further needs are here