Skip to content

Friday, 20 August 2021

I have been using the GIMP since about 20 years or so, but recently started to also work with Krita since I found it quite nice to work with (besides the text module, which is a pain).

As there came out the first beta of Krita 5, I decided to throw it into my KDE/Plasma OBS builds to try it out. To get it working, add my OBS key say in /usr/local/share/keyrings/obs-npreining.asc and add a file /etc/apt/sources.lists.d/obs-npreining-krita-beta.list, containing the following line:

deb [signed-by=/usr/local/share/keyrings/obs-npreining.asc] ./

Warning: Krita will also warn you, but files saved with version 5 might not be openable with version 4 of Krita, so be sure to have a backup of your files in case you need to go back to Krita 4.


Wednesday, 18 August 2021

Bullseye has been released, and we are in the post-release rush with lots of changes going on. On the KDE/Plasma side we are trying to move all our accumulated changes to unstable. On the OSC side, frameworks 5.85 and KDE Gears 21.08.0 have been released.

Debian Bullseye

As mentioned previously, the now released Debian/Bullseye contains KDE Frameworks 5.78, including several backports of fixes from 5.79 to get smooth operation. Plasma 5.20.5, again with several cherry picks for bugs will be in Bullseye, too. The KDE/Apps are mostly at 20.12 level, and the KDE PIM group packages (akonadi, kmail, etc) are at 20.08.

Debian unstable (and in time also testing)

Frameworks 5.83 and Plasma 5.21.5 have been uploaded to unstable. This is a temporary measure until several necessary packages have cleared the NEW queue. After that we will upload frameworks 5.85 and Plasma 5.22.N.

KDE Gears is still at 20.08, but we have 21.04 in experimental, and I am currently preparing to upload 21.08.0, should be done soon.

OBS packages

The OBS packages as usual follow the latest release, and currently ship KDE Frameworks 5.85, KDE Gears 21.08.0, and Plasma 5.22.4. The package sources are as usual (note the different path for the Plasma packages and the apps packages, containing the release version!), for Debian/unstable:

deb ./
deb ./
deb ./
deb ./

and the same with Testing instead of Unstable for Debian/testing.

OBS for bullseye

For now, use the Testing packages with the addition dependencies:

deb ./
deb ./
deb ./
deb ./
deb ./

Sooner or later OBS will offer Debian Bullseye as proper target, and then I will prepare releases for it and write another blog post.


Expect continued breakage of the next weeks until the upload storm subsides a bit.

Tuesday, 17 August 2021

Hi everyone! GSoC coding period is in its last stage, The final evaluation has started yesterday, I am really happy that all activities have been finished on time, 3 of them are already merged in master and I hope the last one will also be merged soon.

In the past 2 weeks, I was working on finalizing mouse control action activity:

  • The “click” circle appears only if the pixel is exactly the same on pressed and on released, we found it is better to to give it a bit of tolerance, as for touch input it might be very hard to stay on the same pixel.
  • Supporting swipe gestures for phones/tablets and mouse movements by making the main duck moving by hovering in case of laptops or it can move by touch inputs using MultiPointTouchArea in case of phones/tablets.
  • Fixing an issue result from a side effect of hover + drag combination as when doing click-drag, on release the duck can jump position.
  • Making the main duck motion more smoother by moving it a short distance and within a very short duration/repetition.
Mouse Control Action Activity


The activity was tested on another Qt version (Qt5.9) and it didn’t work as expected, though it works good on Qt5.15, I was using the startX and startY properties of the TouchPoint (these properties hold the starting position of the touch point). The problem is that these properties are always zero though they have value, as a result it effects the activity’s main functionality. To solve this problem, I have implemented my own startX and startY properties and assigned them the starting position of the touch point when the release signal is triggered in the MultiPointTouchArea.

It has been an awesome journey with KDE, I can safely say that this past summer has been an immensely gratifying learning experience. All of this has been possible only because of my mentors Timothée Giet, Johnny Jazeix and Emmanuel Charruau, They not only helped me throughout the process but made sure to appreciate my work and gave me constructive feedback at every turn. I’m extremely grateful for the opportunity to learn from such talented people. Thank you to the KDE community for bearing with me while I got up to speed with way things work.

Thank you so much for this wonderful summer 🙂

Monday, 16 August 2021

Well, we all know that the work on open source projects is never truly finished, but all of the core goals have been achieved and the time is up :). In this post I’ll briefly summarize my GSOC work and then talk about one last small but user-facing feature that I’ve implemented.

I’ve successfully implemented a new DSO backend and smoothed out most of the bugs. The python framework does work satisfactory and all existing catalogs have been ported. There remains the UGC catalog which will be imported in the future, either by me or by another member of the project. The latter option would be a good way to battle-test the documentation and I would prefer this option because I do not want to remain the only person familiar with the system.

To quantify my contributions during the GSOC period see the snippet below, although I do not think such numbers have much to say1.

Valentin Boettcher <>:
       insertions:    15193  (19%)
       deletions:     23402  (35%)
       files:         312    (21%)
       commits:       76     (23%)
       lines changed: 38595  (26%)

Furthermore there is (the list of my merge requests)2 which does go into more detail.

The user-facing side of my work is not very prominent. There is a small GUI for managing catalogs that allows importing, exporting, creating and editing catalogs.

There is also a basic CSV importer that should make it easier for users to get their own custom data into KStars.

Figure 1: The CSV importer. It sure needs some prettying up :P.

Figure 1: The CSV importer. It sure needs some prettying up :P.

Nevertheless, the main goal of my work was to create a seamless replacement for the old DSO system of which the user should not be too aware. To that end, I’ve implemented a feature that should have been in my overhaul from the beginning: a mechanism to import custom objects from the old DSO database. Now, on startup the user is being asked whether the old database should be imported if it is present.

And finally: Colors!

The DSOs always had a distinct color depending on the catalog they’re from. Right from the outset one complaint from early testers were the garish colors that I chose for the catalogs. I “fixed” this problem by simply choosing more subdued colors. But colors are a matter of personal taste. Also, a single color can’t fit all of KStars' color schemes. Therefore colors can now be customized for each catalog and color scheme through a “pretty” dialog.

Figure 2: The &ldquo;pretty&rdquo; color picker.

Figure 2: The “pretty” color picker.

Now you can do things like this:

Figure 3: Color Scheme: Moonless Night

Figure 3: Color Scheme: Moonless Night

Figure 4: Color Scheme: Starchart

Figure 4: Color Scheme: Starchart

And again I’ve learned that user feedback is very important. I would never have thought of this feature on my own but must admit that it enhances the usability of KStars greatly.

With that oddly specific foray into the world of colors I now conclude this blog post and thank you for your attention.

Cheers, Valentin

  1. I deleted the old OpenNGC text catalog which contained more than ten thousand lines :P. ↩︎

  2. You have to paste this link into the url bar manually to make it work! ↩︎

We’ve reached the final few days of Google Summer of Code 2021. It has been an amazing journey. I learned so many new things throughout this journey. It makes me proud that I’ve contributed to KDE, which is an amazing open source organization. It brings immense pleasure to know that my work is going to enhance GCompris project, which has thousands of active users. Though GSoC is coming to an end, I strongly believe, this is not the end to my contributions towards KDE or open source software in general.

In my previous blog, I talked about Oware activity. Oware is an abstract strategy game among the Mancala family of board games. I had already completed the basic layout for this activity. In the past few weeks, I worked on making the actual game mechanics, adding animations to the activity, and also creating a simple oware engine for playing the game against the computer.

Oware against Computer

In this activity, the user controls the upper 6 pit with green border, and the computer controls the bottom 6 pits with purple border.

Oware against Computer: demonstration of automatic move by computer

The engine is a basic one. Out of all valid moves, it picks any one random move.

When captures happen in clockwise fashion. Whenever a pit ends with two or three seeds in opponents camp, it can be captured by the player, before the streak of consecutive captures break.

Demonstration of multiple captures

Oware against a friend

In this mode, the computer does not play any role. Two sides of the board are controlled by two different users.

Oware against a friend: Demonstration of two player mode


  • Implementing the animations was a challenging task. Lot of different animations were to be play sequentially one after the other. It involved a lot of manual recursive triggers. The base cases were very important to not get stuck into an infinite recursion.
  • The layout of the activity was quite a challenge. The idea of show a particular pattern for displaying a specific number of seeds in a pit was quite challenging task.
  • Implementing the rules of the game was also quite challenging.

What next?

I completed almost all the objectives of this task. A few of the objectives were not met, and could be easily extended from the current code. The following sub tasks are left for future work:

  • Offer draw to opponent, detect if accepting draw is feasible for computer.
  • Implement tougher engines for oware. The current engine randomly picks one valid move. Though even random moves are strong, and so simple to win over the computer.


It has been an awesome journey with KDE. Working on GCompris project was very interesting. Path activities has already been merged to main branch. Oware activities are still under review. I believe it would be merged soon to the main branch.

Thanks for reading!

I’m happy to announce first release of QCoro, a library that provides C++ coroutine support for Qt.

You can download QCoro 0.1.0 here or check the latest sources on QCoro GitHub.

I have talked about QCoro (and C++ coroutines in general) recently at KDE Akademy, you can view the recording of my talk on YouTube.

In general, QCoro provides coroutine support for various asynchronous operations provided by Qt. Since Qt doesn’t support coroutines by default, QCoro provides the necessary “glue” between native Qt types and the C++ coroutine machinery, making it possible to use Qt types with coroutines easily.

QCoro provides coroutine support for asynchronous operations of QIODevice, QNetworkReply, QProcess, QDBusPendingReply, QTimer and more. Take a look at the documentation for detailed description and list of all currently supported Qt types.

A brief example from our documentation that demonstrates how using coroutines makes handling asynchronous operations in Qt simpler:

This is a (simplified) example of how we do network requests with Qt normally, using signals and slots:

QNetworkAccessManager *manager = new QNetworkAccessManager(this);
QNetworkReply *reply = manager->get(url);
connect(reply, &QNetworkReply::finished, this,
        [this, reply]() {
            const auto data = reply->readAll();

And this is the same code, written using C++ coroutines:

QNetworkAccessManager networkAccessManager;
QNetworkReply *reply = co_await networkAccessManager.get(url);
const auto data = reply->readAll();

The co_await keyword here is the key here: it asynchronously waits for the reply to finish. During the wait, the execution returns to the caller, which could be the Qt event loop, which means that even if this code looks synchronous, in fact it won’t block the event loop while keeping the code simple to read and understand.

Saturday, 14 August 2021

A relatively easy way to decide what communication activities are appropriate for your Free Software project.

Friday, 13 August 2021

Let’s go for my web review for the week 2021-32.

This scientist says cleaning indoor air could make us healthier—and smarter

Tags: air-quality, science

Clean indoor air is important for a lot of health factors… Including the pandemic.

Atlantic Ocean currents weaken, signalling big weather changes - study

Tags: climate, ecology

If confirmed this is seriously bad news…

Apple Privacy Letter: An Open Letter Against Apple’s Privacy-Invasive Content Scanning Technology

Tags: tech, apple, surveillance, security, privacy

The Apple ecosystem hell bent on becoming extremely privacy invasive… Per usual it’s justified by “protecting the children” or some other false pretense. Don’t be fooled, once it’s in, it’ll just expand in scope and governments will do everything they can to tap in the content of those scans.

If You Build It, They Will Come: Apple Has Opened the Backdoor to Increased Surveillance and Censorship Around the World | Electronic Frontier Foundation

Tags: apple, surveillance

Thanks you Apple for creating the perfect tools for private and governmental surveillance. Now, we can probably expect a race to the bottom from the other players as well.

After DeepMind’s cofounder was placed on leave for bullying, Google promoted him

Tags: tech, google

Such a nice company…

SAML is insecure by design

Tags: tech, saml, security

Interesting exploration and rough explanation of why SAML has so many issues. Complexity by design in such critical components is a bad idea…

CSS Transforms tutorial

Tags: tech, web, frontend, css

Nice summary of the abilities coming from CSS transforms.

Working Around a Case Where the Postgres Planner Is “Not Very Smart” - Heap

Tags: tech, databases, postgresql, performance

Interesting exploration and workaround for the Postgres query planner.

Bye for now!

Wednesday, 11 August 2021

In one of our previous blog posts we wrote about the new development in the spreadsheet and the extension in the statistics dialog that now make use of new visualization elements. One of these elements is the Box Plot:

Box Plot

Of course, this new visualization type is not only available in the statistics dialog in the spreadsheet, but it can also be used in the Worksheet, in the area where LabPlot plots the data. In this blog post we will introduce this important new development, as it is going to be part of the next release.

A box plot (also known as a box-and-whisker plot) provides a quick visual summary of the important aspects of a distribution of values contained in a data set:

Anatomy of a Box Plot

A more detailed description of the components of a box plot can be found in our documentation.

Even though this is the first release of this visualization type, we decided to implement many features for this very powerful visualization tool. LabPlot’s box plots supports different orientations (horizontal and vertical), different types of whiskers, variable widths, plotting of multiple data sets in one plot, and much more. A great variety of box plot visualizations can be achieved by using and combining the available options. To give you an idea of what is possible in LabPlot see below a couple of examples.

The first examples demonstrate the visualization of multiple data sets using different orientations of the box plots and working with and without the variable width of the box (width proportional to the square root of the number of data points):

Different orientation with fixed box size

Different orientation with fixed box size

Box plots, laid out side-by-side, allow a visual comparison between different batches of data in four aspects regarding level, spread, shape and potential outliers. The notches on the sides of box plots permit a more refined comparison by providing a rough measurement of the significance of the differences between medians. They define a confidence interval around the median that has been adjusted to make it appropriate for comparisons of two boxes:

Box Plot with notches

A box plot can hide the details of the actual distribution. Showing the data points on top of the box plot can reveal the underlying structures of the data. In case the data set is big and plotting of many data points doesn’t lead to nice looking results, the “jittering” (adding random noise over the data points) can be used. The example below shows the data points plotted on top of the box plot, with and without jittering:

Box Plot with jittered data points

In many cases, a more powerful representation and interpretation of the data can be achieved by putting multiple visualization elements together. In addition to jittering, a combined visualization of a histogram and a box plot can be used to provide more insight. The example below shows five datasets (taken from the same stats, different graphs) that have completely different distributions but lead to the same box plot visualizations. The combination of box plots and histograms helps reveal the underlying structure of the data sets:

A combination of histograms and box plots with jittered data points.

As usual, LabPlot provides full flexibility when defining the appearance of the box plot in the Properties Explorer. You can set the properties of lines, colors, different symbol styles for different “markers” (outliers, far out values, median and data points), and more:

Anatomy of a Box Plot

The box plot feature has already been in master for quite some time and has reached stability and maturity. We consider it is worth now introducing to you, our users, and inviting you to test it in our nightly builds so you can provide us feedback.

Tuesday, 10 August 2021

There has been a lot of work on printers this week but


GDB MI allows applications to connect to GDB without actually running it from the terminal, this is how frontends talks to GDB. Most of the time this is how users actually use GDB for debugging.

Children and to_string

GDB has two ways for returning pretty printing values, as children or as to_string. children method returns a tuple of two values, the name and the value ie. ('name', value). to_string returns a string or a gdb.Value, you can read up more on that here. some printers return to_string, children or both to give relevant debugging information. For example for a double would return a to_string value and std::vector would return to_string to show how many items are in the vector and children’s value to print the items in the vector.

Printing children and to_string

Currently in GDB/MI, if the pretty-printer has a children method, it ignores the value of the to_string a only shows the children. for example you have the below code

    QStringList alist {"this", "is", "a", "stringlist", "!"};

in gdb cli it would be

    (gdb) print alist 
    $1 = <5 items> = {"this", "is", "a", "stringlist", "!"}

in GDB MI it would be

   -var-create - * "alist"

and the IDE would show something like this. gdb_mi_IDE_variable

this is a current limitation of GDB/MI but the its still usable, however a bug report has been filed. the problem comes when both the to_string and children valuables are needed. The current workaround is to repeat the value in the to_string in the children method. so if you have a QStringRef

    QString string{"this is a string"};
	QStringRef aref(&string, 10 , 6);

    //GDB CLI
    (gdb) print aref 

    $1 = string = {"this is a string", 0x7ffff4fe9b70 "string", 10, 6}

in a IDE it would be


Python 2

All the printers has been ported to python2

New Printers


  • print python string correctly

    GDB cannot show a python string as a string instead it shows it as a char array. the only way to get it to print as a string is to convert it to a char pointer, however this would add the memory address in front of the value.

  • format qtime in python2