Skip to content

Wednesday, 1 January 2020


Carlos Alves cbcalves 00:00 +00:00

About 🔗

Carlos Alves cbcalves 00:00 +00:00
This site was written in Go, Hugo is an open source static site generator available under the Apache Licence 2.

Contact 🔗

Carlos Alves cbcalves 00:00 +00:00

Tuesday, 31 December 2019

Another year of Kaidan development is over. Kaidan is still not usable for daily use, but we also got many things done and our vision of a simple and powerful Jabber/XMPP client for everyone came a good step closer. This is a summary of what we have done in this year.


In January not much happened in Kaidan itself, but Linus Jahn started to work on the MIX implementation in QXmpp, the XMPP library we are using. MIX stands for Mediated Information eXchange and is the upcoming modern groupchat extension for XMPP, replacing the old, IRC-like MUC (Multi-User Chat).

For details, have a look at the issue for MIX.


Plasma Mobile Sprint in Berlin

We were much more active in February, this is also because of the Plasma Mobile sprint in Berlin that Ilya Bizyaev, Jonah Brüchert and Linus Jahn attended.

The sprint week was in the end one of the, or even the most productive week for Kaidan in this year. Thanks to Endocode for hosting us!

Day and night at the Plasma Mobile sprint

View from the Plasma Mobile sprint at day and night (CC BY 4.0, Linus Jahn)

Qt Quick Compiler

Jonah Brüchert added support for building Kaidan using the Qt Quick Compiler which leads to no visual changes but an improved performance. This is worth mentioning, because this is also required for being accepted in the Apple App Store since they do not allow the usage of JIT compilers. The Qt Quick Compiler converts Kaidan’s QML code into binary code in advance.

Last Message Correction

Jonah Brüchert and Linus Jahn worked together on implementing the Last Message Correction extension, which allows you to (as the name suggests) send corrected versions of your last message. Previously, if someone corrected their message, the corrected message just appeared as a new message.


One advantage of free software is that you can share the code that somebody else has written already. Jonah Brüchert did that with the Spectral’s Emoji picker that he added to Kaidan.


At the one-week Plasma Mobile sprint Linus Jahn also worked on Kaidan’s back-end and added the functionality to download received files. Uploading was already implemented using HTTP File Upload. This was one essential missing point for the Kaidan 0.4 release.


Linus Jahn also did some experiments with MAM, the extension used for receiving messages from the server’s archive. MAM is also needed when you want to receive your offline messages and you have multiple devices in use. Fortunately MAM is already supported by QXmpp. While trying to use this, we noticed that Kaidan’s database back-end is blocking the user interface when inserting new messages. In practise this made Kaidan unusable when the message history is loaded. Upon that Linus Jahn started to rewrite the database back-end using different threads. (In the end we found out that the problem was not that the database is running in the same thread, but that the database was safely saved to disk after each message. However, having the database separated in a different thread is still a good thing.)


Consistent Color Generation

In March Linus Jahn implemented XEP-0392: Consistent Color Generation for generating user / contact colors that are consistent with all different XMPP clients and devices.

Jonah Brüchert could use that to replace our old fallback avatar image with proper text avatars. They contain the first two letters of the contact’s name and use the consistent user color as background.

Berlin XMPP Sprint

The Berlin XMPP sprint was (not like the Plasma Mobile Sprint) only a weekend long. It was very nice for us to finally meet many people known from the mailing lists and MUCs. At the sprint itself didn’t do much of coding and rather got to talking with the attendees.

One major feature was realized though, spoiler messages were implemented at the sprint by on of the co-authors of the XEP, Xavier Ferrer. That we were in direct contact at the sprint was very helpful here, so Linus Jahn could assist in the whole process.

Many other things that happened can be found in the blog post by our host, Tim Schrock from the DBJR.


In April we launched our website based on the design of the Falkon web browser. Posts for the old releases were added belated, so the website was not completely empty.

We also published a release candidate for Kaidan 0.4.

Jonah Brüchert worked on Windows builds using the cross-compilation toolchain MXE that could be added to our GitLab pipeline allowing us to have automated builds for every merge request and commit.


In May we introduced the new adapting settings page by Jonah Brüchert which is used on a new layer on mobile devices and inside of a sheet on desktop.

The first thing we used the settings for was the new change password dialog by Jonah Brüchert (user interface) and Linus Jahn (back end). It allows you to change the password of your account on the server now.

We also got two new contributors to Kaidan, Melvin Keskin and Germán Márquez Mejía (mancho) who later participanted in Kaidan and QXmpp.


Melvin Keskin improved the presence indicator by replacing the dot on the avatars by a vertical bar at the side of the contacts on the contacts page.

Jonah Brüchert added automated macOS builds using the cross-compilation toolchain osxcross.

The emoji picker was improved by Filipe Azevedo. He added an emoji search and a favourite emoji tab to it.

Linus Jahn and Melvin Keskin finished the database rewrite to solve the UI blocking problem.

The notifications were previously only added as a proof-of-concept using the libnotify-bin command in a shell. Linus Jahn replaced this by KNotifications. This allows us to have notifications on most of the platforms, currently missing iOS.


In July we finally released Kaidan 0.4, details about that can be found in the blog post.

Linus Jahn implemented XMPP URI parsing in Kaidan. This is important for us to read QR codes in the future, e.g. for OMEMO or to log in with an account.

QR code scanning was implemented by Linus Jahn and Melvin Keskin. It can be used to scan (currently not standardized) XMPP login QR codes, allowing a very fast account transfer to another device.

Robert Maerkisch implemented the new contacts search and notification muting for contacts under assistance from Linus Jahn.

Jonah Brüchert (UI), Linus Jahn (back end & UI) and Robert Maerkisch all worked together on the new VCard based profile page and also contact renaming.

Jonah Brüchert published Kaidan on the Flathub, so Kaidan (stable) can be easily used on all Linux distros providing flatpak.

Melvin Keskin and Linus Jahn started to work on the in-band registration in QXmpp and in Kaidan. Jonah Brüchert helped with UI designing.


Basically nothing happened in August. :’(


In September Linus Jahn became the new lead-developer of QXmpp, allowing us way faster progress there since the original author(s) are not very active anymore.


In October Volker Krause helped us to fix the Android builds with KNotifications. Volker was the one who implemented notifications for Android in KNotifications for KDE Itinerary.

On requests Linus Jahn added a secondary roster (contact list) sorting by contact name, so the contacts are at least not randomly sorted when logging in for the first time.


In November a new contributor, Yury Gubich (Blue), implemented a nice message search with animations.

Also, Filipe Azevedo’s huge multimedia recording branch could finally be merged after several months. You can now record images from your camera, voice and video, all in Kaidan. What’s also new are the previews in the chat for audio and video.


In December we did some refactoring and Melvin Keskin did some design improvements to the chat and other parts of Kaidan.

Linus Jahn and Melvin Keskin together with an iOS developer started to work on proper iOS support.


2019 was a great year, we got many new contributors and have implemented many features. Let’s see what we can do in the next year.

Some weeks ago I wrote about SPDX identifiers and how they can be used to annotate source code files with machine readable license information. In this post, now I want to compile the things I learned after looking more deeply into this topic and how it might be applied to KDE.

SPDX identifiers are an important step in order to allow tools an automatic reading and checking of license information. However, as most norms, the SPDX specification is quite general, for many people cumbersome to read and allows many options on how to use the identifiers; while me as a developer, I just want to have a small howto that explains how I have to state my license inormation. Another point is that in my experience any source code annotation with machine readable information is pointless unless you have a tool that automatically checks the correctness. Otherwise, there is a big burden on code reviews that would have to check tiny syntactical requirements from a specification. — If you look deeply into the used license headers in KDE (I did this), there is a shocking number of different license statements that often state exactly the same. This might be due to different formatting or typos but also due to actual faults when trying to pick the correct license for a use case, which somehow got mixed up.

While doing research on best practices for applying machine readable license information, I was pointed to the initiative, which was started by the Free Software Foundation Europe (FSFE) to provide a set of recommendations to make licensing easier. What they provide is (in my opinion) a really good policy for how to uniformly state SPDX based license headers in source files, how to put license texts into the repository and a way to automatically check the syntactical correctness of the license statements with a small conformance testing tool.

I really like the simplicity of their approach, where I mean simplicity in the amount of documentation you have to read to understand how to do it correctly.

Meanwhile in KF5…

As already said, I want to see machine readable license information in KDE Frameworks in order to increase their quality and to make them easier to use outside of KDE. The first step to be done before introducing any system for machine readable identifiers is to understand what we have inside our repositories right now.

Disclaimer: I know that there are many license parsing tools out there in the wild and I know that several of them are even well established.

Yet, I looked into what we have inside our KF5 repositories and what has to be detected: Most of our licenses are GPL*, LGPL*, BSD-*-Clause, MIT or a GPL/LGPL variant with the “any later version accepted by the membership of KDE e.V. (or its successor approved by the membership of KDE e.V.), which shall act as a proxy […] of the license.” addition. After a lot of reasoning, I came to the result that for the specific use case of detecting the license headers inside KDE project (even focused only on frameworks right now) it makes most sense to have a small tool only working for this use case. The biggest argument for me was that we need a way to deal with the many historic license statements from up to 20 years ago.

Thus, I started a small tool in a scratch repository, named it licensedigger and started the adventure to parse all license headers of KDE Frameworks. From all source files right now I am done with about 90%. Yet, I neglected to look into KHTML, KJS, KDE4LibsSupport and the other porting aid frameworks until now. Specifically for the Tier 1 and Tier 2 frameworks I am mostly done and even beasts like KIO can be detected correctly right now. Thus, I am still working on it to increase the number of headers to be detected.

The approach I took is the following:

  • For every combination of licenses there is one regular expression (which only has the task to remove whitespace and any “*” characters).
  • For every license check there is a unit test consisting of a plaintext license header and a original source code file that guarantees that the header is found.
  • Licenses are internally handled with SPDX markers.
  • For a new license or a license header statement for an already contained license, the license name must be stated multiple times to ensure that copy-past errors with licenses are minimized.
  • It is OK if the tool only detects ~95% of the license headers, marks unknown headers clearly and requires that the remaining 2-3 files per repository have to be identified by hand.

At the moment, the tool can be run to provide a list of license for any folder structure, e.g. pointing it to “/opt/kde/src/frameworks/attica” or even on “/opt/kde/src/frameworks” will produce a long list of file names with their licenses. A next (yet simple) step will be to introduce a substitution mode that replaces the found headers with SPDX markers and further to add the license files in a way that is compatible with REUSE.

Please note that there was no discussion yet on the KDE mailing list if this (i.e. the REUSE way) is the right way to go. But I will send respective mails soon. This post is mostly meant to provide a little bit of background before starting a discussion, such that I can keep mails shorter.

This blog is to inform that Kraft, the Qt and KDE based desktop software to manage documents like invoices and quotes in your small company was released in version 0.90 recently.

Followup Documents

A great new feature is the completely reworked handling of so called follow-up documents. Kraft has this feature to help dealing with docs that follow on a certain kind of predecessor doc in the business flow, such as an invoice follows on an offer once the work has been finished.

Document flow exampleTo achieve that and to have all the items of the offer again referenced in the invoice, the Kraft user justs clicks on the menu item “Create Followup Document” on the selected offer, and the new doc is created with all the items of the offer prepared. It is ready to be adjusted to the final invoice details.

Now with version 0.90 this has even improved. Often, the flow is a bit different because a partial invoice is sent while the job is still in progress, for example to cover cost for material. A partial invoice usually has only one item, which is the progress payment the customer should pay.

Kraft users can handle that now very easy: The new UI does not only allow to choose from which predecessor document the final invoice should copy the items (which usually is the offer in the beginning) but it also realises that a partial invoice was sent before, so this amount of payment has to be substracted from the final invoice. Kraft adds an item to the final doc automatically here.

This helps to create high quality documents for your customers even faster, which is exactly the mission of Kraft.

Other Improvements

In addition to that, as usual a lot of other visible and invisible changes have gone into this release. For example, the UI has been simplified again by a clean up of the menu for example. The About Kraft dialog was removed and integrated into the Kraft information page.

Under the hood, we finally added unit tests, which is just a start so far, and ntroduced a new, XML based system to manage the available document types which makes igrations way easier. Last but not least the python based pdf conversion script was ported to python 3 to be ready for the end of python 2.


Last but not least, Kraft got new contributions from the community: A new document type was initiated by a community member, which is a offer like document without showing the price information. Also, the complete app was translated to Dutch by a volunteer, and the translation is now shipped with Kraft by default. Also, other smaller bugfixes went in.

Thank you all for your help to improve Kraft.

Sunday, 29 December 2019

Hello, how are you? I hope that you are good. =D

2019 is almost over, and this year Atelier didn’t have the amount of love and care that I wish I had given. Among finishing college(Yay!), changing jobs(Awesome!) and traveling for events(Akademy <3), I didn’t have enough time for it.

However, a while ago, I had started to build a plasmoid, i.e., a widget for your awesome Plasma Desktop for you to quickly select a 3dprinter and a gcode file and 3d print it. But I didn’t reach a useful state of the widget.

But yesterday I was kinda bored with my work, since I am doing home office for a couple weeks because I have twisted my ankle (I am better now, but holidays). So I went to remove the durty of my plasmoid code and see if I was able to make it finally work.

And I did. (Uhul!!!)

I have followed the “Getting Started” guide from the KDE Wiki and with a few QML controls and AtCore native support to use it with QML, I had the following result:

With a quick CMake build and install I can add this plasmoid to my Plasma desktop and use it to print a file and have basic control of the printer temperatures.

There’s a couple of bugs that are from AtCore(maybe? for sure? need to debug) and Chris is already pinging me up to add the use of AtCore Printer Profiles on this widget, so you can skip the baud and firmware selection.

But for now, you can check the source code on my KDE Gitlab Repository, install, and use it. Feel free to fork it and send Merge Request if you want too. Feedbacks are welcome.

Remember to check the Readme for full information on how to build and install it.

I hope that you have amazing Holidays and that in 2020 we keep doing awesome code with and for the KDE Community. =D

That’s all folks.

Sunday, 1 September 2019

Now it’s the end of Google Summer of Code 2019. As my GSoC project, the port of KDE Connect on macOS has made great progress. You can find and download it in my blog release page.

Note: This post aims at presenting the features of KDE Connect which have been implemented on macOS. If you’d like to know more information, such as compilation of your own KDE Connect binary on macOS, please turn to another post in my post Connect your Android phone with your Mac via KDE Connect. And if you’re interested in what I’ve done during Google Summer of Code, my status report of Google Summer of Code is HERE.


In this chapter, I’d like to give you a preview of all features, as well as how to configure to make some of functions work.

Launch KDE Connect

First, we can click on KDE Connect application - the to open it.

Then, we can open KDE Connect configuration window from the indicator in the tray bar of macOS.

As you can see, this is the main page of KDE Connect. All available plugins are here, you can enable/disable or configure them. In addition, available devices will be listed on the left, you can choose them to pair/unpair with them/it.


Pair notification

When you pair from your Andoid Phone, you should be able to receive a notification that shows the pair request. You can accept or reject it in the KDE Connect configuration window, or you can do it with KDE Connect indicator tray icon, there would be an entry for the pair request as well.

Otherwise, if you change the notification type of KDE Connect to alert in the system preference, you should also be able to do a quick action with the notification itself. Just as I showed in Enable notification plugin in KDE Connect on macOS.

Once paired, you can enjoy your adventure on macOS with KDE Connect!

Clipboard synchronization

The text that you copy on your Mac will be shared to your phone, and those you copy on your phone will be also synchronized to your Mac.

Notification synchronization

With KNotifications support for macOS, you can receive notification from your Android phones and react to them. You can ping your Mac to test whether they are well connected.

Sending file

Sharing your file on your Mac with your Android phone is also a basic feature. You could also send a file from your Android phone, by default, the file will be saved in the Downloads folder in your Mac.

System Volume

You can control the system value of your Mac from your Android Phone remotely.


With my SFTP browser, you can browse files in your Android Phone from your Mac, easily synchronize a file.


Thanks to SMS application of Simon Redman, sending and receiving SMS on your Mac are possible!

Running command

Run command from your Android phone. I believe that using AppleScript, more and more things that KDE Connect can do on macOS, will be discovered, maybe by you!

Mouse and Keyboard

You should be able to use your Android phone as a temporary trackpad and a keyboard. But it needs your permission to allow your Android phone to do it on your Mac. The GIF above shows how to do that.


Except the functions shown above, you can also do these from your Android phone:

  • Keep your Mac awake when your phone is connected
  • Use your phone to control your slides during a presentation
  • Check the battery level of your phone
  • Ring your phone to help find it

And, you may have noticed that, in the screen capture, there are KDE Connect in dark mode and in light mode. Thanks to Qt, we are able to benefit it.

Furthermore, there is no doubt that more functions will be delivered and released in the future. We are all looking forward to them.


There are some issues that we’ve known and we are trying to fix them.

The released application package isn’t notarized and still has some lirary reference issues. So, it requires you to manually open it, if it’s rejected by Gatekeeper(package validator on macOS), like that showed in the image above.

We’ll try to fix all issues and make a release which you can run it without barricade.


Thanks to KDE Community and Google, I could finish this Google Summer of Code project this summer.

Thanks to members in KDE Connect development. Without them, I cannnot understand the mechanism and get it work on macOS so quickly :)


If you have any question, KDE Connect Wiki may be helpful. And you can find a bug tracker there.

Don’t be hesitated to join our Telegram Group or IRC channel if you’d like to bring more exciting functions into KDE Connect:

  • Telegram
  • IRC (#kdeconnect)
  • (

I wish you could enjoy the seamless experience provided by KDE Connect for macOS and your Android Phone!

Friday, 14 October 2016

One afternoon twenty years ago Matthias Ettrich and Martin Konold sat at a stone table in the cafeteria of the university Tübingen and talked computers. They talked Linux and they talked desktop. They talked about making Linux accessible to everyone. This was the moment where KDE was born. This afternoon they walked away with a mission. Matthias went on to write the call to action to found the KDE project, and Martin to create the very first KDE mailing list

On October 14th 1996 the famous announcement arrived on the newsgroups comp.os.linux.development.apps, comp.os.linux.misc, and de.comp.os.linux.misc:

    New Project: Kool Desktop Environment. Programmers wanted!

The new project quickly attracted a group of enthusiastic developers and they pushed out code with a frentic pace. kdelibs-0.0.1 was released in November, containing the first classes KConfig and KApplication. In May 1997 the young project presented at the Linux-Kongress in Würzburg. In August Kalle Dalheimer published the famous article about KDE in the German computer magazine c't which attracted a whole generation of KDE developers to the project. On Jul 12th 1998 KDE 1.0 was done and released. The community had not only implemented a friendly face for Linux but also a bunch of applications while going, including a full web browser.

KDE did hundreds more releases over the years, continuously improving and maintaining the growing number of applications and amount of code. The community grew. It started to do annual conferences such as Akademy or the Desktop Summits and focused developer sprints such as the Osnabrück or the Randa meetings. KDE e.V., the organization behind KDE, which was founded as partner for the KDE Free Qt Foundation, grew with the community to be the corner stone of the organizational structure of KDE, using German association law as its secret superpower (read more about this in the book "20 Years of KDE: Past, Present and Future").

Millions and millions of people used KDE software over the years. Thousands of people contributed. KDE made appearances in Hollywood movies, it was subject of theses and scientific studies, and it won many awards. KDE's founder, Matthias Ettrich even received the German Federal Cross of Merit. The timeline of twenty years of KDE is an impressive demonstration of what Free Software is able to achieve.

Akademy 2014 group photo by Martin Holec (CC-BY)

KDE also was a breeding ground. Many people started their careers there. Hundreds of students went through mentoring programs such as the Summer of Code or the Season of KDE. Whole projects emerged from KDE, such as ownCloud and its sibling NextCloud, Kolab, or KHTML, which turned into WebKit and then Blink, powering most of web browsers on this planet today.

Today Linux has reached world domination in various, sometimes surprising, ways. KDE has contributed its share to that. With Plasma it provides a slick and powerful desktop which does make Linux accessible to everyone. This mission has been accomplished. But there is more. Following KDE's vision of bringing freedom to people's digital life there are amazing projects exploring new areas through Free Software, be it an application such as Krita to bring freedom to digital painters, or a project such as WikiToLearn to create collaborative text books for education. When KDE people meet you can feel the enthusiasm, the openness, and the commitment to change the world to the better just as in the days of the beginning.

I joined KDE in 1999 with my first patch to KOrganizer. I wrote a lot of code, maintained and founded applications, served on the board of KDE e.V. for nine years. Most importantly I found a lot of friends. Neither my personal nor my professional life would be what it is today without KDE. I owe a lot to this community. Thank you for the last twenty years.

Friday, 21 August 2015

Update 1: Google Play still not has the newest version, but it is incomming in the following days
Update 2: There is an open beta version now, you can get it from here from Google Play.

Marble Maps has the following features:
  • Wondering around on the map
    • You can move the map with one finger by dragging the map with it
    • It will increase the zoom if you touch double times fast to the map
    • You can also zoom with two fingers (only supported on multitouch devices)
  • Handling your position
    • You can check your position on the map
    • You can check the distance and direction to your position when your position is not visible
    • You can center the view to your position
  • Routing
    • You can plan routes via interactive placemarks, you have to search for something and after that, you can use the result as a waypoint
    • Also, you can modify the route instead of the interactive waypoints with the route editor which is available from the menu

    • To get the routing instructions, visit the menu too
    • You can select from three routing profile: with car, with bike or as a pedestrian
  • Navigation
    • You can navigate on the route what you have planned previously, or you can also navigate to a single destination
    • Marble Maps shows your position on the route with a different icon
    • It provides turn-by-turn based navigation
    • It uses the Text To Speech interface of the Android system to provide voice instructions. To use it, please install it from Google Play
    • It shows the next instruction and its distance too
    • The current speed and the distance to the destination is also visible 

Some techincal background:
Marble's base source code in this summer has become Android compatible. If you want an Android app can be built on the top of it. Any map can be loaded in, and all of the projections are available. It supports some plugins too.

And finally my personal experience about the summer:
I liked to work on this project very much because I have learned a lot of new things, like coding technics, I have got closer to QML and I also have had a deeper insight on how Android applications work. It was also good to work with the people of the community. I would like to thank to everybody who helped me this summer, especially to Dennis Nienhüser and to Torsten Rahn. Without them Marbe on Android would be still a dream.

Thank you Google for this fantastic opportunity!

But the story is not ending here, so stay tuned...