September 12, 2019

A few Kubuntu Members (and Councillors!) met Thursday before KDE Akademy’s end. We discussed the coming release (will be 19.10) and the upcoming LTS (20.10) – which will be Plasma LTS *and* Qt LTS. This combination will make this LTS super-supported and stable.

We also discussed snaps and when Ubuntu possibly moves to “all snaps all the time” for applications at least. This may be in our future, so it is worth thinking and discussing.

Tobias Fischbach came by the BOF and told us about Limux which is based on Kubuntu. This has been the official computer distribution of Munich for the past few years. Now however, unless the Mayor changes (or changes his mind) the city is moving to Windows again, which will be unfortunate for the City.

Slightly off-topic but relevent is that KDE neon will be moving to 20.04 base soon after release, but they will not stay on the Plasma LTS or Qt LTS. So users who want the very latest in KDE Plasma and applications will continue to have the option of using Neon, while our users, who expect more testing and stability can choose between the LTS for the ultimate in stability and our interim releases for newer Plasma and applications.

Of course we continue to ask for those of our users who want to help the Kubuntu project to volunteer, especially to test. We’ll soon need testers for the upcoming Eoan, which will become 19.10. Drop into the development IRC channel: #kubuntu-devel on freenode, or subscribe to the Kubuntu Development list:

Since a few years Kate is working well on Windows. You can grab fresh installers since then from our download page.

But the visibility of it was very low for Windows users.

Already last year the plan was made to increase the visibility of KDE applications by getting them into the official Windows Store.

Like always, Akademy is a great chance to get the last bits ironed out and the stuff done!

Now, thanks to the help of Hannah von Reth and others, we finally got Kate submitted to the Windows Store!

The submission still needs to be processed by Microsoft, stay tuned when our nifty editor will really be available there for download!

Thanks to all people that contributed to this!

September 11, 2019

I am happy to Announce we have released Qt 5.12.5 today.

KDE Project:

Following Volker's last blog on this topic, here are some highlights of the recent work that has been done around Kontact / PIM during this summer. First of all, stats: there were around 1200 commits in the past two months, leading to the new 19.08 release.

KDE Itinerary

You can have a good overview of Volker's work by following this blog.


It seems our team was mostly focused on cleaning, fixing and introducing little UI features during summer:

Laurent added folder specific exportation from PIM within its PIM data exporter, contact selection from LDAP servers, refactoring some PIM libraries to new ECM macros and cleaned up deprecated method preparing for a Qt 6 future.
In addition to that some bug fixes got in, most notably adding reminders to new events in KOrganizer, text-to-speech fixes and general KMail behavior corrections.

Reminders to new events in Korganizer:

Choosing a contact from LDAP server :

All of the libraries have been adapted to compile with Qt 5.13 and soonish we should reach 5.14 compilation state.

Volker spent time unifying instant message address storage in vCards to KContacts, KContacts soon to be its own framework. The visual style for inline messages in KMail's message viewer was updated too, following the Breeze style as you can see in the picture.

Visuals for inline message boxes in the mail view :

Sandro Knauß worked on the begining of an implementation for MemoryHole support : the idea is to encrypt the mail header (containing metadata) to enforce even further user privacy. In order to achieve that, they wrote a new interface between MimeTreeParser and MessageViewer so we now can update mail headers for later extraction, stay tune for more deails about that next blog posts. In addition and with the help of Glen Ditchfield they put their effort on making messagelib tests green again!

David Faure ported the all of KDE PIM to D-Bus activation as a way to start applications, which enabled the deprecation of KDBusServiceTrader and maybe in a long term future a refactor to simplify KLauncher.


Dan worked on a better support of PostgreSQL (better handling of table name case sensitivity and the sorting of versioned directories). Akonadi server received some love with a few cleanup and modernization treats, you will have more detail about what Dan cooked in his kitchen in his blog so stay tuned!


Volker and Laurent made sure all KDE PIM modules would appear correctly under the, to make the KDE PIM codebase easier to follow and discover.

Help us make Kontact even better!

All these efforts to provide good free software to the world would not be possible without our committers, if you want to take part on that feel free to contact us #kontact and #akonadi IRC channels on Freenode, see the below section to get started:

And again, if you are attending Akademy, feel free to come see us !

This is a guest post from Franck Arrecot due to technical issues with his blog.
Thanks Franck for writing up the above!

The KStars team is glad to announce the release for KStars v3.3.6 for Windows, MacOS, and Linux.

This release is packed with many small quality of life improvements and bug fixes.

Intuitive Popup Menu

We cleaned up the popup menu so that mount actions are more intuitive. Took this chance as well to add some lovely Breeze icons to the mix.

We will continue to make mount controls even more accessible, especially to users over VNC.

Live Debayering

The KStars Live Video window can now debayer frames in real-time, thereby allowing for color video streams.

FITS Viewer

A few improvements landed in FITS Viewer:

  • Updated Statistics display that can display value for each color channel separately, if present.
  • Faster loading times thanks to a performance patch by Hy Murveit. Config and Indexes

Robert Lancaster made huge improvements to the handling of configuration management and indexes. This should make these features a lot more accessible to a wider pool of users.

You can edit the configuration file directly in KStars. Furthermore, you can easily add/remove folders that that contain the index files. Many users have the indexes files stored in external hard drivers, and with this feature, it is now very easy to add the additional folders so they get utilized by the solver.

This change is accompanied by changes to the index downloader. Now you can check all your collections, and you have the ability to download indexes to a particular folder in your collection. A green index file indicates that the file is available in the system and does not require to be downloaded.

Observatory Weather Info

Wolfgang Reissenberger continued his outstanding work in improving the Observatory Module. With this release comes weather data directly displayed in the module. Along with the configurable thresholds for Warning and Alert states, you can rest easily knowing that KStars can take the appropriate actions to protect your observatory from adverse weather conditions.

Meridian Flip

A small quality-of-life improvement to the Meridian Flip value. You can now toggle between Degrees (default) and hours. Many mounts indicate the meridian flip limit in degrees so we opted to make this as default.

Mount Control Motion Reverse

You can now reverse the direction of each axis of motion separately, in case you prefer to controls to behave in the way you expect them to in the Mount Control Panel.

Setting Coordinates Manually

The dialog now opens pre-populated with the currently selected object coordinates. You can easily switch between JNow, J2000, or your own custom Epoch.

Under The Hood

Yuri Chornoivan is the unsung hero of internationalization efforts in KStars. Many volunteers work in KDE internationalization effort and Mr. Chornoivan keeps a vigilant eye on KStars to make sure it remains accessible to the widest audience possibly globally.

Mr. Chornoivan replaced many obsolete functions in KStars with their up-to-date alternatives.

September 10, 2019

According to the now traditional schedule, Akademy 2019 started with two days of conference talks. Hosted by unixMIB at the University of Milano-Bicocca in Milan, Italy, the central conference of the KDE community attracted more than a hundred attendees during this past weekend. Many of them were attending Akademy for the first time ever, which is always a reason to celebrate.

For those of you who were not able to join us, we've prepared a recap of all the talks from this year's Akademy. The conference program on both Saturday and Sunday was split into two tracks after the lunch break, and included plenty of time for socializing (and hacking!) in between.

Day 1 - Saturday, September 7: Goals, Reports, and the Future of Qt

Akademy 2019 started in the morning of September 7 with an introductory session by Lydia Pintscher, President of KDE e.V., followed by the first keynote. In the keynote, Lars Knoll from Qt presented the path towards Qt 6 all the way from the very beginning of the project. Lars also spoke of what upcoming changes in Qt 6 may potentially impact the KDE ecosystem.

The next batch of talks was dedicated to the KDE community goals. Ivan Čukić started by presenting the progress of the Privacy and Security goal in his talk "Everything to hide: Helping protect the privacy of our users". Ivan pointed out that security and privacy should come before usability, even if some users hate it, because it's our duty and responsibility to protect them.

Ivan shows how to capture a password from an insecure application.

Eike Hein talked about the Usability and Productivity goal and wondered: "Are we there yet?". Massive improvements have been made to KDE software as part of this goal, and Eike emphasized the importance of communicating this progress (as illustrated in weekly blog posts by Nate Graham). The achievements of the third community goal - Onboarding New Contributors - were presented by Neofytos Kolokotronis, who listed the adoption of Matrix as a communication tool, the on-going adoption of GitLab, and the creation of the KDE Welcome team as some of the major moments.

After looking back at the previous set of goals, it was time to look forward to the new ones. During the panel with Ivan Čukić, Eike Hein, and Neofytos Kolokotronis, Lydia Pintscher announced the three new goals that the KDE community is going to focus on. The creators of the goal proposals spent some time talking about their plans and tasks that will kick off the new goals.

In the afternoon round of quick talks, Adriaan de Groot presented QuatBot, a meeting-managing bot he wrote for the Matrix IM service, and talked about the power and versatility of KDE Frameworks. Attendees also got a chance to hear how Carl Schwan brought in new contributors from Reddit and Aleix Pol dispensing valuable advice on how to organize a sprint.

Over in the Security track, Albert Astals talked about the cool ways developers can use oss-fuzz to test their code, and encouraged KDE developers to use it for projects such as Baloo, kfilemetadata, and PIM-related code. Volker Krause presented parts of the work carried out for the Privacy goal in his talk "Secure HTTP Usage", and warned about the importance of having secure defaults in KDE software.

The Community session included a talk on building developer portals by Ivana Isadora Devcic, followed by Ray Paik's talk on making a difference in the community. As a Community Manager at GitLab, Ray shared his experience with identifying crucial community metrics, attracting new contributors, and improving leadership and inclusivity efforts.

Meanwhile, the tech talk session continued with Marco Martin and Bhushan Shah discussing the future of Plasma on embedded devices. They rightfully pointed out that the assumption your software will only be used on a desktop is not true anymore, and explained how KDE Frameworks enable creating software for different platforms. Aleix Pol talked about the details of optimizing Plasma to run fast on low-end hardware; more specifically, on the Pinebook. Aditya Mehra presented a demo of Plasma and Mycroft being used to voice-control a car, and Kai Uwe Broulik gave an in-depth look into the overhauled notification system shipped with the latest version of Plasma.

Aditya shows us how some day KDE tech may control your car.

The first day of Akademy 2019 closed with reports by Google Summer of Code students developing fresh new code for KDE, and the KDE e.V. Board and Working Group reports that provided an insight into growth and health of the KDE community.

Day 2 - Sunday, September 8: New Technology, FOSS Revolution in Italy, and Akademy Awards

The second day of Akademy 2019 opened with a keynote "Developers Italia and the New Guidelines: Let the Open Source Revolution Start" by Leonardo Favario from the Team Digitale IT. Leonardo presented the work that his team has been doing to establish guidelines for Free and open source software distribution in the Italian administration. Continuing on a similar topic, Michiel Leenaars talked about NGIO (Next Generation Internet Zero); a EU initiative focused on helping non-profit organizations build a better Internet for everyone.

The tech talks on Sunday were fascinating, with new, innovative technology introduced left and right. Cristoph Haag explained how Collabora made Plasma desktop usable in a Virtual Reality environment, and set up demos that the attendees could play with during the day. Trung Thanh Dinh showed how AI face recognition can be used in digiKam, KDE's photo management app, and Eike Hein presented a completely new KDE application called Kirogi, which provides a FLOSS ground control for consumer drones that works on mobile devices.

Eike points to the skies, which is where KDE is going next with Kirogi.

In the afternoon sessions, Katarina Behrens from the Document Foundation talked about integrating LibreOffice products with KDE Plasma, while Timothée Giet and Aiswarya Kaitheri Kandoth told the story of how a single floppy disk with LaTeX on it resulted in schools using GNU/Linux and GCompris in Kerala, India.

Volker Krause gave two more talks - one about the development and usage of KPublicTransport, a framework for interacting with data from public transport operators; and another on how the limitations of the Android development platform impact KDE Frameworks. In another developer-oriented talk, Daniel Vràtil gave his perspective on using C++ to build APIs. Attendees also heard from Caio Jordao Carvalho, who presented the progress on kpmcore, the heart of KDE's partitioning and disk management tools.

Meanwhile, a session on different ways to package and distribute KDE software was chaired by Dan Leinir Turthra Jensen, with participants explaining advantages and shortcomings of different solutions (AppImage, Flatpak, Snap, Steam, Google Play...).

The session was followed by two community-related talks. In "What We Do in the Promos", Paul Brown gave a realistic look into how people outside the FOSS bubble perceive (or do not perceive) KDE software, and explained the reasoning behind activities carried out by KDE Promo. Afterwards, Aniketh Girish explained how code reviews can be toxic and put off new contributors, so he offered some advice to prevent that. Last but not least, Dan Leinir Turthra Jensen presented the "Get Hot New Stuff" project and its development.

Following the lightning talks from Akademy 2019 sponsors, the second day of the conference closed with the announcement of Akademy Awards winners:

  • Best Application: Marco Martin for work on the Kirigami framework
  • Best Non-Application: Nate Graham for persistent work on the "KDE Usability & Productivity" blog
  • Jury Award: Volker Krause for long-term contributions to KDE including KNode, KDE PIM, KDE Itinerary and the UserFeedback framework

The organizers win a special award for an excellent Akademy.

Akademy 2019 continues this week with daily BoF (Birds of a Feather) sessions, meetings, and various activities that help us strengthen the community bonds. The recap video of the first BoF day is already available - stay tuned for more. And for something completely different, take a look at the sketchnotes from Akademy 2019 talks by Kevin Ottens.

Kevin sketches Akademy talks.

About Akademy

Akademy 2019, Milano

For most of the year, KDE - one of the largest free and open software communities in the world - works online by email, IRC, forums and mailing lists. Akademy provides all KDE contributors the opportunity to meet in person to foster social bonds, work on concrete technology issues, consider new ideas, and reinforce the innovative, dynamic culture of KDE. Akademy brings together artists, designers, developers, translators, users, writers, sponsors and many other types of KDE contributors to celebrate the achievements of the past year and help determine the direction for the next year. Hands-on sessions offer the opportunity for intense work bringing those plans to reality. The KDE community welcomes companies building on KDE technology, and those that are looking for opportunities. For more information, please contact the Akademy Team.

Tuesday continued the Akademy BoFs, group sessions and hacking. There is a wrapup session at the end of the day so that what happened in the different rooms can be shared with everyone including those not present.

Watch Tuesday's wrapup session in the video below

Dot Categories:

The OpenForum Academy held its second 2019 workshop in Brussels this week. OpenForum Academy is a European-based independent think tank which explains the merits of openness in computing to policy makers, industry and communities across Europe. This workshop series aims at being a forum for practitioners, academics and policy makers to collaborate on various topics of openness and freedom. It is organized by OpenForum Europe, enabling it to bridge between the abstract academic world and policy discussions at the European Commissions. We set out to explore focus topics to answer current challenges to openness that the academy will develop insights and recommendations for. These topics will shape the work of OpenForum Academy for the near future.

A bit later than expected, because of a regression found during beta testing, we’re releasing Krita 4.2.6. Over 120 people have participated in the beta test survey, so this is something we’ll repeat for the next release.

This release also contains an important workaround for users with an AMD Ryzen 5 3500 CPU. This CPU has a bug in its hardware random generator that caused crashes.

New features:

  • Add new layer from visible to layer right-click context menu.
  • When running Krita for the first time on Windows, Angle is now the default renderer. Note that if you have an NVidia GPU and Krita’s window is transparent, you need to select Angle manually in Krita’s settings; if you have another GPU and you have problems with the canvas not updating, you might need to manually select OpenGL in the same window.

We want to especially thank Karl Ove Hufthammer for his extensive work on polishing the translatable string.

Bugs fixed

  • Allow selection overlay to be reset to default. (BUG:410470)
  • Set date for bundle creation to use ISO-Date. (BUG:410490)
  • Fix freeze with 32bit float tiff by using our own tiff reader for the thumbnails. (BUG:408731)
  • Ensure filter mask button is disabled appropriately depending on whether the filter supports it. (BUG:410374)
  • Enable the small color selector if opengles is available as well (BUG:410602)
  • Fix mixed Zoom, Pan, Rotate on macOS (BUG:410698)
  • Ensure that checkboxes are shown in menus even when using the fusion theme
  • Isolate Layer Crash (BUG:408785)
  • Properly fix font resetting when all the text in the editor removed (BUG:409243)
  • Fix lags in Move Tool when using tablet device (BUG:410838)
  • Fix Shift and Alt modifiers in Outline Selection Tool (BUG:410532)
  • Ensure Convert group to Animated Layer shows text in the toolbar. (BUG:410500)
  • Allow ‘Add Clone Layer’ to Work on Multiple Layers (BUG:373338)
  • Fix saving animated transparency masks created through conversion (BUG:409895)
  • Partially fix the curve change despite ‘Share curve across all settings’ checked (BUG:383909)
  • Try harder to make sure that the swap location is writable
  • Properly handle timezones in bundles
  • Make sure all the settings dialogs pages are always shown in the same order
  • Make the settings dialog fit in low-res screens (BUG:410793)
  • Remove misleading ‘px’ suffix for ‘move amount’ shortcut setting
  • Make string for reasons for image export problems translatable (BUG:406973)
  • Fix crash when creating a bezier curve (BUG:410572)
  • Fix deadlocks in KoShapeManager (BUG:410909, BUG:410572)
  • Fix a deadlock when using broken Wacom drivers on Linux (BUG:410797)
  • Fix absolute brush rotation on rotated canvas (BUG:292726)
  • Fix deadlock when removing reference image (BUG:411212)
  • Fix a deadlock in handling of vector objects (BUG:411365)
  • Fix autosave saving only once (BUG:411631)



Note for Windows users: if you encounter crashes, please follow these instructions to use the debug symbols so we can figure out where Krita crashes.


(If, for some reason, Firefox thinks it needs to load this as text: to download, right-click on the link.)


Note: the gmic-qt is not available on OSX.

Source code


For all downloads:


The Linux appimage and the source .tar.gz and .tar.xz tarballs are signed. You can retrieve the public key over https here: 0x58b9596c722ea3bd.asc. The signatures are here (filenames ending in .sig).

Support Krita

Krita is a free and open source project. Please consider supporting the project with donations or by buying training videos or the artbook! With your support, we can keep the core team working on Krita full-time.

The GSoC coding period is now over and it is only appropriate that it is discussed what has been achieved and what needs to be done to see KIOFuse officially included in as a KDE project, allowing the 75324 bug report to be finally closed after a whole 15 years! Before I continue, I’d like to thank my mentors, Fabian Vogt (fvogt) and Chinmoy Ranjan Pradhan (chinmoyr) for all their support and advice during the course of GSoC. I’d also like to thank various reviewers of upstream code who quickly reviewed and merged code that I submitted. My previous posts (here and here) have discussed the work accomplished in May/June in detail.

Currently the way KIOFuse works is that I/O is implemented on top of a file-based cache, in particular, on temporary files. Reading and writing occurs on the temp file. Flushing works by calling KIO::put, which sends the data in our cache to the remote side via a TransferJob. However, whilst this is happening, there’s nothing stopping write requests coming in for that same node, which marks the cache as dirty. Once the job is done, we check if the node is dirty. If it is, we start another TransferJob, as it would be incorrect to say that the node is flushed. If this scenario keeps occurring, we’d never reply with a successful flush. A simple solution, which doesn’t guarantee that this scenario doesn’t occur but can decrease its likelihood, is as follows: every time a chunk of data is requested by the TransferJob we check if the node is dirty. If so, if it is less than 85% complete, restart the job, otherwise let it finish. The patch for this can be found here.

Another task was to refresh the attributes of nodes after a while. Currently, the existence of nodes is only checked lazily, i.e. if lookup or readdir are called. For each new node found (or created) the stat struct (the node’s attributes) is filled with the values from KIO::UDSEntry. However, this is only done once and any changes on the remote side are not noticed. One could always refresh the attributes on every lookup but that may be overzealous, and so the solution chosen was to do a KIO::listDirin readdir if it hasn’t been called on that node in the last 30 seconds. The patch for this can be found here.

Another problem that KIOFuse had was that write permission wasn’t checked, we’d just forward the permission bits received from the remote side and if we in fact couldn’t write we’d only know during flush, which is a bit too late. Although we cannot fully guarantee write access, there are steps taken to try and get as close as possible to a guarantee. First we start a KIO::chown job, which changes the owner to ourself. If we can, then we assume that the owner permission bits are valid, and forward them. If KIO::chown isn’t supported we just allow write requests to go through, as there is simply no way we can actually check. If the job fails (i.e. we’re not the owner of the file), then changing the modification time can actually help us; it doesn’t help us if we’re the owner as we can change the modification time independent of our write permission. If we can change it, then we can write, if KIO::setModificationTime isn’t supported, we just allow write requests to go through. The patch for this can be found here.

As mentioned previously, file I/O is implemented on top of a file-based cache. Data on the remote side is transferred via the help of KIO::get and KIO::put. Some slaves support KIO::open, in particular sftp/smb/file, which means that it is possible to engage in seek-based file I/O. This means that we do not need to use a file-based cache for those slaves, and can simply read and write directly from and to the remote side. This obviously introduces a bit more latency, but also means that we can easily handle large files, such as videos. The biggest issue with getting this implemented is that the documentation on the how to implement KIO::open correctly and its assorted functions consists of one-liners. This means that each slave author has their own idea of what it means to read/write/seek. The solution to this was to study what all three slaves did, and converge on one definition of what we mean by the different functions provided by the FileJob interface. In addition several bugs were squashed. The most surprising of which was the close signal never being emitted; a big sign that no one has used this API properly since its inception in 2006! Issues in the smb/sftp slaves and the mtp slaves were also fixed. The above mentioned patches have all been merged meaning that KIOFuse now requires KF5 Frameworks 5.62 (and kio-extras 19.08.1). The patch that allows KIOFuse to take advantage of KIO::open can be found here.

The main benefit of KIOFuse is obviously integration into KIO itself. The idea is to create a KIOFuse KDED module loaded at startup, which starts the kio-fuse process. On the KIO side, every time we wish to send a KIO URL to an app that we identify as not supporting the given URL, a DBus request is sent to our KDED module, which mounts the URL and sends back the local path of the URL. We then pass it to the application. The beauty of this is that the conversion is transparent and requires no setup from the user; it also induces no slowdown to KIO-enabled applications. In fact, many people won’t even be able to tell that they’re using KIOFuse, non-KDE apps will seamlessly access the KIOFuse path instead of KIO URLs they don’t understand. The patch for the KDED module can be found here, and the patch in KIO that uses that KDED module can be found here.

So, what’s required for KIOFuse to be production ready? Firstly, some of the linked MRs have not been merged, which just requires a bit of time to get it reviewed and in. Secondly, there are still some bugs that need resolving. GDrive files which don’t have a size (usually GDoc files) get corrupted on read (and potentially write), this issue has been looked at but I’ve not yet found a resolution. MTP doesn’t seem to work at all for some reason. Whether this is an issue in the MTP slave or KIOFuse has not been determined, which is making it harder to resolve this issue. Another thorny issue is that conversion from a local path to a remote URL is a bit buggy. This should be resolvable, but it needs to time to get it right. Ideally, we’d like more testing on all slaves. One potential cool way of testing KIOFuse is using fio, which performs several intensive tests, usually for kernel file systems; this is something we definitely should explore. There is also the question of how KIOFuse will be included in KDE, for example, will it be a framework?

Note that I’m at Akademy, so feel free to ask any questions about it either there or on this blog.

September 09, 2019

Monday was the first day of Akademy BoFs, group sessions and hacking. There is a wrapup session at the end of the day so that what happened in the different rooms can be shared with everyone including those not present.

Watch Monday's wrapup session in the video below

Dot Categories:

Or: More preparation for the autumn of version 5 of KDE Frameworks

Consumer and producer interest in legacy in a library API

During the development life-time of a library in a API-compatible major version, quite some part of its API can be found to be insufficient and thus be deprecated in favour of API additions that serve the purpose better. And the producers of the library want to make the consumers of the library aware about those changes, both to make the investment into the improved API pay out for the consumers as well as prepare them for the future removal of the old API. As a deprecation note in the API documentation or release notes might be missed for existing consumer software, the compiler is pulled into the game using deprecation attributes on the API symbols, so developers looking at the build log have a chance to automatically be pointed to use of deprecated API in their software.
Next, once the chance for dropping the legacy parts of an API arrives on a change to a new major version, again having the compiler support pointing out that part is easier then grepping over the codebase for potentially pattern-less informal notes in code comments or the documentation.

At the same time consumers of a library might be well aware about API deprecations. But they might want to support a range of released versions of the library, using a single code base without variants for the different library versions. They might have more important issues to solve than deprecated API and want to get rid of any deprecation warnings at all. Or they want to ensure that no new uses of deprecated API is added.
Others consumers again might want to use custom builds of the library with all the implementation for deprecated API dropped, at least until a certain version, to save size when bundling the library product.

KDE Frameworks: … TODO

KDE Frameworks, the continuation of the “kdelibs” bundle of libraries, but with emphasis on modularization, is now at API-compatible major version 5. Yet one can find legacy API already deprecated in version 3 times, but done so only as comment in the API dox, without support by the compiler. And while lots of API is also properly marked as deprecated to the compiler, the consumer has no KDE Frameworks specific option to control the warnings and visibility. While some “*_NO_DEPRECATED” macros are used, they are not consistently used and usually only for deprecations done at version 5.0.

As you surely are aware, currently the foundations of the next generation of Qt, version 6, are sketched, and with the end of 2020 there even exists a rough date planned for its initial release. Given the API breakage then happening the same can also be expected for the libraries part of KDE Frameworks. And which would be a good time to also get rid of any legacy cruft.

New: ECMGenerateExportHeader, enabling more control about deprecated API

A proposed new addition to KDE’s Extra CMake Modules (ECM) should allow to improve the situation with KDE Frameworks, but also other libraries: ECMGenerateExportHeader (review request).

It would generate an extended export macro definition header which also includes macros to control which parts of the deprecated are warned about, are visible to the compiler for library consumers or included in the build of the library at all. The macros would be inspired by similar macros introduced with Qt 5.13, so the mind model can be transferred.
(Inspired, but not a plain copy, as e.g. the name “QT_DISABLE_DEPRECATED_BEFORE” is a bit misleading, as the macro is specified to work as “before and including”, so the proposed inspired name uses “*_DISABLE_DEPRECATED_BEFORE_AND_AT”.)

More elaborated example usage would be like this (note the difference between FOO_BUILD_DEPRECATED_SINCE and OO_ENABLE_DEPRECATED_SINCE, see documentation for explanation):



set(EXCLUDE_DEPRECATED_BEFORE_AND_AT 0 CACHE STRING "Control what part of deprecated API is excluded from build [default=0].")


Installed header foo.hpp:

#include <foo_export.h>

enum Bars {

  * @deprecated Since 5.0
void doFoo();

  * @deprecated Since 5.12
FOO_EXPORT void doBar();

class Foo {
    * @deprecated Since 5.12
  virtual void doFoo();

Source file foo.cpp:

#include "foo.hpp"

void doFoo()
    // [...]

void doBar()
    // [...]

void Foo::doFoo()
    // [...]

Other, better approaches?

The author is not aware of other approaches currently, but would be happy to learn about, to compare, improve, or even discard in favour of another the proposed approach.

Please also have a look at the documentation for the proposed CMake macro ECMGenerateExportHeader (review request) and tell your thoughts.

For this macro being applied, see a patch for KCoreAddons and a patch for KService.

The Opportunity

During Akademy 2019 here in Milan, Dominik and me had time to sit together and discuss a bit what we shall do to evolve Kate :)

Whereas Kate already works well as a general purpose editor, the competition in the text editor space got more intense in the last years.

Beside the well established stuff like GNU Emacs & Vim, new editor projects got started that did set the bar higher on what users expect from a advanced GUI text editor.

For example Sublime, Atom and Visual Studio Code are things to keep an eye on feature & polishing wise.

Therefore we decided it would make sense to think a bit about which stuff should be improved or altered in the near future.

The Rough Ideas

Kate Plugin Interfaces

From the KDE 4.x Kate to the KF5 based Kate version, we removed the Kate specific plugin interfaces and went with more generic interfaces in KTextEditor.

The idea was to be able to share more plugins e.g. between Kate and KDevelop. This idea never really did take off, at the moment just two of our plugins are shared at all…

On the other side, this makes it much harder to expose new functionality to our plugins, as we need to stay binary compatible.

Moving back to having some Kate only stuff that has not even installed headers but is just usable for the plugins we bundle in our kate.git will make it again more flexible what to expose.

One can still think about moving “proven in practice” parts back to the KTextEditor interface part.

Make Projects a Core-Feature

At the moment the projects feature is located in a plugin.

For exposure of some things like the current project files some evil Qt property hacks are used.

By moving this feature into the Kate core we can use a sane way to search in project, list project stuff in quick open, …

Other state of the art editors provide that per default, too

Still stuff like “shall we create projects on the fly” can be deactivated like today

LSP Support per default

We shall get the LSP support in a shape that it can be shipped enabled per default.

Users expect that modern editors provide advanced language integration off the shelf, like Atom, Visual Studio Code, …

Great code navigation

We shall provide the user with better code navigation.

We will provide the plugins with an interface to register location jumps.

This will enable the user to seamlessly jump back and forth for any kind of location change e.g. due declaration lookup or search in files match lookup, …

Consolidate the plugins

The new LSP plugin shall subsume stuff like the Rust or D specific code completion plugins.

Think about the future of unmaintained plugins!

External Tools Plugin

Revive the external tools in a improved way, e.g. like in Qt Creator.

Improve Port to KSyntaxHighlighting

Porting the highlighting over to KSyntaxHighlighting was a big success.

Kate and Qt Creator now finally share the same highlighting engine and we got a lot of new contributions to our highlightings. (we support now over 300 different languages, something to be proud of)

Still, e.g. the theme support is still not moved over to what the new framework provides.

Further Brainstorming

Git Integration

We shall take a look what other editors provide.

Diff/Patch Viewer

Want we to integrate with stuff like KDiff3/Kompare/… to have a better handling of e.g. git diff, patches, …?

Improve View Management

Try to improve the way we handle splitting the views and the tabbing.

Take a look how other editors do that!

KDevelop vs. Kate?

Given already today we enter the area of KDevelop by providing the LSP client, we need to think about what happens in the future with overlapping features.

It is no goal to evolve Kate into an IDE.

We think Kate shall be a competitor for editors like Atom, not for full-fledged IDEs like KDevelop or Visual Studio.

Still, e.g. in the area of project management/code navigation/version control support there will be some overlap.

The question is: can we share stuff there? What shall be the focus of Kate and KDevelop in e.g. language support?

I think here it will be interesting which future direction the KDevelop project will take.


If you want to chime in on this, feel free to join the discussion at the KDE reddit.

If you want to contribute, just join us at or on

September 08, 2019

The conference part of this year’s Akademy is now over. Like last year, I did live sketchnoting of all the sessions I attended.

Obviously, the first keynote from Lars talking about the Qt 6 plans was very important for the community and I think I did an adequate job there:

I don’t think I made the KDE e.V. Board Report shine… sorry about that, but that’s again a very important community landmark:

The second keynote about Open Source in Italian Public Administrations was also interesting and the sketchnotes ended up not too bad:

As far as sketchnoting goes, I think the one I’m the most proud of this year is the one done during the KPublicTransport session (the talk was very interesting as well, good content):

And finally, like last year, the lightning talk session was very challenging. I think it’s in part due to the fast pace of the talks. Since the session was shorter though (it was only 4 talks) I decided to constraint myself to a single page for all of them. I think it was worth it and I’m happy with the result:

If you want to see more (there’s almost 20 of them, I didn’t list them all here), the full list of sketchnotes are in the Akademy 2019 gallery.

I hope you like them and will find them useful. As usual they give a different perspective on the conference content.

KDE Project:

Today I'm in beautiful Milano, Italy, where the KDE community has gathered for its annual user and developer conference, Akademy. At Akademy I've had an opportunity to present my new KDE project to a larger audience: A ground control application for drones, Kirogi.

A screenshot of Kirogi's direct flight controls screen
Kirogi's direct flight controls screen

Kirogi aims to enable the operation of drones of all sorts of makes and models in an approachable and polished manner, with both direct and map-based control modes and many more features planned for the future.

The origin story behind the Kirogi project is a classic open source tale. During this year's Lunar New Year holiday, I was paying a visit to family in Busan, South Korea (the name Kirogi is Korean and means wild goose). During the off-days I ended up buying my first drone. I attempted the first flight in my mother-in-law's living room. Unfortunately the official vendor application immediately started crashing after take off - much to my embarassment, I couldn't land the thing! Eventually it slowly drifted towards a very nice armchair (sorry mom!) and crashed on contact with an emergency engines-off.

Turns out the app I was using had been replaced by a newer, seperate app store upload intended for a newer drone - and the app I had wasn't fully compatible with a newer version of the phone's OS anymore. I realized open source can serve drone owners better there and started hacking on this new KDE application a few days later.

Since then I've received a lot of support and help from many people in the fantastic KDE community, including Krita-powered artist L. 'AsmoArael' C., who responded to a request I posted KDE's Artists Wanted forum and helped me realize Kirogi's mascot:

A drawing of Kirogi's mascot, a farm goose and technology enthusiast
Kirogi's mascot, a farm goose and technology enthusiast

If you want to know more about the project's origins and dive further into the technical details, I invite you to check out the slides for the talk I gave today. It was recorded on video as well; I will add a link once it's been made available.

The project also has a website already. Along with much additional information on the project it features download links for nightly development builds.

Three months of fighting with boost, qt, having a proper plan, multiple individuals to get help from and still unable to hit the target in time. That will be software engineering 101 for me.

At the moment, the yearly KDE conference Akademy is taking place in Milan. The yearly KDE e.V. meeting will be tomorrow.

KDE e.V. is a registered non-profit organization that represents the KDE Community in legal and financial matters.

For example the KDE e.V. is responsible for paying the servers that run our Phabricator/Bugzilla/Gitlab instances and all our web sites. KDE e.V. takes care of sponsoring developer sprints and contributor travel costs, too.

If you are a KDE contributor, consider to join the e.V. to get some vote about its direction.

If you want to join, just take a short look at this guide.

This is the last week in KDE’s Usability & Productivity initiative (next week the blog posts will continue, but under a new name). The voting results are in for KDE’s new goals and the community-selected winners are full Wayland support, consistency throughout the KDE ecosystem and software, and a renewed focus on KDE apps. Read all about it here!

But meanwhile, there’s a ton of stuff to announce right now, so let’s jump right in.

Serendipitously enough, something big landed this week that’s relevant to the first new goal: fractional scaling on Wayland!!!

Check out the complicated dependency tree of patches that were required to make this happen:

Veteran KWin developers Roman Gilg and David Edmundson have been working on this for ages, and all of their hard work–which will land in Plasma 5.17–is much appreciated. But wait, there’s more!

New Features

Bugfixes & Performance Improvements

User Interface Improvements

Next week, your name could be in this list! Not sure how? Just ask! I’ve helped mentor a number of new contributors recently and I’d love to help you, too! You can also check out, and find out how you can help be a part of something that really matters. You don’t have to already be a programmer. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

If you find KDE software useful, consider making a tax-deductible donation to the KDE e.V. foundation.

Dear digiKam fans and users, We received a lot of excellent user feedback after publishing the third digiKam 6 release in August 2019. We are now proud to briefly announce the new digiKam 6.3.0, a maintenance version which consolidates this feedback and acts as an important phase of this 3-year-old project. New GMic-Qt plugin for Image Editor Since digiKam 6.1.0, we open digiKam to external contributions with a collection of new plugin interfaces, named “Generic” for album items processing and export to web-services, “Editor” to extend Image Editor and Showfoto post processing, and “Bqm” to add new tools in Batch Queue Manager.

September 07, 2019

Lydia Pintscher, Eike Hein, Ivan Cukic and Neofytos Kolokotronis discuss the results of the past goals.

The KDE Community has spoken! On the first day of Akademy 2019, Lydia Pintscher, President of KDE e.V., announced the three new goals we will prioritize over the next 2 years.

The goals were selected by community vote from a dozen proposals, all created by community members. Read on to learn more details about each of the new goals.

Finalize the transition to Wayland and embrace the future of desktop

Despite its many merits, the X server has become very long in the tooth, and Wayland is poised to become a more modern and dependable alternative. However, KDE's software is still quite far off from being completely implemented on the newer protocol.

"As technology and the needs of modern computer users advance, X server has been proven less and less capable to keep up", says Fanis Bampaloukas, author of the first proposal. "I propose to make our goal to migrate the core of the Plasma desktop, and make X server an optional compile and runtime dependency".

To achieve this goal, Fanis says KDE will have to fix major breakages and implement missing features.

Jonathan Riddell and Niccolò Venerandi explain their ideas for new KDE goals.

Improve consistency across the board

As KDE relies on "volunteers, each with different ideas and "scratching their own itches", there is often a lack of organization and consistency within the app ecosystem" says Niccolò Venerandi, author of the second goal proposal. Niccolò points out that inconsistencies are not only found in the design of applications, but also in their features. Tabs, for example, are implemented differently on Falkon, Konsole, Dolphin and Kate, making them confusing for users and difficult to fix for developers.

To solve inconsistencies, Niccolò suggests the unification of behavior in app elements (such as sidebars, hamburger menus and tabs), ending the fragmentation of apps with overlapping features (like having several multimedia players), and laying down criteria for hosting application websites, among many other things.

KDE is all about the apps

"KDE has over 200 applications and countless add-ons, plugins and Plasmoids" says Jonathan Riddell, author of the third proposal. "But much of the support we offer has fallen short; until recently there wasn't even an up-to-date website listing them all".

The importance of KDE's app ecosystem cannot be stressed enough. Often it is the gateway to other apps, the Plasma desktop, and to becoming a member of the KDE community. In his proposal, Jonathan recommends modernizing the platforms through which KDE developers communicate with users, improving the way each app is packaged, and continuing with reworking to the documentation and metadata supplied with the apps.

Past Goals

The previous three goals were chosen by the community back in 2017.

All goals have had a net positive impact on the community. The Onboarding initiative, for example, has led to a substantial increase in the number of new contributors - especially young students - that has brought a renewed vigor to the community.

The Privacy project has encouraged developers to implement measures for keeping users secure and their data private.

Finally, the Usability project has removed hundreds of design flaws and niggling papercuts. As a result, using Plasma and KDE applications in general is now a much more enjoyable experience.

KDE goals give the community focus and solve problems that otherwise may not be fully addressed. The same way 2017 proposals helped make KDE a better community with better software, this year's goals will help push the project towards a brighter future.

About Akademy

Akademy 2018, Vienna

For most of the year, KDE - one of the largest free and open software communities in the world - works online by email, IRC, forums and mailing lists. Akademy provides all KDE contributors the opportunity to meet in person to foster social bonds, work on concrete technology issues, consider new ideas, and reinforce the innovative, dynamic culture of KDE. Akademy brings together artists, designers, developers, translators, users, writers, sponsors and many other types of KDE contributors to celebrate the achievements of the past year and help determine the direction for the next year. Hands-on sessions offer the opportunity for intense work bringing those plans to reality. The KDE community welcomes companies building on KDE technology, and those that are looking for opportunities. For more information, please contact the Akademy Team.

It has always been a mystery to me, why the AqBanking/Gwenhywfar library used for online banking in KMyMoney complains about the validity of certificates because it cannot check the signer when all other software on my system has no problem with that, even with the same servers.

Up until now, I simply checked the signer manually using some openssl tools and accepted the certificate within AqBanking. Now that it happened to me that I moved to a new system, the complaints popped up again and I sat down to figure out what the problem really is and how to solve it.

Apparently, each Linux distro has their own way of storing the certificates. Some are based on a single file containing all of the certificates simply concatenated, some others rely on single files in a directory. Also, the location of these files and dirs is different among the distros.

Not knowing where AqBanking is searching for certificates, I ran

strace -e trace=%file -o cert.log kmymoney

and I found the following section in the cert.log file after I saw the dialog with the complaint:

openat(AT_FDCWD, "/etc/ssl/certs/ca-certificates.crt", O_RDONLY) = -1 ENOENT (No such file or directory)
stat("/usr", {st_mode=S_IFDIR|0755, st_size=104, …}) = 0
stat("/usr/share", {st_mode=S_IFDIR|0755, st_size=5498, …}) = 0
stat("/usr/share/ca-certificates", 0x7fff91f0cb30) = -1 ENOENT (No such file or directory)

It seems, that it only looks in two locations and my distro does not keep the certificates in them. So far, so good. Since I build Gwenhywfar with the –enable-system-certs setting, I built it again without that setting just to find out that it does not make a difference with respect to my problem.

Next I studied where the openSUSE distro expects the certificates and found some useful information in /usr/share/doc/packages/ca-certificates/README:

The canonical source of CA certificates is what p11-kit knows about. By default p11-kit looks into /usr/share/pki/trust/ resp /etc/pki/trust/ but there could be other plugins that serve as source for certificates as well.

The next paragraph in that file talks about legacy systems:

update-ca-certificate supports a number of legacy certificate stores for applications that don’t talk to p11-kit directly yet. It does so by generating the certificate stores in /var/lib/ca-certificates and having symlinks from the locations where applications expect those files.

Cool, that is it, but why is it not working for me? Well, the locations that are supported out of the box are not the ones AqBanking is using.

  • /etc/ssl/certs: Hashed directory readable by openSSL. Only for legacy applications. Only contains CA certificates for server-auth purpose. Avoid using this in applications.
  • /etc/ssl/ca-bundle.pem: Concatenated bundle of CA certificates with server-auth purpose. Avoid using this in applications.
  • java-cacerts: Key store fore Java. Only filled with CA certificates with purpose server-auth.
  • openssl: hashed directory with CA certificates of all purposes. Your system openSSL knows how to read that, don’t hardcode the path! Call SSL_CTX_set_default_verify_paths() instead.

Hmm, the contents of /etc/ssl/ca-bundle.pem looks very similar to what is kept in /etc/ssl/certs/ca-certificates.crt in other distros. I am a bit adventurous today, so I thought a simple

sudo ln -s /etc/ssl/ca-bundle.pem /etc/ssl/certs/ca-certificates.crt

can help. And in fact, it solved the problem of the unknown signer.

Now I have to find out, why AqBanking/Gwenhywfar always wants me to manually accept an institution’s certificate before I can use it. Or is this by design?

I’m writing this post on the train from Rome to Milan, but I guess better late than never. I’ll be in the city all week and I will host a Dolphin BoF on tuesday.

See you! :)

I'm going to Akademy 2019

September 06, 2019

During this year’s FOSDEM, I continued to practice live sketchnoting of the few sessions I attended (there are so many!!). I posted them on social media as I was working on them, but somehow I forgot to post them on my blog. Better late than never they say, so it’s time to fix that!

I hope you like them and will find them useful.

And it you’re wondering about Akademy… well stay tuned! ;-)

Latte Dock v0.9.2   has been released containing important fixes and improvements!

Go get  v0.9.2   from, download.kde.orgor*

- Win Indicator [youtube] -
- using all new v0.9.2 Indicators API- 

* archive has been signed with gpg key: 325E 97C3 2E60 1F5D 4EAD CF3A 5599 9050 A2D9 110E

  • FIX: do not hide contents/icons when qtquick software rendering is used
  • improve: close multiple windows from previews when using middle-click
  • improve: send tasks progress information to latte indicators
  • improve: latte indicators can offset their icons if they want
  • improve: latte indicators can provide different length padding values for applets compared to tasks
  • fix: activate single windows directly with left click in non compositing mode, and do not show the preview window in that case
  • fix: reverse scrolling direction for desktops and activities through empty areas
  • fix: after dragging active windows send a leave event and restore this way applets in normal state
  • fix: autostart Latte earlier in order to catch up with windows global menu activation. You need to reactivate it in order to work.
  • fix: forced solidness for panels has higher priority compared to panel backgrounds in isBusy state
  • fix: disable panel shadow if the user has enabled the corresponding option
  • fix: do not draw the panel background outline if the plasma default behavior was chosen for popups
  • fix: do not draw progress badge if user has disabled it
  • fix: support struts with thickness < 24px.
  • fixes for Clang


You can find Latte at Liberapay if you want to support,     Donate using Liberapay

or you can split your donation between my active projects in kde store.

The first minor release of the 19.08 series is out with usability fixes. The highlights include:

  • When using a resize effect on a video clip, Ctrl + resize allows you to keep the image centered.
  • Fixes for the custom audio effects that were broken.
  • The Encoder Speed in the render panel is working again allowing to set the encoder speed parameters to Slower, Medium, Faster and Ultrafast.

The stable AppImage is available from the KDE servers.

Other fixes:

  • Fix disabling clip only disable audio part of an AV clip. Commit. Fixes bug #411466
  • Fix regression breaking timeline resize. Commit.
  • Fix timelinekeyboard focus on start and grab not correctly ended. Commit.
  • Default effects to video. Commit.
  • Fix disabling autoscroll. Commit.
  • Convert old custom effects to new customAudio/Video naming. Commit.
  • Fix group move sometimes moving clip very far from expected location. Commit.
  • Ctrl resize in monitor effects keeps center position. Commit.
  • Shift resize in monitor effect keeps aspect ratio. Commit.
  • Update appdata version. Commit.
  • Fix effect/composition list filter working on untranslated strings. Commit.
  • Fix custom effects not recognized as audio. Commit.
  • Fix encoder speed ignored. Commit. Fixes bug #411000
  • Late update of version in appdata.. Commit.
  • Use the parameter readable and translatable name instead of its formal name for the color edit widget. Commit.

As many of you will know we, at KDE and together with GNOME, are organising the Linux App Summit (LAS for short). It will be in Barcelona between the 12th and 15th November.

For those of you who haven’t heard of LAS:

The Linux App Summit is designed to accelerate the growth of the Linux application ecosystem by bringing together everyone involved in creating a great Linux application user experience.


If you would like to talk about what you have been working on, you still can send us your talk. We extended our call for papers to the next week-end. You can learn more about it here:


Registration is now open, and it’s open to everyone! Meet leading experts in Linux and have interesting discussions about the future together.

You can register here:


Since June of this year, I’m working for NLnet foundation. NLnet gives grants to people to improve the internet.

NLnet is growing because it is handling grants for European Next Generation Internet (NGI) programs. This means more funds for new search technologies and privacy enhancing technologies. Typical grants go towards the creation of materials (mostly software) that are made available under free licenses.

I’m honoured to have been asked for this position and will do my best for the success of the projects that we support.

The list of projects that received support from NLnet is very long. In the past I was lucky enough to get grants from NLnet to work on Calligra, WebODF, and ViewerJS.


Akademy starts today, but alas, no akademy for me this year.

I’m celebrating my parents anniversary this weekend and will be at a water park instead of a warm bath of KDE-ers.

Luckily I can attend the new Linux App Summit in Barcelona in November which is back to back with RustFest. So I will not miss out on Free Software desktop conference this year.

My old friend and new colleague Michiel Leenaars is attending Akademy. He will be there to talk about the Next Generation Internet. Michiel will inspire the attendees to come work for an open internet with support from the EU and NLnet. His presentation is just after the Sunday keynote.

September 05, 2019

This week I went to Parliament square in Edinburgh where the highest court of the land, the Court of Session sits.  The court room viewing gallery was full,  concerned citizens there to watch and journalists enjoying the newly allowed ability to post live from the courtroom.  They were waiting for Joanna Cherry, Jo Maugham and the Scottish Government to give legal challenge to the UK Governement not to shut down parliament.  The UK government filed their papers late and didn’t bother completing them missing out the important signed statement from the Prime Minister saying why he had ordered parliament to be shut.  A UK government who claims to care about Scotland but ignores its people, government and courts is not one who can argue it it working for democracy or the union it wants to keep.

Outside I spoke to the assembled vigil gathering there to support, under the statue of Charles II, I said how democracy can’t be shut down but it does need the people to pay constant attention and play their part.

Charles II was King of Scots who led Scots armies that were defeated twice by the English Commonwealth army busy invading neighbouring countries claiming London and it’s English parliament gave them power over us all.  So I went to London to check it out.

In London that parliament is falling down.  Scaffold covers it in an attempt to patch it up.  The protesters outside held a rally where politicians from the debates inside wandered out to give updates as they frantically tried to stop an unelected Prime Minister to take away our freedoms and citizenship.  Comedian Mitch Benn compared it, leading the rally saying he wanted everyone to show their English  flags with pride, the People’s Vote campaign trying to reclaim them from the racists, it worked with the crowd and shows how our politics is changing.

Inside the Westminster Parliament compound, past the armed guards and threatening signs of criminal repercussions the statue of Cromwell stands proud, he invaded Scotland and murdered many Irish, a curious character to celebrate.

The compound is a bubble, the noise of the protesters outside wanting to keep freedoms drowned out as we watched a government lose its majority and the confidence on their faces familiar from years of self entitlement vanish.

Pete Wishart, centre front, is an SNP MP who runs the All Party Intellectual Property group, he invited us in for the launch of OpenUK a new industry body for companies who want to engage with governement for open source solutions.  Too often governement puts out tenders for jobs and won’t talk to providers of open source solutions because we’re too small and the names are obscure.  Too often when governements do implement open source and free software setups they get shut down because someone with more money comes along and offers their setup and some jobs.  I’ve seen that in Nigeria, I’ve seen it happen in Scotland, I’ve seen it happen in Germany.  The power and financial structures that proprietary software create allows for the corruption of best solutions to a problem.

The Scottish independence supporter Pete spoke of the need for Britain to have the best Intellectual Property rules in the world, to a group who want to change how intellectual property influences us, while democracy falls down around us.

The protesters marched over the river closing down central London in the name of freedom but in the bubble of Westminster we sit sipping wine looking on.

The winners of the UK Open Source Awards were celebrated and photos taken, (previously) unsung heros working to keep the free operating system running, opening up how plant phenomics work, improving healthcare in ways that can not be done when closed.

Getting governement engagement with free software is crucial to improving how our society works but the politicians are far too easily swayed by big branding and names budgets rather than making sure barriers are reduced to be invisible.

The crumbling of one democracy alongside a celebration and opening of a project to bring business to those who still have little interest in it.  How to get government to prefer openness over barriers?  This place will need to be rebuilt before that can happen.

Onwards to Milan for KDE Akademy.


I will be at Akademy 2019 in Milano, IT for a few days. I am not going alone, Julia JK König. from MBition, will be there with me during the first two days.

MBition is still in the learning phase as organization when it comes to Open Source, but the enthusiasm among my colleagues, including the leadership team, with the posibility of becoming contributors in the near future makes me confident about our Open Source journey.

One of my initial goals is to help the organization to learn about how Open Source communities operate, what are their motivations, what do they do, their governance, etc. As I have written before, I would divide the Open Source communitiesin three big groups:

  • Community driven Open Source projects.
  • Consortium driven projects.
  • Company driven projects.

In order to learn about community driven projects, I think KDE is a great place to start and not just because I am involved in the project. There are several additional reasons. The most obvious ones are:

  • MBition is a C++ and Qt house, just like KDE.
  • KDE has a significant experience in areas were MBition is currently working on.
  • MBition (and Daimler in general) collaborate with Universities in intership programs. KDE is one of the most successfull Open Source projects when it comes to mentoring programs.
  • MBition HQ is located in Berlin, GE, and KDE eV is registered there.
  • I am not the only current or former KDE contributor at MBition. Motivation is king.

MBition decided not just to attend to Akademy but also to become a Supporter, by the way.

See you there.

I am pleased to announce that Qt 5.13.1 is released today. As a patch release, Qt 5.13.1 does not add any new functionality but provides many bug fixes and other improvements.

Older blog entries

Planet KDE is made from the blogs of KDE's contributors. The opinions it contains are those of the contributor. This site is powered by Rawdog and Rawdog RSS. Feed readers can read Planet KDE with RSS, FOAF or OPML.