October 21, 2019

KDevelop 5.4.3 released

We today provide a stabilization and bugfix release with version 5.4.3. This is a bugfix-only release, which introduces no new features and as such is a safe and recommended update for everyone currently using a previous version of KDevelop 5.4.

You can find the updated Linux AppImage as well as the source code archives on our download page.



  • ProblemNavigationContext: Fix incorrect link target for file:line links with declarations. (commit)
  • ProjectManagerView: Make items with an empty icon have the same indent as items with a valid icon. (commit)
  • Welcome page: fix version of QtQuick.XmlListModel import to match Qt 5.7 ff. (commit)
  • Welcome page: fix version of QtQuick.Layouts import to match Qt 5.7 ff. (commit)
  • [Grepview] Use the correct fallback icon for Collapse All. (commit)
  • FileManagerListJob: use a semaphore for locking. (commit)
  • Fix Infinite Recursion in DUChain. (commit)
  • Cache the defines/includes for gcc-like compilers per language type. (commit)
  • Only write defines file when needed. (commit)
  • Don't set super long name on completely anon structs. (commit)
  • Use type name as fallback ID for anon typedef'ed structs/unions etc. (commit. fixes bug #409041)
  • Fixed crash when filtering class list. (commit. code review D22660. fixes bug #406931)
  • Gcclikecompiler: properly resolve include paths with symbolic links. (commit. fixes bug #405221)


No user-relevant changes.


  • Fix expressions using array constants. (commit. fixes bug #405719)
  • Don't mark class constants as normal members. (commit)
kossebau Mon, 2019/10/21 - 18:31

Hoy me complace anunciar que LaKademy 2019 se celebrará en Salvador-Bahia, con lo que ya será la séptima edición de la gran reunión de simpatizantes de KDE en Latinoamérica y se convierte ya en un evento que deja sus tímidos comienzos para convertirse en una de las citas destacadas del Software Libre.

LaKademy 2019 se celebrará en Salvador-Bahia

Según podemos leer en el boletín de noticias de KDE-Brasil de hace unos años pero que sigue vigente hoy en día:

«LaKademy, abreviación para Akademy de América Latina, es un encuentro de usuarios y colaboradores latinoamericanos de KDE, una de las comunidades de software libre y código abierto, más grandes del mundo. La región es de gran importancia para el proyecto, pues cuenta con una gran comunidad de desarrolladores y usuarios.»

De esta forma me complace compartir con todos vosotros que este año Lakademy se celebrará en Salvador-Bahia del 14 al 17 de noviembre. La sede de este año es Information Technology Superintendence of Federal University of Bahia y se espera aumentar el número de participantes de ediciones anteriores.

LaKademy 2019 se celebrará en Salvador-Bahia

En palabras de Sandro Andrade, miembro de la junta de KDE e.V. y activo miembro de la Comunidad KDE:

«Salvador (la ciudad en la que vivo) es bien conocida por sus hermosas playas, el mayor carnaval del planeta y su cocina única. En noviembre, los asistentes ya pueden echar un vistazo a nuestro cálido verano y esperamos que eso traiga un montón de energía adicional para tener una reunión divertida y productiva.»

En resumen, una gran oportunidad para tener un primer contacto con la Comunidad Latina del Proyecto KDE o para seguir afianzando los lazos que unen a los que ya lo están.

En cuanto tenga más información como el programa de charlas o los eventos sociales os iré informando.

Más información: Sandro Andrade

Qt 3D makes heavy use of threads, as a way to spread work across CPU cores and maximize throughput, but also to minimize the chances of blocking the main thread. Though nice on paper, the last case eventually leads to added complexity. Sometimes, there are just one too many threads.

In the past, we’ve been guilty of trying to do too much within Qt 3D rather than assuming that some things are the developer’s duty. For instance there was a point in time where we’d compare the raw content of textures internally. The reason behind that was to handle cases where users would load the same textures several times rather than sharing one. This led to code that was hard to maintain and easy to break. Ultimately it provided convenience only for what can be seen as a misuse of Qt 3D, which was not the the original intention.

We had similar systems in place for Geometries, Shaders… Part of the reason why we made such choices at the time was that the border between what Qt 3D should or shouldn’t be doing was really blurry. Over time we’ve realized that Qt 3D is lower level than what you’d do with QtQuick. A layer on top of Qt 3D would have instead been the right place to do such things. We’ve solved some of these pain points by starting work on Kuesa which provides assets collections.

In the past couple of Qt releases we’ve been trying to simplify the code where it had become overly complex for debatable convenience. For Qt 5.14 we have decided to rework the threading architecture.

Before we dive into what has changed and what we gain from it, let’s first go over the architecture that was in place until 5.13.

Qt 3D Threading Architecture as of 5.13

The Main Thread

This is the Qt application thread where the Qt 3D Entity/Component scene tree lives.

The Aspect Thread

This is the thread in which Aspects live. Each Aspect is responsible for maintaining an internal backend tree that reflects the frontend tree. A messaging mechanism has been set up in order to maintain frontend and backend trees in sync. Most of these messages contain a property name as a string and a value as a variant.

The ThreadPool


Each frame, based on changes and content of its backend tree, and each aspect will get a chance to schedule work that needs to be performed:

  • The Render aspect will for instance launch jobs that prepare the content for rendering, load buffers, load textures …
  • The Input aspect will look for pending input events and send messages to the frontend tree to notify it about any state change

The RenderThread

Pure Qt 3D Case

This is the thread tasked to submit the rendering commands that have been created previously by the render aspect’s jobs. The idea is that submitting these commands in a dedicated thread allows to unlock the Aspect and Main threads so that we can prepare content for frame n + 1 while rendering frame n.

One thing to be noted however, this thread is only available when using “pure” Qt 3D, in other words when using Qt 3D without QtQuick and Scene3D.

Scene3D Case

When using Scene3D, we instead rely on the SceneGraph Thread (which can potentially be the same as the main thread) to ask for the rendering commands to be submitted.

Since the Scene Graph thread is outside of our control, when it asks for Qt 3D to submit commands it could be that the Render aspect jobs in charge of preparing said commands have yet to be completed. To handle that case, we would return early in the renderer and expect that when we’re called again in the future, jobs would finally have completed.

This means that potentially Qt Quick and Qt 3D would not be rendering at the same refresh rate. This can be seen as good or bad depending on your use case:

If 3D content is just there but not critical, then having Qt 3D not block Qt Quick can be interesting for you. If on the other hand you want Qt Quick and Qt 3D to be synched, this was until recently not possible.


The Simulation Loop


The loop behind Qt 3D that drives aspects, rendering and synchronization:

  1. We wait for the Renderer to be ready for the next frame
  2. Synchronize the aspect’s backend trees by distributing change messages from the frontend tree stored in the ChangeArbiter
  3. Ask each aspect to launch jobs that need to be performed for the current frame
    • One job from the RenderAspect will notify the RenderThread that all RenderCommands have been prepared
  4. We wait for all jobs to be completed
  5. We wait for the next frame
    • Once RenderThread has all that’s required for rendering, it calls proceedToTheNextFrame and does the graphics submission
    • This allows to start the next loop of the simulation loop while we are still rendering.

What has changed in 5.14?

As you can see, aspects are living in their own thread. The main reason for this is to allow Aspect to launch jobs and communicate while the main thread is blocked. This unfortunately forces to use string based messages to synchronize the trees. It also makes synching between threads to handle all cases quite difficult.

What have we done for Qt 5.14? Simply put, we’ve removed the Aspect Thread.


Well, what’s the gain of having it? Even if the Aspect thread can spin freely while the main thread is blocked do we really benefit from this behavior?

From experience, in 90% of cases, we use Qt 3D with Scene3D. Which means that if the main thread were to be locked, Qt Quick wouldn’t sync and Qt 3D wouldn’t render anything.

So arguably, we have a thread that’s making things more complex to handle a case that very few of us might benefit from. This benefit couldn’t offset the difficulties that resulted from it:

  • Slow synching mechanism
  • Very hard to control Qt 3D from the outside
  • Lots of optimizations left on the table because it adds complexity to lots of areas (backend trees, string based messages, blocking threads to sync, hard to know what has changed…)

What do we gain from that?

This now means Aspects and the simulation loop are performed in the main thread.

Gains from that are:

  1. We don’t need to use messages to sync, we can just compare against the frontend nodes directly:
    • This removes lots of allocations, string comparisons
    • QVariant comparison was a huge performance hit because of the way it handles multithreading
    • Technically we could now go as far as not having a copy of the tree in the aspects
    • This should make caching commands a lot easier.
  2. This allows to have a greater control over the simulation loop:
    1. We can now decide whether Qt 3D should be in the driver seat or not
    2. Control can now be manual, done by the user
      • Makes integrating Qt 3D with 3rd party engines a lot easier
      • Scene3D integration uses that approach.
  3. Qt Quick and Qt 3D now run in sync at the same refresh rate
    • The downside is that if Qt 3D content is slow to render, Qt Quick will be impacted.
  4. Should allow us to introduce more sync stages to avoid having to wait more than 1 frames to react to things like inputs, capture request…
  5. Greatly simplifies startup and shutdown sequences.

What’s next?

In a follow up article, we will see how Qt 5.14 was also modified to change the way the scene state get sync’ed between frontend and backend nodes, providing significant performance gains on very dynamic scenes.

The post Qt 3D: One too many threads appeared first on KDAB.

October 20, 2019

At this year’s KDE conference Akademy we discussed how to evolve Kate over the next years. One of the areas we want to improve is better git integration out of the box. Currently, Kate ships the Projects plugin, which automatically detects and loads your file structure from your git repository. If a project is loaded, then the Search & Replace plugin allows to search&replace in all project files. In addition, the Quick Open feature also supports opening files from the currently active project - all explained here.

However, the Projects plugin does not provide any real git integration: You can neither pull nor push, commit, diff, etc. If at all, additional git functionality is available only via external tools like gitk or git-cola (e.g. available in the context menu).

This is something we would like to change by having really nice git integration.

Using Existing Git Clients

Since we don’t have the resources to start a git client from scratch, we had a quick look at existing git clients, preferably written in C++ and Qt5. What we found so far:

GitQlient and QGit

Back in 2007, the Qt-based git client QGit emerged. QGit is still alive and maintained. However, no new major features seem to be added either. QGit is licensed under GPLv2.

Just some weeks ago, two blogs appeared on planet.qt.io about GitQlient, which is a fork of QGit. As discussed in part 1, the idea of GitQlient is to have a nice widget that can be embedded into Qt Creator. This idea is elaborated a bit more in the follow-up part 2. The GitQlient additions are licensed under LGPLv2+, but given it’s based on QGit, the effective license is GPLv2 only for now.

What’s nice about GitQlient is that it is Qt5-based and uses just 74 .cpp/.h files, and has only a total amount of 11393 source lines of code (slocs) including API documentation and empty lines. So it’s not that much code, which is good maintenance-wise. However, both QGit and GitQlient currently are one-man shows, so the developer base is rather small at the moment.

gitahead - Understand your Git History

Another Qt5-based git client that caught our attention is gitahead. gitahead seems to be a full-feature git client with many features. What’s very nice about gitahead is: It’s licensed under MIT license. However, the source code is much larger: ~52000 slocs. In addition, the 3rd party dependencies include e.g. scintilla and many other libs, adding another ~184000 slocs. Compared to QGit/GitQlient this is 20 times more, and many dependencies we certainly would not want in Kate.

Join the Discussion

At this point, nothing is decided yet. As it currently stands, GitQlient looks a bit more promising, since it’s simply much smaller code-wise and therefore likely easier to adapt to Kate. If we decide to give GitQlient a try, I’d like to contact the initial and current QGit authors to try getting it relicensed from GPLv2 only to GPLv2+ or even LGPLv2+.

If you know of any other Qt-based git clients that can nicely be integrated into Qt/Kate, then please join the discussion at the KDE subreddit.

Every once in a while I need to do a fresh installation (usually because of new hardware) and then I encounter this:


This is a long-known bug with countless Reddit/Forum/… posts with often the correct answer how to fix it.

So what I decided to do is to make a package that does that semi-automatically:

1-click install

Basically the problem is: When there’s no “default” set in /usr/share/icons/, Plasma or KWin or whatever doesn’t always pick the selected cursor set (happens only under X11, not Wayland) and this package simply installs a default theme that contains no cursor files and merely inherits Breeze.

Here’s the source code if you want to make sure nothing nefarious is going on.

Me ha costado un poco, pero finalmente he actualizado de nuevo el canal de Ivoox de KDE España para que todos aquellos que utilicen esta plataforma para escuchar los podcast de KDE España puedan estar al día de los mismos.

Actualizado de nuevo el canal de Ivoox de KDE España

Actualizado de nuevo el canal de Ivoox de KDE EspañaCreo que es buena idea recordar cada cierto tiempo que el Grupo de Comunicación de KDE España creó hace un tiempo un canal de podcast en la famosa plataforma Ivoox con la idea de llegar a más gente.

Este canal de Ivoox de KDE España no se actualiza directamente por diversas razones y necesita un poco de cariño para que esté al día. Es por ello que no he podido realizarlo hasta tener un día «más o menos tranquilo» para bajar los vídeo del canal de Youtube y, convertirlos a mp3 con VLC y, a continuación, subirlos a Ivoox.

Aprovecho para agradecer públicamente la labor de Victorhck que actualiza raudo y veloz el canal de KDE España en Archive.org con lo que podemos llegar a más audiencia y, por supuesto, el trabajo de Rubén, José, Adriá, Albert y Aleix, los artífices principales de la creación y posterior mantenimiento del podcast.

Así que desde hoy 19 de octubre tenemos el canal actualizado hasta el próximo podcast y aprovecho esta entrada para poneros el último episodio que realizamos y donde hablamos la relación de KDE y Lliurex con la gente de esta gran distribución educativa:


Al mismo tiempo, me gustaría pediros algunas cosas amigos lectores.

En primer lugar preguntaros si sabéis de otras plataformas donde creéis que deberíamos estar presentes y que nos ayudarais a estarlo.. En segundo lugar pediros vuestra opinión sobre la duración de los podcast (¿son largos?¿son cortos?).

Además, nos encantaría saber sobre qué os gustaría que habláramos en los mismos y os pido ayuda para la mejora de nuestro canal, toda ayuda es poca en cuanto a generación de una portada genérica para los podcast, mejoras tecnológicas, participación en los mismos o difusión en otras redes sociales.

Plasma 5.17 was released this week to glowing reviews! As with most new releases, our loyal users wasted no time in finding all the bugs we missed! So you know what that means, right? We all burned the midnight oil fixing the problems you found, and Plasma 5.17.1 will be released in just a few days with everything we’ve knocked out so far (detailed below) so never fear!

New Features

Bugfixes & Performance Improvements

User Interface Improvements

How You Can Help

Check out https://community.kde.org/Get_Involved and find out ways to 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!

Finally, consider making a tax-deductible donation to the KDE e.V. foundation.

October 19, 2019

I’ve been working on Calamares, the Universal Linux Installer, for a little over two years – following up in the role Teo started. It’s used by Neon (for the dev version, not the user version) and Manjaro and lots of other Linux distributions. I’ve typically called it an installer for boutique distro’s, as opposed to the Big Five.

Well, Debian 11 has plans. And lubuntu uses it as well (and has for over six months).

Those seem pretty big.

This does not change the way Calamares is developed (much), really. The same principles apply as with each recent release.

  • PRs are welcome. Really! Especially if you have something specific to implement, or specialised knowledge. I’ll quibble about code formatting and style and possibly encourage you to do things in a more general fashion, but most PRs are good.
  • Well-written feature requests get attention (drop in on IRC to talk about them).
  • Regressions get fixed now (if I understand your bug report).

I consider Calamares development to be collaborative, and I’m mostly here to deliver the things that distro’s downstream need (since my “own” distro would be FreeBSD, and that’s a long-long-term project with Calamares).

It is time for another installment of Godot (previous entries: introduction, 2D). This time, I have dived into the world of 3D. The goal is to recreate parts of an old time favorite: Kosmonaut. Something I remember playing a lot on my dad’s 286 with amazing EGA graphics.

The state of the game when writing can be seen in the short screen capture below. This is more of a tech demo status than a full game at the moment, but I hope you will still find it interesting. You can also get the complete source code.

The project is split into two major parts: the Player and the World. Each of these contain scripts that I will refer to below. But first I want to talk about how to create 3D scenes.

Of course every scene can be created manually from individual elements. However, in 2D games it is common to use tiles to create large worlds from common elements. Godot’s analog in the 3D world is the GridMap.

A grid map is more or less a 3D tile map. Inside each tile (or cell, or whatever you call them in 3D) you can place an item. The way you create these items in Godot is to place each 3D element in a scene and then convert it to a mesh library. Then you can draw your 3D scene much like you can draw a 2D scene from tiles.

Once we have a world with a track (the grid map), we add a player to the scene (the yellow blob in the image above – I need to learn Blender to create a proper ship). The player scene contains the ship – and the camera. This means that the camera follows the player automatically – very convenient.

The player script is responsible for this ship’s movements based on user input. Inputs can either be pressed for a long time, used for sideways movement, or just tapped (i.e. the release is ignored), used for jumping. Each of the inputs are mapped to a keyboard key (or other input device) in the Project Settings dialog, under the Input Map tab. This feels a bit awkward to me and makes me lose the feeling of flow – but I don’t know how to do it better.

Getting gravity, jumping and bouncing to work was fun. It reminded me of coding games on my Atari ST. The character controller code is really basic, but can become super complex if one does not think through the order of the things you do. I ended up exporting some tunables so that they can be adjusted in the editor, just to figure out how high to jump and how fast to run the ship.

Figuring out crashes was easier than expected. Through the KinematicCollision objects retrieved using get_slide_collision, the normal of the surface collided with can be retrieved. From there on, it is easy to determine if the ship is sliding along a wall, or just hit it head on. The latter is deadly and the crash signal is emitted.

The crash signal leads to the world script. Here we handle the second death scenario – falling. This is a handled by the world, rather than the player, as the world knows what the lowest possible y value is.

The world also refers to two invisible scene elements used to mark the starting position ($StartPosition) and goal position ($GoalPosition). The first is used when resetting the player, while the latter is used to determine when the goal has been reached (duh).

When starting a run – or restarting for the millionth time, and when completing a track, a short sequence is shown. These sequences are realized using a CanvasLayer, Sprites and an AnimationPlayer. The canvas layer allows us to add 2D contents on top of (and behind) a 3D (or 2D) scene. Each such layer is broken into a scene of its own that encapsulates one sequence. Each scene have a small script interface with a play function and a finished signal.

When showing a sequence from the main world script, the script is started and then the calling function yields until the finished signal is emitted, as exemplified here. Very convenient!

One more word about the sequences: the animation player is a really convenient way to control all properties of a scene using key frames. It can even be used to call functions. I really like this.

On a side note, I found my first Godot docs bug when writing this post. The pull request is right here ;-)

Cada vez hablo menos de distribuciones. La culpa la tiene KDE Neon, que ha conquistado mi corazón kdeero y colonizado los discos duros de mis ordenadores. No obstante, no hay que olvidar que KDE Neon se basa en Kubuntu, y que su desarrollo es fundamental para que el proyecto de KDE siga avanzando. Es por tanto motivo de alegría que haya sido lanzado Kubuntu 19.10, que lleva por nombre código «Eoan Ermine” (nótese la repetición de la letra habitual).

Lanzado Kubuntu 19.10 «Eoan Ermine”

El equipo de desarrolladores de Kubuntu ha trabajado duro estos últimos meses para ofrecernos una nueva versión de su distribución, la 19.10 que tendrá un periodo de soporte de 9 meses, es decir, hasta julio de 2020.

Se trata de la típica versión entre lanzamiento principales, los cuales se realizan en el mes de abril y que nos ofrece una gran revisión de la primera versión del año.

Algunas de las principales características técnicas de Kubuntu 19.10 son las siguientes:

  • Kernel Linux 5.3
  • Qt 5.12.4
  • KDE Frameworks 5.62.0
  • Plasma 5.16.5
  • KDE Aplicaciones 19.04.3.
  • Firefox 69
  • LibreOffice 6.3

Además, muchas aplicaciones KDE vienen instaladas por defecto como latte-dock, Elisa 0.4.2, Kdenlive, Yakuake, Krita, Kdevelop y Ktorrent.

Lanzado Kubuntu 19.10 "Eoan Ermine”

Otras novedades destacadas de Kubuntu 19.10 son las siguientes:

  • Posibilidad de iniciar una sesión en Wayland si se instala el paquete plasma-workspace-wayland, pero no está oficialmente soportado.
  • Incluidos por defecto los drivers de las tarjetas gráficas NVidia cuando se selecciona Software de terceros en las opciones de instalación.
  • Se ha suprimido el soporte a KDE 4 ya que se ha quedado obsoleto.
  • Soporte inicial para ZFS

En resumen, una distribución con solera e historia que se convierte en una alternativa para los usuarios de KDE que prefieren no tener lo último de la Comunidad KDE pero si de otras aplicaciones que no pertenecen a ese ecosistema.

Más información: Kubuntu

October 18, 2019

The Kubuntu community is delighted and proud to ship Kubuntu 19.10. As a community of passionate contributors we need systems and services that enable us to work together, and host our development tools.

Our sponsors page provides details and links to the organisations that have supported us through our development process.

Bytemark is a UK based hosting provider that generously provide racked and hosted bare metal hardware upon which our build chain KCI ( Kubuntu Continuous Integration ) operates.

Kubuntu Continuous Integration Server, provided and sponsored by Bytemark

Bytemark the UK's

Linode, our US based hosting provider that generously provide scalable hosting upon which our build chain KCI operates.

Build and Packaging Servers provided and sponsored by Linode


Big Blue Button provide an online virtual classroom primarily targeted for online learning environments, but has proved itself a valuable tool for remote collaborative working, and community events.

Video conference and training suite, as used by Kubuntu Podcast, provided by Big Blue Button


We are deeply grateful for the support these organisations provide, and we welcome others to come join our community and pitch in.

Akademy 2019 was hosted in University of Milano-Bicocca, Milan from 7th to 13th September. It was great to meet all the fellow KDE contributors again 🙂

Akademy gives a chance to bring together artists, designers, developers, translators, users, writers and other contributors to meet in person and discuss about achievements of the past year and plan out the goals for the next year.

DSC02500.JPGGroup Photo

First two days contributors presented talks on their respective projects. You can go through the talks as now the videos for the same are available.
All talks were so great and full of knowledge, but out of all there were few topics that fascinated me, and I would like to share those topics with you.

Last year in Akademy, KDE Goals were announced, which were:

  1. Usability and Productivity for Basic Software.
  2. Privacy Software.
  3. Streamlined Onboarding of New Contributors.

So in this Interactive Session, Lydia discussed with the goal keepers how far they have reached and how was their experience while working on these goals, and then finally this year’s Goals were announced,

  • Wayland
  • Consistency
  • All about the apps

This year unfortunately I didn’t give any talk but instead tried my hands in volunteering. I volunteered to be a Session-Chair, basically my job was to introduce speaker and manage talk room. It was such a learning and amazing experience to be a volunteer.

DSC02441.JPGHaving a word with the Keynote speaker Leonardo Favario.
{Photo credit Paul Brown}

Rest of the week was BoFs (Bird of Feather), Workshops, Meetings, Daytrip and Training.

There were many BoF sessions scheduled for a week and I attended the following sessions:


We discussed on some marketing strategies, and did some brainstorming on few topics. Learnt how far we have reached on spreading KDE to new users and determined few tasks we would work on for this year.

OpenQA :

I work and contribute in OpenQA Project, in this session Harald Sitter and Jonathan Riddle gave a brief introduction on OpenQA and then we discussed the workflow for writing new tests cases, and I personally got a chance to learn alot of new things from Jonathan Riddle.

KDE India :

We discussed on next KDE Conference India, listed few places were we can host the conference, and I am happy to announce that conf.kde.in is coming back in 2020 🙂 It will be held in Maharaja Agrasen Institute of Technology from 17th to 19th January. If you love open source and wish to learn more about our community come join us in this conference 🙂

Privacy :

In Privacy BoF we discussed on various aspects, determined goals for this year, talked a bit on funds for next sprint and did brainstorming on few topics.

KDE Students Program :

Here we discussed about the students program, took feedback on what we need to improve, what should be the work pattern for this year and our main focus was on Season of KDE Program, It is an upcoming project so we were discussing on its timeline and structure which soon you will come to know 🙂


It is a tradition of Akademy that Wednesday afternoon we all attendees go out and explore a particular area. This time the trip went to the North to Varenna near Lake Como, Ahhh! it was indeed the most magnificent place, a day where I enjoyed the nature’s beauty accompanied with my incredible friends.

Enjoying Daytrip


Communication Training:

KDE e.V. had organized Communication Training session for community members, and I am so glad I could attend this training. Our trainer Tilman Krakau gave some basic but very essential lessons on communication, how to coordinate with your team-workers and always try to understand the receivers’ point of perception.


Akademy was really productive, it was great socializing and meeting old friends and making new ones. Learnt alot of new stuffs and it was an amazing experience. I am really thankful to the KDE e.V. for sponsoring my trip.

And to those who aren’t part of KDE yet and wish to be, I have something interesting to share with you, Season of KDE is coming soon. It is a great way to join our community, learn new things and get comfortable with coding, and there is one thing I would like to tell about this program, it is just not for students it is open for everyone 🙂

See you all next Akademy, till then Happy Coding! 🙂



We are happy to announce the release of Qt Creator 4.11 Beta!

Thanks to the awesome KDE community, we are happy to present the Plasma Mobile project’s third weekly update.

Shell User Interface

David Edmundson backported some Qt Wayland patches that improve the overall stability of the shell.

Marco Martin added further refinements to the shell.


Jonah Brüchert replaced the custom contacts search field by the recently added Kirigami search field in Kaidan. The search is accessible by using the search action or by pressing Ctrl+F as usual. Robert Maerkisch improved the performance of the search by using a proxy model instead of hiding contacts from QML. Apart from that the contacts are now sorted chronologically and secondarily also alphabetically thanks to Linus Jahn.

New Kaidan contacts view


Kirigami apps no longer show an empty context drawer in certain circumstances (Nicolas Fella).

Marco Martin fixed the Kirigami drawer handles on Plasma Mobile.


Thomas Fischer has started work on a mobile-friendly BibTeX client.


Nicolas Fella made sure that an appropriate message is shown when no contacts could be found.

Settings Application

The code for the settings applications received a small cleanup. Names of various settings entries have been adjusted to be more concise: they now show “Foo” instead of “Configure Foo” in the top bar.


When creating or editing an entry, saving is now the most prominent action.


Angelfish, the browser, has seen some refactoring by Jonah Brüchert which avoids loading all kinds of dialogs (authentication, webrtc permissions etc) at startup and loads them when needed. This should result in reduced startup times.

Input of urls in its settings is now converted into proper urls, to make sure for example the homepage can actually be loaded even though the user did not enter https://kde.org but just kde.org.

Maui Project

The file browser component has gained improvements for focus chaining, keyboard navigation and new keyboard shortcuts. The places list can now browse all available tags. Files now keep their associated tags even when renamed or moved. Furthermore it now supports copy/pasting files into/out of the app.

The file previewer now uses Okular to preview any document supported by Okular.

The browser view has an improved Miller Column view and its model features improved performance by only adding or removing the necessary paths.

The MauiKit framework and some Maui apps can now be built for Android using CMake in addition to qmake. This allows building Index and vvave using the KDE Binary Factory and making them available in the KDE F-Droid repository (Nicolas Fella). This allows you to test some of the Plasma Mobile apps even without a Plasma Mobile device. MauiKit gained initial support for handling system accounts in a more integrated way by using libaccounts on Linux.

MauiKit parts now have been separated into components to allow having lighter builds when using static linking. Those components are: Editor, Filemanager, Tagging, Syncing, Accounts, Terminal and Store.

When using qmake, MauiKit now automatically fetches all the needed extra binaries, library sources, and assets needed to compile when statically linking.

vvave’s codebase has received some cleanups and improvements.

Want to be part of it?

Next time your name could be here! To find out the right task for you, from promotion to core system development, check out Find your way in Plasma Mobile. We are also always happy to welcome new contributors on our public channels. See you there!

October 17, 2019

Kubuntu 19 .10 has been released, featuring the beautiful KDE Plasma 5.16 desktop.

Codenamed “Eoan Ermine”, Kubuntu 19.10 integrates the latest and greatest open source technologies into a high-quality, easy-to-use Linux distribution.

The team has been hard at work through this cycle, introducing new features and fixing bugs.

Under the hood, there have been updates to many core packages, including a new 5.3-based kernel, Qt 5.12.4, KDE Frameworks 5.62.0, Plasma 5.16.5 and KDE Applications 19.04.3. Firefox 69 is the default browser and LibreOffice 6.3 is provided by default in the full installation, along with updates and bugfixes to latte-dock, Elisa 0.4.2, Kdenlive, Yakuake, Krita, Kdevelop and Ktorrent.

Getting Kubuntu 19.10

Upgrading from 19.04
Detailed upgrade instructions can be found here: Kubuntu 19.04 to 19.10 Upgrade

Download a Disk Image
Download a Bootable image. Direct downloads, torrents, and zysnc are available as options.

For more about the changes in the Ubuntu base, see the Ubuntu Release Notes

Since Plasma 5.17 has been released too late in our release cycle to make it into 19.10 as default, users can install these via our backports PPA.

A Plasma Wayland session can be added by installing the package plasma-workspace-wayland, but is not officially supported. This will add a Plasma (wayland) session option at the login screen. Users needing a stable desktop experience should select the normal ‘Plasma’ (without Wayland) option at login.

NVIDIA drivers are now included with the ISO, which allows the installer to select and install these when the 3rd party and restricted drivers and codecs option is chosen, even if you are installing offline.

ZFS on root installer support landed too late in the Eoan cycle to implement and test for the Ubiquity KDE front end. This option is therefore targeted for the 20.04 LTS release.

See our Release Notes for more information: https://wiki.ubuntu.com/EoanErmine/ReleaseNotes/Kubuntu

At least twice I have been to India. Atil Chitnis closed FOSS.IN in 2008, and I wrote about that only briefly, and in 2011 there was conf.kde.in in Bangalore which I wrote about some more.

During one of those conferences I fell asleep on the ground in the hall at the KDE booth.

But there’s a new conf.kde.in happening at the beginning of 2020. You can read more on the dot. Based in Delhi this time, the conference remains true to its roots:

conf.kde.in is a platform for Qt/KDE contributors, developers and enthusiasts to come together, share their knowledge, contribute, learn and play.

Kai-Uwe has made a badge that, frankly, rivals my own kolourpaint prowess:

I'm going to conf.kde.in

Now, I’m not going yet. Like everyone else, I go through the call-for-papers process (which means thinking up things to talk about!). You can find the link on the site, along with other information (you’ll need a KDE identity account).

During one of those conferences there were monkeys.

For me personally, it’s weird and inspiring seeing conf.kde.in return. I remember the excitement of an own conference in India, of first shirt designs, of The KDE Handbook which Pradeepto put together with the enthusiasts of the time (I still have my copy). The amazing “we’ll make it work” attitude to conference organization which seems to be a hallmark of KDE events to this day.

If you watched the Akademy BoF summary videos this summer, you saw the results of the KDE India BoF, which included planning – starting the planning – of this event. And now it’s here.

So watch the site, write a proposal, and be there!

Announcing a small update for the goal: KDE is All About the Apps. kde.org/applications is now listing the stores where the application is available. For the moment, it’s only listing Linux and the Windows Store, but support for F-Droid and the Play Store is planned. Stay tuned!

Store listing

Announcing LaKademy 2019

Hi there,

The seventh edition of the KDE Latin-American Summit (LaKademy 2019) is ready to go! It will take place at Salvador-Bahia, northeastern Brazil, from 14th to 17th November. 24 participants, hopefully accompanied by some local guests, will meet at Information Technology Superintendence of Federal University of Bahia for four days of hacking sessions, promo meetings, and all sort of KDE-related things.

Salvador (the city I live in) is well known for its beatiful beaches, the biggest carnival in the planet, and its unique cuisine. In November, attendees can already have a glimpse on our warm summer and hopefully that will bring a bunch of additional energy for having a fun and productive meeting.

Announcing LaKademy 2019Salvador - Bahia - Brazil

Stay tuned for the upcoming news of our achievements at LaKademy 2019. Many thanks to Angela Cunha for coming up with such a nice LaKademy 2019 logo and to the KDE e.V. for supporting the meeting.

See you!

Join us for conf.kde.in from the 17th to 19th of January 2020 in Delhi, India.

conf.kde.in 2020 will focus on promoting Free and Open Source software, including (but not limited to) Qt and KDE products.

The Venue

conf.kde.in 2020 will be held in Maharaja Agrasen Institute of Technology, located in Rohini, Delhi, India. MAIT was established by the Maharaja Agrasen Technical Education Society and promoted by well-known industrialists, businessmen, professionals and philanthropists. The aim of MAIT is to promote quality education in the field of Technology.

MAIT endeavors to provide industry-relevant education and training through its well-crafted and practical training programs for the students in different semesters of their courses. The campus is composed of 10 blocks with a learning resource center. MAIT has been ranked as the 10th best private engineering institute in India by the Dataquest T-School Survey. MAIT always supports Free and Open Source communities and tech-related activities.

About conf.kde.in

conf.kde.in started in 2011 at RVCE in Bangalore as a 5-day event with 300 participants. This kicked off a series of KDE events in India. We held a KDE Meetup in 2013, and another conf.kde.in 2014 at DA-IICT. In 2015, the third conf.kde.in was held at Amrita University in Kerala, and in 2016 at LNMIIT Jaipur. The Jaipur conference attracted members of the KDE Community from all over the world. Attendees from different backgrounds came to meet each other, give talks, and share in the spirit of KDE. The 2017 conference was held in IIT Guwahati, Assam and sought to cater to new members of KDE, as well as to seasoned developers.

KDE Meetup 2014

All of these events have been successful in attracting a lot of Indian students to mentoring programs such as Google Summer of Code (GSoC), Season of KDE, and Google Code-In.

conf.kde.in 2020 will generate even more interest and participation by creating a fertile environment for people to get started with KDE, Qt and FOSS through numerous talks, hands-on sessions and demonstrations.

Call For Papers

Join us! Submit a paper, explain the content for a 30-minute presentation or a workshop on any aspect of KDE, Qt or any other FOSS topic you want to cover, and become a conf.kde.in Speaker.

Remember to include all pertinent information about your background, other talks you've given, and anything else that gives a sense of what attendees can expect from your presentation.

See you in 2020 in India!

October 15, 2019

KDE neon 5.17 is out. You can upgrade your existing KDE neon User Edition install or install fresh from an ISO image or run the Docker image. Featuring Plasma 5.17 it is packed full of new features according to OMG Ubuntu.

K', Hot off the presses, here's some New Stuff for you, with the Quickness! ...terribly sorry about that, i shall endeavour to do better. Let's try that again.

As of KDE Frameworks 5.63, released on 2019/10/12, we officially introduce the fruits of my labour over the last few months, the shiny, new Qt Quick components, which were created to bring the Qt Quick submodule of KNewStuff up to par with the old QWidget based UX. Not only that, they also bring with them some shiny, new abilities in KNewStuff, which previously did not have any concept of comments outside of the very basic information of how many a content item had (which, incidentally, was also incorrect, and had been since, well... since that code was written about a decade ago - guess nobody noticed, because the information is a bit useless on its own).

Before running off and explaining what's what, have a video of my presentation from Akademy 2019, where i gave an overview of the new components and functionality:

Now, before you hop over to the API documentation and start digging in to work out how to actually use all this hot new stuff really quickly (sorry), here's a really quick visual rundown of some of the shiny stuff:

You know this. It's the KNS::Button button, but now more Quick [API]. Don't use this unless you're doing some porting, keep going...

The dialog we all know and love, but with a twisty twist and shiny new tile types [API] Don't use this either (with a similar caveat), use the next thing instead!

The new Page. The new intended central access. Shown here in the similarly new test tool. [API]

The entry details dialog, except as a Kirigami Page [API]

A lot of entries have multiple options for stuff to get - the DownloadItems Sheet shows those. [API]

You want comments? We got comments! All automatic, except if you feel like doing something much deeper. Have a model. [API]

Authors are important. So we should trust what they tell us they're called, and what they look like, right? Anyway, a super easy data provider Component for Author information. [API]

When you have a UI-less library that needs to get some feedback from the user, what do you do? Well, KNewStuff uses a QuestionAsker system. [API]

If you (like Peruse) was already using the old Qt Quick components List and Item, they still work just fine. In fact, finer than they did before by a fair chunk. Do consider using the Page, though. [API]

i hope you have enjoyed your screenshots and videos ;) Now go forth and implement getting that hot new stuff in your Qt Quick applications!

Also don't hesitate to mention, when you discover it, the various holes in the documentation that undoubtedly are there, so that we might get those fixed. Even better yet, we are very happy to take patches over on Phabricator, both code and documentation ones. One thing that i know is missing is a porting guide, to help people transition from the old QWidgets based stuff to the Qt Quick components for people who have got applications they're looking to port or are already porting.

The word of the day is: Shiny. Because shiny things are neat ;)

KDE launches the new version of its acclaimed desktop environment, Plasma 5.17.

Plasma 5.17 is the version where the desktop anticipates your needs. Among many new features and improvements, your desktop now starts up faster; Night Color, the color-grading system that relaxes your eyes when the sun sets, has landed for X11; your Plasma desktop recognizes when you are giving a presentation, and stops messages popping up in the middle of your slideshows; and, if you are using Wayland, Plasma now comes with fractional scaling, which means that you can adjust the size of all your desktop elements, windows, fonts and panels perfectly to your HiDPI monitor.

The best part? The hundreds of improvements that have made their way into Plasma 5.17 do not tax your hardware! Plasma 5.17 is as lightweight and thrifty with resources as ever.

Check out the official release announcement for more features, improvements and goodies, or browse the full Plasma 5.17 changelog to read about every single change. You can also experience Plasma 5.17 for yourself and install one of the many distributions that offer Plasma.

Guillermo Amaral

The Plasma 5.17 series is dedicated to our friend Guillermo Amaral. Guillermo was an enthusiastic KDE developer who rightly self-described as 'an incredibly handsome multidisciplinary self-taught engineer'. He brought cheer to family, friends and colleagues. He lost his battle with cancer last summer, but will be remembered as a friend to all he met.

October 14, 2019

As mentioned, I’ve started using Godot to create some games with my kids. We decided to start with something simple, so we created Super Memory. I’m still waiting for a graphics delivery, so right now the you play with “dad’s placeholder cards”. They aren’t pretty – but they get the job done.

I had three major goals when creating this game:

  1. Teaching the kids basic programming logic – how to think like a machine.
  2. Teaching myself a bit about Godot.
  3. Creating a game that I can push all the way to Google Play.

The first two items are done – for the third I’m still waiting for the graphics delivery. Kids are such lazy team members ;-)

When it comes to the game logic, I decided to push it all into the entry point of the game: the table scene. The main parts are in the init_game function and the _on_card_flipped function. I would consider the rest of the code support functions, or GUI driving functions.

This brings me to the GUI parts. I’m still not convinced that I understand how to properly layout stuff using Godot, but at least it looks ok now – at the cost of some fixed element sizes and such. I need to spend some more time to really understand how the anchoring and stretching really works. I guess I have a hard time wrapping my head around it as the approach is different from what I’m used to from Qt.

Looking at the rest of the code, I’ve tried to make all the other scenes (in Godot, everything is a scene) like independent elements. For instance, the card scene has a face, and an is_flipped state. It can also signal when it is being flipped and clicked. Notice that the click results in a signal that goes to the table scene, which decides if the card needs to be flipped or not.

The same goes for the GUI parts. They simple signal what was clicked and the table scene reacts. There are some variables too, e.g. the number of pairs setting in the main menu, and the points in the views where that is visible.

All in all, the code is quite messy. I’m getting used to GDScript, so parts of the code has static typing information, while others don’t. Also, naming and underscore prefixing is a bit random. I’m also a bit unsure about the onready var pattern to hold references to various scene elements vs hard coding the reference. And one more thing – some parts are in Swedish before it all shifted to English.

At the moment, I have built installers for all desktop platforms and tried them. I’ve also setup an Android toolchain and pushed development builds to a couple of phones. This also works beautifully. Next step is to get the graphics delivery and push something to Google Play. I will keep you posted.

We now have the Akademy 2019 videos ready for you to enjoy, see the previous summary of talks on the dot for some inspiration on what to watch. The talk schedule has the full list

We had keynotes on Developers Italia and the New Guidelines: Let the Open Source Revolution Start! by Leonardo Favario and Towards Qt 6 by Lars Knoll

We also got updates on KDE Community's goals

Another thing to check out are the previously announced BoF wrapups letting you know what went on during the week following the talks


Here are some talks recommended by attendees:

What we do in the Promos
Piyush: i attended Paul's talk. It was really nice to have an insight on promo's day to day tasks and challenges!

Strengthen Code Review Culture: rm -rf ‘Toxic Behaviors’
Philip: I liked the code review one
Valorie: and I agree, Aniketh's Code Review talk was excellent

Software Distribution: lightning talks & discussion
Jon: Software Distribution talk! (although I prefer my original name for it of Getting KDE Software to Users)

Taking KDE to the skies: Making the drone ground control Kirogi
Ivana: I nominate Eike's talk about Kirogi. It was such a cool talk that told the story of developing an app in a way that even non-devs could understand, and I think it really showcased how KDE is still going strong and taking the lead in the innovation game
Hannah: The talk was horrible.... It made me want to buy a drone

Mycroft on Plasma Automobile Demo
Bhushan: Automative demo one

About Akademy

Akademy 2019, Milan

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.

Dot Categories:

Could you tell us something about yourself?

My name is Fabian Mosakowski and I’m an aspiring illustrator living in France. I’m currently working on my portfolio creating an illustrated fantasy tale called “If Only Blood Was Red”. It deals with what’s left of humans thriving to survive in a land that doesn’t welcome them.

Do you paint professionally, as a hobby artist, or both?

Currently as a hobby artist. I made a few comissions for close relatives but I’d like to make it professional once my portfolio will be done.

What genre(s) do you work in?

Mainly fantasy as it’s the narrative thread of my project but I also mix it with dark art, another genre I really enjoy, to fit the story atmosphere. I also occasionnally work in vectorial or comic book style for lighter projects.

Whose work inspires you most — who are your role models as an artist?

I try to learn everyday from various artists, beginners and professionals, traditional and digital. They always have something to teach me whether it’s a composition, a texture, a story they wish to share or even a color palette. But if I had to choose one, I would go for Magali Villeneuve, a well-known fantasy illustrator. The detail of her work and her path as a self-taught artist both have my admiration.

How and when did you get to try digital painting for the first time?

The first time I painted on screen was in September 2017 when I entered a video game school as a Game Art student. We were being taught the basics of a digital painting software interface from the first days of class.

What makes you choose digital over traditional painting?

I think digital medium offers me the opportunity to be more organized and cautious when drawing. I tend to get very messy and insecure on paper whereas on screen, you can rely on guardrails such as layers and CTRL+Z 😉

How did you find out about Krita?

During my years as a Game Art student. Krita was the software teachers made us work with. Although I couldn’t continue my formation, I didn’t give up on Krita and still learn to discover its capabilities.

What was your first impression?

At first sight, I was really confused about how to use the interface as I never painted digitally before. But still I found it more intuitive than other licences because tools were specific to drawing. Krita is very user-friendly and I managed to get used to it (and the graphic tablet) within only a week.

What do you love about Krita?

I especially enjoy the fact that Krita never imposed me technical constraints. Whether it’s a texture, a pattern or a special effect, there is always the perfect brush or technique to achieve it. Once you managed to isolate every tool, it becomes much more intuitive to modify brushes, mix them and add filters.

What do you think needs improvement in Krita? Is there anything that really annoys you?

I don’t have much to complain about except for the Mirror tool which sometimes has difficulty tracking the stylus path.

What sets Krita apart from the other tools that you use?

To be honest, except Inkscape for the vectorial drawing, I never used any other digital painting software than Krita. I started with it and I intend to keep working on it. Krita is also an accessible tool in times when you cannot afford proprietary digital painting software. Art can be a really tough sector to penetrate so FLOSS allow you to first gain experience and then contribute.

If you had to pick one favourite of all your work done in Krita so far, what would it be, and why?

It would be “Madame de Visembaut, Dead-Blood Duchess”. I really enjoyed working on atmospherical lights and clothes patterns like the victorian lace dress. This character needed a really specific setting, reflecting her leader status, her occult abilities and the faction state of mind.

What techniques and brushes did you use in it?

I mainly use two brushes in every painting: Airbrush_Soft to do colour planes and Blender_Basic to blend them.

The textures and special effects require more specific brushes such as Speedpaint Light Sparks for the candlelights and Blender_Rake to create the wooden texture of the staircase.

For the lighting, I also used the Soft Light SVG blending mode which is really useful to make the setting take on the light source colour.

Where can people see more of your work?

I’d to be glad to introduce them to my project storyline here: http://www.fabianmosakowski.com/if-only-blood-was-red/
From there, they can access my gallery portfolio 🙂

Anything else you’d like to share?

I also have accounts on Twitter and ArtStation and I’d love to meet other artists (illustrators, writers, musicians…) and discover their work 😉

October 13, 2019

In the last few years I have come across the CLA topic several times. It is and will be a popular topic in automotive the coming years, like in any industry that moves from being an Open Source Producer towards becoming an Open Source Contributor.

In my experience, many organizations take the CLA as a given by looking at the google, microsoft or intels of the world and replicate their model. But more and more organizations are learning about alternatives, even if they do not adopt them.

What I find interesting about discussing the alternatives is that it brings to the discussion the contributor perspective and not just the company one. This enrichs the debate and, in some cases, leads to a more balanced framework between any organization behind a project and the contriibutor base, which benefits both.

Throughout these years I have read a lot about it but I have never written anything. It is one of those topics I do not feel comfortable enough to write about in public probably because I know lots of people more qualified than I am to do so. What I can do is to provide some articles and links that I like or that have been recommended to me in the past.


  • Why you probably shouldn’t add a CLA to your open source project“, written by Ben Alter back in 2018 is a must read. Ben is a United States-based lawyer who works for GitHub as their “evangelist” to government agencies.
    • CLAs are Not a Sham” by Kyle E. Mitchell, a lawyer, is a respond to the previous article.
  • “The trouble with Harmony: Part 1 and Part 2″ by Richard Fontana 2011, a Red Hat lawyer. He came back to the topic this year (2019) in his article “Why CLAs aren’t good for open source” summarising Red Hat’s position.
  • Why Your Project Doesn’t Need a Contributor Licensing Agreement” by by Bradley M. Kuhnon June 9, 2014. Bradley is a well known member of the Software Freedom Conservancy.
  • Contributor Agreements Considered Harmful” by Eric S. Raymond on July 8, 2019, represents a clear view from the individual contributors perspective on the CLA topic.
  • Community contributions and copyright assignment” By Jonathan Corbet, October 28, 2009. This article analyses from the contributor’s perspective the Canonical Ltd CLA which started a heated debate back then, leading to the Harmony project creation first and the initiative by the Mark Shuttleworth Foundation later on, two of the main attempts to standardise CLAs up to date.
  • Some thoughts on Copyright Assignment” by Michael Meeks, 2011, is still one of the most relevant articles on the topic, covering not just the theory but also putting examples of how harmful unbalanced relations with an entity that controls an Open Source project might be for contributors. Specially relevant has been over time the Recommendations section of this article.


It is impossible nowadays to talk about CLAs without talking about DCO (Developer Certificate of Origin). Here are some articles that I find interesting:

  1. Ben’s Cotton article “CLA vs DCO What’s the difference“, from 2018 is a good article to read because it does not favour one over the other one.
  2. I like the article “CLAs and using DCO clearly” from Hen written back in 2018 because it summarises well the costs associated to CLAs and how they (do not apply) apply to the DCO.
  3. It is worth reading the summary of James talk at Linux Foundation Collaboration Summit 2014, “The most powerful contributor agreement” done by Jonathan Corbet.
  4. Julien Ponge wrote “Developer Certificate of Origin versus Contributor License Agreements” back in 2016.

For companies that “do not buy into the anti-CLA” case, R. Fontana propose another two options:

  1. Eclipse Contributor Agreement
  2. The Software Freedom Conservancy’s Selenium CLA, which are not proper CLAs but DCOs in his view.


It is always interesting to learn about the Fiduciary License Agreement FLA, developed by the FSFE:

  1. Fiduciary Programme
  2. FLA FAQ
  3. FLA-2.0 announcement.

Inbound = outbound

A serious conversation about CLA requires to understand the concept of inbound=outbound:

GitHub explains inbound=outbound as:

  • outbound licensing”, refers to granting a licence to another party to use, copy, distribute…. (depending on the license) your intellectual property.
  • inbound licensing” means obtaining a licence from another party, to use, copy, distribute…. (depending on the license) its IP for your own consumption (distribution, etc. again depending on the license).

GitHub explains inbound=outbound as:

Whenever you make a contribution to a repository containing notice of a license, you license your contribution under the same terms, and you agree that you have the right to license your contribution under those terms.[…]

In the CLA discussion context, the general idea behind inbound=outbound is that the project should make evident to every contributor the contribution conditions, including those related with licenses rights and restriction. The contributor will then contributes her code with the same license, giving little room for later claims, either by the project, the contributor or third parties, based on those conditions being unclear or not easily reachable.

The project license and its description should be prominent and located at least where it is common practice in Open Source to find them. The same applies to all the assumptions and conditions affecting the contributors and the project in this area.

Common practice, many will claim, but sadly some projects are better than others on this.

Who is doing what?

In CLA discussions, it helps to know what others are doing. Here you have some links I have collected over the years and I still find relevant. I have to recognise that in a couple of cases cases I do not remember exactly why they called my attention at the time.

Company driven projects:

Consortium driven projects:

Community driven projects

Organizations with different agreements for individuals and entities:

Organizations with CLA:

Additional links

And finally, I have several links that I think are worth reading for different reasons:

  1. Project Harmony is worth investigating as an interesting attempt to standardize CLAs:

2. GitHub uses an Individual and an entity CLA. It is interesting their CLA-assistant.

3. James Bottomley’s ideas about the Corporate Contribution Pledge published back in 2016 as complement to the DCO are worth reading.

Additional suggestions from readers

I hope my effort triggers the contributor in you so you provide additional links or challenge the ones above. I will substitute this text for those links you provide, obviously giving you credit by default. It would be a great way to help others in the future. Thank you very much in advance.

KBibTeX is a bibliography editor (BibTeX and somewhat BibLaTex) used in conjunction with LaTeX and friends. Based on this code base, a SailfishOS client called ‘BibSearch’ exists which allows to search for bibliographic data in various online sources (IEEE Xplore, Google Scholar, ACM Digital Library, …). BibSearch&aposs code makes use of KBibTeX&aposs C++ code, has its user interface implemented in SailfishOS&aposs Silica QML, and provides just two C++ files on its own to glue together everything.

It has long been my goal to provide a QML or Kirigami-based client of KBibTeX of similar functionality, either to be used as Plasma widget or for Plasma Mobile (thus equivalent to the SailfishOS implementation). Finally I have been able to put together an initial implementation using Kirigami2. There are several rough edges and bugs, and much of the intended functionality is missing, but at least one can search for bibliographic data. If you are familiar with Kirigami, it should be a low-hanging fruit to fix the obvious issues, especially given that there is already a Silica-based client as reference. Code contributions to branch feature/kirigami are welcome!

comment count unavailable comments

In a recent blog posting I presented some code on how to transliterate common Unicode characters into ASCII-only representations using a offline-generated lookup table to avoid dependencies on ICU which would normally do this job.

By an anonymous commenter, I got pointed to that Unicode (in Qt) is slightly more complicated than I had considered when writing the code: I missed to handle planes beyond the Basic Multilingual Plane (BMP) and the ‘surrogates’ between code points 0xD800 and 0xDFFF. In a series of recently pushed Git commits I addressed problem of surrogates and fixed some more issues. Some preparatory work has been done to support more planes in the future, but as of now, only the BMP is supported. For details, please have a look at the five commits posted on 2019-10-12.

comment count unavailable comments

Lots of great backend work happened this week which is very important, but not terribly flashy. And most of the in-progress work I alluded to last week hasn’t landed yet. So I’m afraid the user-visible changes will have to be a bit light this week. But fear not! For Plasma 5.17 is undergoing its last rounds of final polish and bugfixing before the release next week, and work churns along on lots of great stuff slated for Plasma 5.18 and the next apps versions!

Bugfixes & Performance Improvements

User Interface Improvements

How You Can Help

Check out https://community.kde.org/Get_Involved and find out ways to 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!

Finally, consider making a tax-deductible donation to the KDE e.V. foundation.

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.