May 21, 2018

Are you using Kubuntu 18.04, our current LTS release?

We currently have the Plasma 5.12.5 LTS bugfix release available in our Updates PPA, but we would like to provide the important fixes and translations in this release to all users via updates in the main Ubuntu archive. This would also mean these updates would be provide by default with the 18.04.1 point release ISO expected in late July.

The Stable Release Update tracking bug can be found here:

A account is required to post testing feedback as bug comments.

The Plasma 5.12.5 changelog can be found at:

[Test Case]

* General tests:
– Does plasma desktop start as normal with no apparent regressions over 5.12.4?
– General workflow – testers should carry out their normal tasks, using the plasma features they normally do, and test common subsystems such as audio, settings changes, compositing, desktop affects, suspend etc.

* Specific tests:
– Check the changelog:
– Identify items with front/user facing changes capable of specific testing. e.g. “weather plasmoid fetches BBC weather data.”
– Test the ‘fixed’ functionality.

Testing involves some technical set up to do, so while you do not need to be a highly advanced K/Ubuntu user, some proficiently in apt based package management is advisable.

Details on how to enable the propose repository can be found at:

Unfortunately that page illustrates Xenial and Ubuntu Unity rather than Bionic in Kubuntu. Using Discover or Muon, use Settings > More, enter your password, and ensure that Pre-release updates (bionic-proposed) is ticked in the Updates tab.

Or from the commandline, you can modify the software sources manually by adding the following line to /etc/apt/sources.list:

deb bionic-proposed restricted main multiverse universe

It is not advisable to upgrade all available packages from proposed, as many will be unrelated to this testing and may NOT have been sufficiently verified as updates to assume safe. So the safest but a little involved method would be to use Muon (or even synaptic!) to select each upgradeable packages with a version containing 5.12.5-0ubuntu0.1 ( for plasma-discover due to an additional update).

Please report your findings on the bug report. If you need some guidance on how to structure your report, please see Testing is very important to the quality of the software Ubuntu and Kubuntu developers package and release.

We need your help to get this important bug-fix release out the door to all of our users.

Thanks! Please stop by the Kubuntu-devel IRC channel or Telegram group if you need clarification of any of the steps to follow.

Yes, folks. This year SIGGRAPH 2018 is in Canada and we’ll be there at the Qt booth, showing off our latest tooling and demos. These days, you’d be surprised where Qt is used under the hood, even by the biggest players in the 3D world!

SIGGRAPH 2018 is a five-day immersion into the latest innovations in CG, Animation, VR, Games, Digital Art, Mixed Reality and Emerging Technologies. Experience research, hands-on demos, and fearless acts of collaboration.

Meet us at SIGGRAPH 2018!

The post KDAB at SIGGRAPH 2018 appeared first on KDAB.

KDAB is proud to be bronze sponsor at Italian C++ Conference, the largest conference in Italy specifically focused on C++ development for professionals, students and businesses using C++.

It’s free, organized by the Italian C++ community, and there’s Italian icecream to think about too… It’s an offer you can’t refuse ��

Sign up and see you in Milan in June!

The post KDAB at Italian Cpp 2018 appeared first on KDAB.

There are many ways to understand a community.

For instance, Kevin Ottens has been writing about understanding the KDE community by the “green blobs” method, showing who is active when. Lays Rodrigues has written about using Gource to show Plasma growing up. Nate Graham describes the goings-on in the KDE community nearly every week.

Those are, roughly: a metric-, a visual-, and a story-based approach to understanding the community, over different timescales. But understanding of a system doesn’t come from a single dimension, from a single axis of measurement. It comes from mixing up the different views to look the system as a whole.

To that end, I’m going to apply Kevin’s and Lays’s approaches to .. well, not to something Nate has written, but to a recent this-week-in-Elisa post by Matthieu Gallien. The relevant period is april 22nd (the release of Elisa 0.1.1) to may 16th (latest post on Elisa progress).

ComDaAn is the toolbox Kevin has come up with for dealing with activity and centrality. It’s a Python3 application — it almost works with Python2, except that timestamp-formatting in Python2 does not support the %z flag (in spite of the documentation). No strange dependencies, and easy_install or system packages get everything (even on FreeBSD). The green-blobs tool is called and can take a date range to limit what is shown, for instance ComDaAn/ -f 2018-04-21 -u 2018-05-16 ~/src/kde/elisa/ , which gives us this (image links to an actual HTML page with all the fanciness).

Image of contributions to Elisa

Elisa Contributors, 2018-04-22 — 2018-05-16

Gource is what Lays used to show off Plasma development. I used the same video (regenerated locally) as a blinkenlights show at the KDE booth at FOSS-North. Gource also takes a date range, for instance , which gives us this (image links to the video).

Elisa Gource Screenshot

A moment in Elisa time

The time period here is short; it’s unwise to draw any conclusions from any of these visualisations. They do support the story that Matthieu tells, and the natural order of things is that the main developer does the most commits, with features and fixes coming (ir)regularly from others. The movie shows that the structure of Elisa (or the source code, at least) remains stable over this period. Together, the visualisations along different axes enliven the story of Elisa — and running those tools over a longer period of months can help understand how the community around that application grows and changes.

[[ As an aside, there’s a really neat use of Gource out there: instead of visualising source-code changes, use it to watch other kinds of events, like those that DTrace can provide from a running system. FreeBSD users can enjoy Devin Teske’s dwatch-gource, which uses dwatch to produce logs suitable for gource, and then make a movie of what their system is doing. Maybe not great for parties, but excellent for figuring out why the desktop is suddenly slow while building Qt, LLVM and GCC in parallel (all three with -j8). ]]

I like to cook. And sometimes store my recipes. Over the years I have tried KRecipes, kept my recipes in BasKet notes, in KJots notes, in more or less random word processor documents.

I liked the free form entering recipes in various notes applications and word processor documents, but I lacked some kind of indexing them. What I wanted was free-ish text for writing recipes, and some thing that could help me find them by tags I give them. By Title. By how I organize them. And maybe by Ingredient if I don’t know how to get rid of the soon-to-be-bad in my refridgerator.

Given I’m a software developer, maybe I should try scratch my own itch. And I did in the last month and a half during some evenings. This is also where my latest Qt and modern C++ blog posts comes from

The central bit is basically a markdown viewer, and the file format is some semi structured markdown in one file per recipe. Structured in the file system however you like it.

There is a recipes index which simply is a file system view with pretty titles on top.

There is a way to insert tags into recipes.

I can find them by title.

And I can find recipes by ingredients.

Given it is plain text, it can easily be synced using Git or NextCloud or whatever solution you want for that.

You can give it a spin if you want. It lives here There is a blueprint for a windows installer here:

There is a markdown file describing the specifics of the file format. It is not declared 100% stable yet, but I need good reasons to break stuff.

My recipe collection is in my native language Danish, so I’m not sure sharing it for demo purposes makes too much sense.

Once more in Florence, QtDay Italy is almost upon us and we’ll be there.

Giuseppe D’Angelo will be giving a talk on Gammaray, KDAB’s open source profiling and debugging tool.

GammaRay is a “high-level debugger”, able to show the status of various Qt subsystems inside an application, with an easy to use interface (that does not require any knowledge of Qt internals). GammaRay can, amongst other things, show the properties of any QObject in the application, show the status of all state machines, inspect and debug layouting and stacking of both widgets and Qt Quick applications, analyze raster painting, show the 3D geometry in a Qt3D scene, and much more.

This talk introduces the basics of GammaRay usage, with some interesting cases as examples of problem solutions.

See you in Florence!

The post QtDay Italy, May 23-24 appeared first on KDAB.

May 20, 2018

This week was mainly focused on three things

  • Enable loading/unloading of QML plugins in Falkon
  • Adding permission to existing plugin infrastructure for allowing plugin in incognito
  • Developing QML Bookmarks API similar to WebExtension API

Enable loading/unloading of QML plugins in Falkon

QML plugins will now be loaded into Falkon from the subdirectory qml in the standard plugin paths, similar to Python plugins. Also in metadata.desktop file for plugin, the main entry file (QML) can be specified so that the plugin named X can have the entry file Y.qml.

Adding permission to existing plugin infrastructure for allowing plugin in incognito

Plugins will now support permission to allow them in incognito mode. Also the information for plugins is moved from ini files to sql database.


Developing QML Bookmarks API similar to WebExtension API

The following table demonstrates the browser compatibility of WebExtension API for Falkon compared with other browsers.

Falkon Chrome Edge Mozilla
BookmarkTreeNodeType ❌*
BookmarkTreeNodeUnmodifiable ❌*
CreateDetails ❌*
getSubTree ❌*
getTree ❌*
onChildrenReordered ❌*

To enable the support of API's marked with ❌*, the additional API includes:

  • BookmarkTreeNode.type
  • BookmarkTreeNode.parent
  • Bookmarks.rootItem, Bookmarks.toolbarFolder, Bookmarks.menuFolder, Bookmarks.unsortedFolder
  • Bookmarks.lastUsedFolder
  • Bookmarks.isBookmarked

Currently I am, with a great help from my mentor David Rosca, working on developing autotests for the Bookmarks API.

Happy Summers :)

The other day, some user of Extra CMake Modules (A collection of utilities and find modules created by KDE), asked if there was an easy way to query cmake for wherever the KDEInstallDirs points to (KDEInstallDirs is a set of default paths that mostly is good for your system, iirc based upon GNUInstallDirs but with some extensions for various Qt, KDE and XDG common paths, as well as some cross platform additions). I couldn’t find an easy way of doing it without writing a couple of lines of CMake code.

Getting the KDE_INSTALL_(full_)APPDIR with default options is:

$ cmake -DTYPE=APPDIR ..

and various other options can be set as well.

$ cmake -DCMAKE_INSTALL_PREFIX=/opt/mystuff -DTYPE=BINDIR ..
KDE_INSTALL_FULL_BINDIR: /opt/mystuff/bin

This is kind of simple, but let’s just share it with the world:

cmake_minimum_required(VERSION 3.0)
find_package(ECM REQUIRED)



I don’t think it is complex enough to claim any sorts of copyrights, but if you insist, you can use it under one of the following licenses: CC0, Public Domain (if that’s in your juristiction), MIT/X11, WTFPL (any version), 3-clause BSD, GPL (any version), LGPL (any version) and .. erm. whatever.

I was trying to get it to work as a cmake -P script, but some of the find_package calls requires working CMakeCache. Comments welcome.

Cheap talk

Last weekend, I went to İstanbul to attend Özgür Yazılım ve Linux Günleri (Free Software and Linux Days 2018) to represent LibreOffice. We had 3 presentations during the event about LibreOffice Development and The Open Document Format. We had booth setup with stickers, flyers, roll-up etc. These were all thanks to The Document Foundation’s supports! You can find detailed information about the event from here :

Summary of the event ��

I came back from the event in Monday and since then, I have been working on the Workspace KCM rewrite and single/double click bug fix so just find time to write blog. Workspace KCM rewrite and single/double click bug fix are done and the code is pushed to the master. If you’re on the dev unstable repo, and if you have updated your system in the last 4 days, just go to “System Settings > Desktop Behavior > Workspace” and check it. You should be using new Workspace KCM �� But there are more. I finished a new design for it yesterday and it’ll be pushed soon, after some discussion with maintainers.
See the evaluation of Workspace KCM :

KCM Rewrite

Single/double click bug fix

Kirigami redesign

Show me the code

1. The old Workspace KCM is rewritten in QML. Commit is here.
2. In Wayland, there was no “single/double click” options and in Xorg, it was under “Mouse KCM” but this doesn’t make sense. When user change the setting, it doesn’t affect only mouse, it affects whole system because it is not about input devices. So we discussed the issue and decided to move the setting to Workspace KCM. This also solved the issue for Wayland. In short, single/double click options is moved to Workspace KCM. Commit is here.
3. Workspace KCM is redesign by using Kirigami and the code has same improvement. See the work from here (D12973) and here (D12974).


These were very active days for me. I have been in lots of discussions, did have lots of conversations. Basically I understand how things going on in the background. Nate and Roman are great mentors, friends and the KDE is a great community.

Now, my todolist is as following:
1. Rewrite Touchpad KCM in QtQuick.
2. Rewrite Mouse KCM in QtQuick.

Hope to see you next week! ��

The post This Week in KDE, Part 2 : OYLG, Workspace KCM, Single/Double Click appeared first on Bir Coder'ın Günlüğü.

Valencia está de moda, Valencia se mueve.  Durante mucho tiempo he notado a faltar un grupo de gente en la capital del Turia que dinamizase el Software Libre, eso afortunadamente ha cambiado, y mucho, estos últimos meses. La ciudad está entrando en un época gloriosas para convertirse en un referente dentro de los movimientos locales y un prueba de ello es el anuncio de que el  25 de mayo tendremos nuevo Meetup de GNU/Valencia, una oportunidad única de conocer a gente extraordinaria que lucha por difundir el Software Libte.

25 de mayo tendremos nuevo Meetup de GNU/Valencia

Como decía en la introducción en Valencia está resurgiendo un movimiento libre muy potente: Akademy-es realizó una de sus mejores ediciones allí, Slimbook ensambla y distribuye sus dispositivos libres desde la capital de la luz, lugar donde también se ha creado Linux Center (inaugurado ayer), y un grupo de personas está impulsado el Software Libre gracias a sus reuniones.

Asi que, el próximo 25 de mayo de este 2018 se va a realizar un nuevo encuentro organizado de los chicos y chicas del meetup de GNU/Linux Valencia, un evento que en palabras de los organizadores tiene como objetivo:

“[…] la difusión de GNU/Linux, para lo cual se pretende realizar reuniones mensuales, para realizar desde instalaciones de distribuciones GNU/Linuxen equipos portátiles o de sobremesa, resolver problemas en el uso diario, y dar a conocer la facilidad de uso y funcionamiento de esta distribución de GNU/Linux.

Dado el planteamiento del grupo, cualquiera puede unirse, desde usuarios noveles, sin apenas conocimientos informáticos, hasta usuarios avanzados, que pueden o bien ayudar a los recién llegados resolviendo sus dudas o problemáticas, o incluso el desarrollo de aplicaciones informáticas para la resolución de problemas cotidianos.”

En este nuevo Meetup se hablará en un principio de Automatización de tareas en GNU/Linux, y posteriormente se realizará un coloquio en el que abordarán temas como la Web del grupo, propuestas de Podcast, etc.

25 de mayo tendremos nuevo Meetup de GNU/Valencia

Más información: GNU/Linux Valencia


This week we announced a beta of the upcoming KDE Plasma 5.13 release, and so far the internet seems pretty excited about it. �� But we’re nowhere near done, and here’s another week of Usability and Productivity enhancements to highlight:

New Features


UI Polish & Improvement

See all the names of people who worked hard to make the computing world a better place? That could be you next week! Getting involved isn’t all that tough, and there’s lots of support available. Give it a try today! It’s easy and fun and important.

If my efforts to perform, guide, and document this work seem useful and you’d like to see more of them, then consider becoming a patron on Patreon, LiberaPay, or PayPal.

Become a patron Donate using Liberapay donate with PayPal

May 19, 2018

KDevelop 5.2.2 and 5.2.3 released

We today provide a stabilization and bugfix release with version 5.2.2 and 5.2.3. 5.2.2 was tagged 6 weeks ago, but we never managed to release it because we did not have the patience to fix the Windows installers in time due to a broken CI. Windows installers are provided for 5.2.3 again. We'll only provide source tarballs for 5.2.2 and we encourage everyone to just skip this release and use 5.2.3 which contains a few more bug fixes.

This is a bugfix-only release, which introduces no new features and as such is a safe and recommended update for everyone currently using KDevelop 5.2.1.

You can find the updated Windows 32- and 64 bit installers, the Linux AppImage, as well as the source code archives on our download page.

Please let us know of any issues you encounter when using KDevelop on the bug tracker, in the mailing lists for development or users (,, or in the comment section of this release announcement.

Change log


  • KDevelop : support whitespace between the '#' and 'include' (or 'import'). (commit. fixes bug #394200. code review D12903)
  • Shell: Display generic project managers again. (commit. code review D12279)
  • Github: Fix Github repositories not fetched. (commit. fixes bug #392553. code review D11980)
  • Avoid emptry entries in project files filter list. (commit. code review D11912)
  • Note org.kdevelop.IBasicVersionControl@kdevgit as dep for kdevghprovider. (commit. code review D11823)
  • Never assert when the assert can fire sporadically. (commit. See bug #357585)
  • Sublime: Release space in tab bar when no status. (commit. See bug #314167)
  • Shell: Save entries of recent projects action. (commit. fixes bug #385915)
  • Lldb: don't issue command when there's no env variables to set, fix Bug 391897. (commit. code review D11524)
  • Fix crash when activating code completion item. (commit. fixes bug #391742)
  • Do not add return type to constructors declaration when editing definition in signature assistant. (commit. fixes bug #365420. code review D11291)
  • Make lambda introduce a context in DU chain. (commit. fixes bug #387994. code review D11303)
  • Fix bug 384082 - cppcheck is checking CMake generated files. (commit. fixes bug #384082. code review D11041)
  • Never run qmlplugindump on plugins that already offer plugins.qmltypes. (commit. code review D10872)
  • Fix CodeCompletion of Strongly Typed Enum. (commit. code review D10738)
  • Make sure qmlplugindump works on my system. (commit. code review D10782)
  • Make sure we don't crash when stopping all jobs. (commit. code review D10874)
  • Help automoc to find metadata JSON files referenced in the code. (commit. code review D10693)
  • Link against KF5::Purpose if it's available. (commit. code review D9921)
  • Properly quote expected string value in lldb formatter unittests. (commit. code review D9929)
  • Unbreak the GDB QUrl pretty printer test. (commit. code review D9922)
  • Unbreak QtPrintersTest::testQString. (commit. code review D9923)
  • Also unbreak QtPrintersTest::testQByteArray. (commit. code review D9924)
  • Work around bug in kLineEdit. (commit. code review D9809. fixes bug #373004)
  • Fix crash when stopping process. (commit. code review D9858)
  • Performance: Reuse the global icon loader. (commit. code review D9783)
  • Cache ProblemPointers per translation unit. (commit. fixes bug #386720. code review D9772)
  • Only set CMAKE_AUTOMOC_MACRO_NAMES with KF5 < 5.42. (commit. code review D9778)
  • Format comments before setting them on the DUChain. (commit. code review D9472)
  • Set toolbar/toolbutton font on quickopen line edit. (commit. code review D9481)


  • Ensure that always returns something on stdout to unlock m_mutex. (commit. fixes bug #392031. code review D11474)
  • Fix crash with contexts opened in the baseclass list of a class definition. (commit. fixes bug #389326)
  • Fix appstream metadata filename and some content, and install it. (commit. code review D9488)


No changes

kfunk Sun, 2018/05/20 - 00:00

After almost two years, here comes a new version of Doxyqml, the QML filter for Doxygen. This new version adds a new command-line option: --namespace to wrap the generated C++ in a namespace, and makes the parser more robust. Nothing ground-breaking, but some nice changes nevertheless.

What's interesting with this project is that I don't use it these days, but it still receives contributions from time to time. This puts me in the unusual position (for me) where most of my contributions to the project are reviewing code, cleaning things, a bit of infrastructure (I just added code coverage checks: 88%, not too bad) and release management.

Surprisingly, I like doing this, I am happy to see this little tool remains useful enough that others keep it alive.

All that to say, you can now pip install --upgrade doxyqml to get the latest version, and enjoy documenting your QML components!

@tetris4 wrote:

Also available in Italian and Taiwanese Mandarin.

Hello everyone!

On your next system upgrade you will receive all the latest versions of KDE’s Plasma, Applications and Frameworks, in addition to several other package updates. For more details and the full changelogs on KDE’s software releases, you can read the official announcements:

Other noteworthy package updates include wine 3.8, skypeforlinux and pypy 6.0.0.

Konqis by KDE under CC BY-SA

It should be safe to answer yes to any replacement question by the package manager application. If in doubt or if you face another issue in relation to this update, please ask or report it below.

Most of our mirrors take 12-24 hours to synchronize with the central repositories on the origin server. Use the mirror status web page to see when your mirror of choice last synchronized.


Posts: 1

Participants: 1

Read full topic

Sigo con el repaso al último gran evento de KDE España con una breve resumen de una mañana de sábado en Akademy-es 2018 de Valencia, un repaso a lo que aconteció el sábado 12 de mayo en la capital del Turia ya hace una semana. Y es que el tiempo pasa rápido e inexorable.

Una mañana de sábado en Akademy-es 2018 de Valencia

El día amanece soleado pero con una agradable brisa. Mi hermana me acerca al tranvía, el cual me deja bastante cerca de la sede. Un breve paseo completa el recorrido por esta hermosa zona de la ciudad de Valencia.

A las 10:00 ya estamos los organizadores en la sede, que ha abierto especialmente para nosotros, hecho que demuestra la gran predisposición del  Centre del Carme Cultura Contemporanea. Muchas gracias de nuevo por su gran acogida.

Preparamos las mesas para los asistentes. En esta ocasión ponemos a la venta las camisetas que Freewear nos ha mandado para la ocasión. Aleix monta un móvil con Plasma Mobiel y un Pinebook para que los podamos tocas y ver su funcionamiento. Al lado, la mesa de Slimbook muestra sus productos.

  • 10:30 – 11:05 Mycroft: I.A. en el escritorio – Antonio Larrosa, Presidente de KDE España

El sueño del control por voz de nuestros dispositivos de una forma inteligente cada día está más cerca con Mycroft. El gran Antonio nos muestra su funcionamiento y cómo se puede realizar scripts para él.

Una mañana de sábado en Akademy-es 2018 de Valencia

  • 11:10 – 11:45 Aplicaciones educativas KDE Edu – Baltasar Ortega, editor de KDE Blog

El mundo educativo tiene sus minutos en Akademy-es cuando me toca presentar las 26 aplicaciones educativas que forman parte de KDE Edu. Además de realizar el repaso a cada una de ellas, realizo demostraciones más detalladas con aplicaciones que utilizo más a menudo como Kalzium o Step.


De nuevo tiempo para el refrigerio, los corrillos de charlas, la compra de camisetas y la visita al stand de Slimbook. Y, por supuesto, para visitar el baño más escondido del mundo.

  • 12:00 – 12:35 Las metas de KDE  – Rubén Gómez, miembro de Hacklab Almería

Hace un tiempo que presenté las metas de KDE para el futuro, las cuáles fueron la base de la charla de Rubén. En ella se habló del presente y del futuro del proyecto.


  • 12:40 – 13:15 Rust, por un principianteAlbert Astals, desarrollador de KDE

Tiempo para la charla técnica clásica de Albert, tiempo para la programación. En apenas 35 minutos nos da las pinceladas básicas por si queremos iniciarnos en este lenguaje de programación.



Y aunque sea sábado y sea un poco extraño para los valencianos hoy toca comer una magnífica paella. realizada por uno de los padres de los organizadores y que fue debidamente degustada por los asistentes. Por cierto, también había opción vegana.


Queda la tarde y la noche, pero eso será en una futura entrada.

May 18, 2018

Se acerca una nueva gran actualización del escritorio de la Comunidad KDE. Y por ello ha sido lanzada la beta de Plasma 5.13, para que sea probada y que se reporten los errores que se encuentren.

Lanzada la beta de Plasma 5.13

Ayer 17 de mayo fue lanzada la beta de Plasma 5.13, cuya versión definitiva se espera para el 12 de junioy que promete venir cargado de novedades como:

  • Mejoras en la integración de los navegadores web.
  • Mayor optimización de recursos para equipos de poca potencia.
  • Nuevos efectos visuales como el desenfoque (blur).
  • Mejoras en Wayland.
  • Retoques en las Preferencias del Sistema.
  • Nuevas pantalla de bloqueo y de autentificación.
  • Mejoras en el gestor de aplicaciones Discover.
  • Nuevo y precioso fondo de pantalla.

Lanzada la beta de Plasma 5.13

Y muchas más pequeñas mejoras que hará las delicias de los usuarios de este entorno de trabajo.

Más información:

Pruébalo y reporta errores

Lanzada la beta de KDE Aplicaciones 17.12

Konqi siempre se encuentra dispuesto a buscar bugs y solucionarlos.

Todas las tareas dentro del mundo del Software Libre son importantes: desarrollar, traducir, empaquetar, diseñar, promocionar, etc. Pero hay una que se suele pasar por alto y de la que solo nos acordamos cuando las cosas no nos funcionan como debería: buscar errores.

Desde el blog te animo a que tú seas una de las personas responsables del éxito del nuevo lanzamiento de Plasma 5.13 de KDE. Para ello debes participar en la tarea de buscar y reportar errores, algo básico para que los desarrolladores los solucionen para que el despegue del escritorio esté bien pulido. Debéis pensar que en muchas ocasiones los errores existen porque no le han aparecido al grupo de desarrolladores ya que no se han dado las circunstancias para que lo hagan.

Para ello debes instalarte esta beta y comunicar los errores que salgan en, tal y como expliqué en su día en esta entrada del blog.

Plasma 5.13 Beta

KDE Plasma 5.13 Beta

Thursday, 17 May 2018. Today KDE unveils a beta release of Plasma 5.13.0.

Members of the Plasma team have been working hard to continue making Plasma a lightweight and responsive desktop which loads and runs quickly, but remains full-featured with a polished look and feel. We have spent the last four months optimising startup and minimising memory usage, yielding faster time-to-desktop, better runtime performance and less memory consumption. Basic features like panel popups were optimised to make sure they run smoothly even on the lowest-end hardware. Our design teams have not rested either, producing beautiful new integrated lock and login screen graphics.

New in Plasma 5.13

Plasma Browser Integration

Plasma Browser Integration is a suite of new features which make Firefox and Chrome, and Chromium-based browsers work with your desktop. Downloads are now displayed in the Plasma notification popup just as when transferring files with Dolphin. The Media Controls Plasmoid can mute and skip videos and music playing from within the browser. You can send a link to your phone with KDE Connect. Browser tabs can be opened directly using KRunner via the Alt-Space keyboard shortcut. To enable Plasma Browser Integration, add the relevant plugin from the addon store of your favourite browser.

Plasma Browser Integration for Downloads

Plasma Browser Integration for Media Controls

Plasma Browser Integration for Downloads and Media Controls

System Settings Redesigns

Our settings pages are being redesigned. The KDE Visual Design Group has reviewed many of the tools in System Settings and we are now implementing those redesigns. KDE's Kirigami framework gives the pages a slick new look. We started off with the theming tools, comprising the icons, desktop themes, and cursor themes pages. The splash screen page can now download new splashscreens from the KDE Store. The fonts page can now display previews for the sub-pixel anti-aliasing settings.

Desktop Theme

Font Settings

Icon Themes

Redesigned System Settings Pages

New Look for Lock and Login Screens

Our login and lock screens have a fresh new design, displaying the wallpaper of the current Plasma release by default. The lock screen now incorporates a slick fade-to-blur transition to show the controls, allowing it to be easily used like a screensaver.

Lock Screen

Login Screen

Lock and Login Screen new Look

Improved Blur Effect in the Dash Menu

Improved Blur Effect in the Dash Menu

Graphics Compositor

Our compositor KWin gained much-improved effects for blur and desktop switching. Wayland work continued, with the return of window rules, the use of high priority EGL Contexts, and initial support for screencasts and desktop sharing.

Discover's Lists with Ratings, Themed Icons, and Sorting Options

Discover's Lists with Ratings, Themed Icons, and Sorting Options


Discover, our software and addon installer, has more features and sports improvements to the look and feel.

Using our Kirigami UI framework we improved the appearance of lists and category pages, which now use toolbars instead of big banner images. Lists can now be sorted, and use the new Kirigami Cards widget. Star ratings are shown on lists and app pages. App icons use your local icon theme better match your desktop settings. All AppStream metadata is now shown on the application page, including all URL types. And for users of Arch Linux, the Pacman log is now displayed after software updates.

Work has continued on bundled app formats. Snap support now allows user control of app permissions, and it's possible to install Snaps that use classic mode. And the 'snap://' URL format is now supported. Flatpak support gains the ability to choose the preferred repository to install from when more than one is set up.

Much More

Other changes include:

  • A tech preview of GTK global menu integration.
  • Redesigned Media Player Widget.
  • Plasma Calendar plugin for astronomical events, currently showing: lunar phases & astronomical seasons (equinox, solstices).
  • xdg-desktop-portal-kde, used to give desktop integration for Flatpak and Snap applications, gained support for screenshot and screencast portals.
  • The Digital Clock widget allows copying the current date and time to the clipboard.
  • The notification popup has a button to clear the history.
  • More KRunner plugins to provide easy access to Konsole profiles and the character picker.
  • The Mouse System Settings page has been rewritten for libinput support on X and Wayland.
  • Plasma Vault has a new CryFS backend, commands to remotely close open vaults with KDE Connect, offline vaults, a more polished interface and better error reporting.
  • A new dialog pops up when you first plug in an external monitor so you can easily configure how it should be positioned.
  • Plasma gained the ability to fall back to a software rendering if OpenGL drivers unexpectedly fail.

GEdit with Title Bar Menu

Redesigned Media Player Widget

Connect an External Monitor

GEdit with Title Bar Menu. Redesigned Media Player Widget. Connect an External Monitor Dialog.

Live Images

The easiest way to try it out is with a live image booted off a USB disk. Docker images also provide a quick and easy way to test Plasma.

Download live images with Plasma 5
Download Docker images with Plasma 5

Package Downloads

Distributions have created, or are in the process of creating, packages listed on our wiki page.

Package download wiki page

Source Downloads

You can install Plasma 5 directly from source.

Community instructions to compile it
Source Info Page


You can give us feedback and get updates on Facebook
or Twitter
or Google+.

Discuss Plasma 5 on the KDE Forums Plasma 5 board.

You can provide feedback direct to the developers via the #Plasma IRC channel, Plasma-devel mailing list or report issues via bugzilla. If you like what the team is doing, please let them know!

Your feedback is greatly appreciated.

Now that the beta 1 release of Qt 3D Studio 2.0 is out, let’s go through the steps involved in trying it out for real.

Pre-built runtime binaries

As outlined in last year’s post, the runtime component of Qt 3D Studio has undergone significant changes. This means that the Viewer application that is launched whenever pressing the green “Play” button in Qt 3D Studio and, more importantly, the C++ and QML APIs with the engine underneath, have all been rewritten in the familiar Qt-style C++ on top of Qt 3D. In practice the runtime is an ordinary Qt module, providing both C++ libraries with classes like Q3DSWidget, Q3DSPresentation, etc. and a QML plugin Studio3D and friends.

The releasing of the pre-built binaries for the runtime has improved a lot for version 2.0: there is now a dedicated entry in the Qt installer which will install the necessarily files alongside the normal Qt installation, so pulling in the runtime via QT += 3dstudioruntime2 or by import QtStudio3D 2.0 in QML will work out of the box in a fresh Qt installation. No more manual building from sources is needed (except when targeting certain platforms).

Let’s Install

At the moment Qt 3D Studio binaries are provided for Windows and macOS. Linux may be added in future releases. It is worth noting that this does not mean the runtime is not suitable for running on Linux (or Android or QNX or INTEGRITY, for that matter) – it, like the most of Qt, will build (cross-compile even) and run just fine, assuming a well-working OpenGL implementation is available for your platform. (however, glitches can naturally be expected with less stable and complete graphics stacks) So while we expect the design work in the Qt 3D Studio application done on Windows or macOS for now, Qt applications using the created 3D presentations can be developed on and deployed to all the typical Qt target platforms.

When launching the online installer, take note of the following entries. Note that the layout and the location of these items may change in the installer in beta 2 and beyond. What is shown here is how things look as of 2.0 beta 1.

The runtime depends on Qt 5.11, meaning it must be installed together with 5.11.0 (or a future release, here we will use the release candidate).

In the example run shown on the screenshots we opted for Visual Studio 2015, but choosing something else is an option too – the installer takes care of downloading and installing the right set of pre-built binaries for the Qt 3D Studio runtime.



Once installation is finished, you will have the Qt 5.11 RC, a recent version of Qt Creator, Qt 3D Studio 2.0 beta 1, and the necessary runtime libraries all in place.

Let’s Design

Launching Qt 3D Studio and opening the example project from <installation root>\Tools\Qt3DStudio-2.0.0\examples\studio3d\SampleProject should result in something like the following.


For details on what can be done in the designer application, check the documentation. Speaking of which, the documentation for Qt 3D Studio has been split into two parts in version 2.0: the runtime has its own documentation set with the API references, introduction, system requirements, and other topics. (the links are currently to doc-snapshots, the contents will move to later on)

Let’s Code

Designing the presentation is only half of the story. Let’s get it into a Qt application.

Here we will code an example from scratch. Regardless, you may want to look at the runtime’s examples first. These ship in <installation root>examples\Qt-5.11.0\3dstudioruntime2.

The qmldatainput example in action

For now, let’s start with an empty project. Launch Qt Creator and create a new, empty Qt Quick project targeting Qt 5.11.


The application template gives us a main QML file like this:


When the runtime is installed correctly alongside Qt, we can add the following to make our Qt Quick application load up a Qt 3D Studio presentation and compose it with the rest of the Qt Quick scene.

    import QtStudio3D 2.0
    Window {
        Studio3D {
            anchors.fill: parent
            anchors.margins: 10
            Presentation {
                source: "file:///c:/QtTest/Tools/Qt3DStudio-2.0.0/examples/studio3d/SampleProject/SampleProject.uip"

(replace c:\QtTest as appropriate)

In many real world applications it is quite likely that you will want to place the presentation’s files and assets into the Qt resource system instead, but the raw file references will do as a first step.

Launching this gives us quite impressive results already:


What we see there is the live Qt 3D Studio presentation rendered by the new Qt3D-based engine into an OpenGL texture which is then used by the Qt Quick scenegraph when drawing a textured quad for the Studio3D element. The keyframe-based animations should all run as defined in the Qt 3D Studio application during the design phase.

Now, a common misconception is that Qt 3D Studio is merely a designer tool and the scenes created by it are static with no runtime modifications possible when loaded up in Qt applications. This is pretty incorrect since applications have full control over

Future versions of Qt 3D Studio are expected to extend the capabilities further, for example with adding APIs to spawn and destroy objects in the scene dynamically.

Let’s change that somewhat annoying text in the middle of the scene, using a button from Qt Quick Controls 2. Whenever the button is clicked, the attribute corresponding to the text rendered by the Text node in the Qt 3D Studio scene will be changed.

Option 1: Direct Attribute Access


When digging down the scene structure at the left of the timline pane, take note of the fact that the Text node has a convenient, unique name already (DateAndTime). This is good since it means we can refer to it without further ado in the application code:

import QtQuick.Controls 2.2

Window {

    Studio3D {
        anchors.fill: parent
        anchors.margins: 10
        Presentation {
            id: pres
            source: "file:///c:/QtTest/Tools/Qt3DStudio-2.0.0/examples/studio3d/SampleProject/SampleProject.uip"

        Button {
            text: "Change text"
            anchors.bottom: parent.bottom
            anchors.horizontalCenter: parent.horizontalCenter
            onClicked: pres.setAttribute("DateAndTime", "textstring", "Hello World")

For details on this approach, check out the documentation for Presentation and the attribute name table.

Clicking the button results in changing the ‘textstring’ property of the Text node in the Qt 3D Studio presentation. The change is then picked up by the Qt 3D Studio engine, leading to changing the rendered text.

Option 2: Data Input

While changing properties via setAttribute & co. is simple and effective, Qt 3D Studio also supports another approach: the so-called data inputs. With data inputs, the designers of the 3D scene decide which attributes are controllable by the applications and assign custom names to these. This way a well-known, fixed interface is provided from the designers to the application developers. The example presentation we are using here exposes the following data inputs. (and note the orange-ish highlight for Text String in the Inspector Control in the bottom right corner)


The name dateAndTime is associated with the textstring property of the DateAndTime Text node. Let’s control the value via this approach:

import QtQuick.Controls 2.2

Window {

    Studio3D {
        anchors.fill: parent
        anchors.margins: 10
        Presentation {
            id: pres
            source: "file:///c:/QtTest/Tools/Qt3DStudio-2.0.0/examples/studio3d/SampleProject/SampleProject.uip"

            property string text: ""
            DataInput {
                name: "dateAndTime"
                value: pres.text

        Button {
            text: "Change text"
            anchors.bottom: parent.bottom
            anchors.horizontalCenter: parent.horizontalCenter
            onClicked: pres.text = "Hello World"

Here the Text node starts up with a textstring value of “” (but note there is no actual reference to “textstring” anywhere in the application code), while clicking the button results in changing it to “Hello World”. What’s more, we can now use the usual QML property binding methods to control the value.

That is all for now. Expect more Qt 3D Studio related posts in the near future.

The post Get Started with Qt 3D Studio 2.0 beta 1 appeared first on Qt Blog.

KDE Student Programs is happy to present our 2018 Google Summer of Code students to the KDE Community.

Welcome Abhijeet Sharma, Aman Kumar Gupta, Amit Sagtani, Andrey Cygankov, Andrey Kamakin, Anmol Gautam, Caio Jordão de Lima Carvalho, Chinmoy Ranjan Pradhan, Csaba Kertesz, Demetrio Carrara, Dileep Sankhla, Ferencz Kovács, Furkan Tokac, Gun Park, Iván Yossi Santa María González, Kavinda Pitiduwa Gamage, Mahesh S Nair, Tarek Talaat, Thanh Trung Dinh, Yihang Zhou, and Yingjie Liu!

KDE Google Summer of Code mentors at Akademy 2017. Photo by Bhushan Shah.

Students will work on
improving KStars for Android.

This year digiKam, KDE's professional photo management application, has three students: Tarek Talaat will be working on supporting Twitter and One Drive services in digiKam export, Thanh Trung Dinh on Web Services tools authentication with OAuth2, and Yingjie Liu on adding the possibility to manually sort the digiKam icon view.

Plasma, KDE's graphical desktop environment, will also be mentoring three students. Abhijeet Sharma will be working on fwupd integration with Discover (KDE's graphical software manager), Furkan Tokac will improve handling for touchpads and mice with Libinput, and Gun Park will port keyboard input modules to Qt Quick and expand scope to cover input method configuration for System Settings.

Another project with three students is Krita, KDE's popular graphic editor and painting application. Andrey Kamakin will improve multithreading in Krita's Tile Manager; Iván Yossi Santa María González (ivanyossi) will optimize Krita Soft, Gaussian and Stamp brushes mask generation to use AVX with Vc Library; and Yihang Zhou (Michael Zhou) is creating a Swatches Docker for Krita.

GCompris, the suite of educational programs and games for young learners, takes two students: Aman Kumar Gupta will port all GTK+ piano activities and get it one step closer to version 1.0, and Amit Sagtani will work on creating bitmap drawing and animation activities while preparing Gcompris for version 1.0.

Labplot, KDE's application for scientific data plotting and analysis, also mentors two students. Andrey Cygankov will add support for import data from web-service in LabPlot, and Ferencz Kovács will be working on plotting of live MQTT data.

Falkon, a new member of the KDE family,
will also get some GSoC love.

Okular, KDE's PDF and document viewer, gets another two students: Chinmoy Ranjan Pradhan will be working on verifying signatures of PDF files, while Dileep Sankhla will implement the FreeText annotation with FreeTextTypeWriter behavior.

For Falkon, a community developed web browser and a new member of the KDE family, Anmol Gautam will be working on JavaScript/QML extension support, and Caio Jordão de Lima Carvalho will finish LVM support and implement RAID support in KDE Partition Manager and Calamares (an advanced system installer).

Csaba Kertesz (kecsap) will aim to improve the desktop and the Android version of KStars, KDE's planetarium program, while Kavinda Pitiduwa Gamage will work on KGpg, KDE's graphical key management application, to make it better.

Mahesh S. Nair will expand Peruse Creator, adding more features to KDE's easy-to-use comic book reader. Finally, Demetrio Carrara will be working on the WikitoLearn production-ready Progressive Webapp (PWA).

Traditionally, Google Summer of Code starts with an introduction period where students get to know their mentors, after which they start coding. The coding period for 2018 has began on May 14, and will last until August 6. We wish all our students a productive, successful, and fun summer!

Simple greeting post for guests to get to know about my GSoC topic.

Hello all! This is my first time writing about my work progress in a blog, so some things are still awkward for me. And it is also my first time participating in GSoC and there are many things new to me. I’m cooperating with KDE organisation or rather with one of their projects, named Krita.

I hope that I will gain a great experience from working with and learning from community and manage to accomplish all my tasks for this summer. The coding has already started, so wish me luck :).

May 17, 2018

This mini tutorial aims to show you the fundamentals of creating a RESTful application with Qt, as a client and as a server with the help of Cutelyst.

Services with REST APIs have become very popular in recent years, and interacting with them may be necessary to integrate with services and keep your application relevant, as well as it may be interesting to replace your own protocol with a REST implementation.

REST is very associated with JSON, however, JSON is not required for a service to become RESTful, the way data is exchanged is chosen by the one who defines the API, ie it is possible to have REST exchanging messages in XML or another format. We will use JSON for its popularity, simplicity and due to the QJsonDocument class being present in the Qt Core module.

A REST service is mainly characterized by making use of the little-used HTTP headers and methods, browsers basically use GET to get data and POST to send form and file data, however REST clients will use other methods like DELETE, PUT and HEAD, concerning headers many APIs define headers for authentication, for example X-Application-Token can contain a key generated only for the application of a user X, so that if this header does not contain the correct data it will not have access to the data.

Let’s start by defining the server API:

  • /api/v1/users
    • GET – Gets the list of users
      • Answer: [“uuid1”, “uuid2”]
    • POST – Register new user
      • Send: {“name”: “someone”, “age”: 32}
      • Answer: {“status”: “ok / error”, “uuid”: “new user uuid”, “error”: “msg in case of error”}
  • /api/v1/users/ – where UUID should be replaced by the user’s UUID
    • GET – Gets user information
      • Answer: {“name”: “someone”, “age”: 32}
    • PUT – Update user information
      • Send: {“name”: “someone”, “age”: 57}
      • Answer: {“status”: “ok / error”, “error”: “msg in case of error”}
    • DELETE – Delete user
      • Answer: {“status”: “ok / error”, “error”: “msg in case of error”}

For the sake of simplicity we will store the data using QSettings, we do not recommend it for real applications, but Sql or something like that escapes from the scope of this tutorial. We also assume that you already have Qt and Cutelyst installed, the code is available at

Part 1 – RESTful Server with C ++, Cutelyst and Qt

First we create the server application:

$ cutelyst2 --create-app ServerREST

And then we will create the Controller that will have the API methods:

$ cutelyst2 --controller ApiV1

Once the new class has been instantiated in serverrest.cpp, init() method with:

#include "apiv1.h"

bool ServerREST::init()
    new ApiV1 (this);

Add the following methods to the file “apiv1.h”

C_ATTR(users, :Local :AutoArgs :ActionClass(REST))
void users(Context *c);

C_ATTR(users_GET, :Private)
void users_GET(Context *c);

C_ATTR(users_POST, :Private)
void users_POST(Context *c);

C_ATTR(users_uuid, :Path('users') :AutoArgs :ActionClass(REST))
void users_uuid(Context *c, const QString &uuid);

C_ATTR(users_uuid_GET, :Private)
void users_uuid_GET(Context *c, const QString &uuid);

C_ATTR(users_uuid_PUT, :Private)
void users_uuid_PUT(Context *c, const QString &uuid);

C_ATTR(users_uuid_DELETE, :Private)
void users_uuid_DELETE(Context *c, const QString &uuid);

The C_ATTR macro is used to add metadata about the class that the MOC will generate, so Cutelyst knows how to map the URLs to those functions.

  • :Local – Map method name to URL by generating /api/v1/users
  • :AutoArgs – Automatically checks the number of arguments after the Context *, in users_uuid we have only one, so the method will be called if the URL is /api/v1/users/any-thing
  • :ActionClass(REST) ​​- Will load the REST plugin that will create an Action class to take care of this method, ActionREST will call the other methods depending on the called method
  • :Private – Registers the action as private in Cutelyst, so that it is not directly accessible via URL

This is enough to have an automatic mapping depending on the HTTP method for each function, it is important to note that the first function (without _METHOD) is always executed, for more information see the API of ActionREST

For brevity I will show only the GET code of users, the rest can be seen in GitHub:

void ApiV1::users_GET(Context *c)
    QSettings s;
    const QStringList uuids = s.childGroups();


After all the implemented methods start the server:

cutelyst2 -r --server --app-file path_to_it

To test the API you can test a POST with curl:

curl -H "Content-Type: application/json" -X POST -d '{"name": "someone", "age": 32}' http://localhost:3000/api/v1/users

Okay, now you have a REST server application, made with Qt, with one of the fastest answers in the old west ��

No, it’s serious, check out the benchmarks.

Now let’s go to part 2, which is to create the client application that will consume this API.

Part 2 – REST Client Application

First create a QWidgets project with a QMainWindow, the goal here is just to see how to create REST requests from Qt code, so we assume that you are already familiar with creating graphical interfaces with it.

Our interface will be composed of:

  • 1 – QComboBox where we will list users’ UUIDs
  • 1 – QLineEdit to enter and display the user name
  • 1 – QSpinBox to enter and view user age
  • 2 – QPushButton
    • To create or update a user’s registry
    • To delete the user record

Once designed the interface, our QMainWindow sub-class needs to have a pointer to QNetworkAccessManager, this is the class responsible for handling communication with network services such as HTTP and FTP. This class works asynchronously, it has the same operation as a browser that will create up to 6 simultaneous connections to the same server, if you have made more requests at the same time it will put them in a queue (or pipeline them if set).

Then create a QNetworkAccessManager *m_nam; as a member of your class so we can reuse it. Our request to obtain the list of users will be quite simple:

QNetworkRequest request(QUrl("http://localhost:3000/api/v1/users"));

QNetworkReply *reply = m_nam->get(request);
connect(reply, &QNetworkReply::finished, this, [this, reply] {
    const QJsonDocument doc = QJsonDocument::fromJson(reply->readAll());
    const QJsonArray array = doc.array();

    for (const QJsonValue &value : array) {

This fills with the data via GET from the server our QComboBox, now we will see the registration code which is a little more complex:

QNetworkRequest request(QUrl("http://localhost:3000/api/v1/users"));
request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");

QJsonObject obj {
    {"name", ui->nameLE->text()},
    ("age", ui->ageSP->value()}

QNetworkReply *reply = m_nam->post(request, QJsonDocument(obj).toJson());
connect(reply, &QNetworkReply::finished, this, [this, reply] {
    const QJsonDocument doc = QJsonDocument::fromJson(reply->readAll());
    const QJsonObject obj = doc.object();

    if (obj.value("status").toString() == "ok") {
    } else {
        qWarning() << "ERROR" << obj.value("error").toString();

With the above code we send an HTTP request using the POST method, like PUT it accepts sending data to the server. It is important to inform the server with what kind of data it will be dealing with, so the “Content-Type” header is set to “application/json”, Qt issues a warning on the terminal if the content type has not been defined. As soon as the server responds we add the new UUID in the combobox so that it stays up to date without having to get all UUIDs again.

As demonstrated QNetworkAccessManager already has methods ready for the most common REST actions, however if you wanted to send a request of type OPTIONS for example will have to create a request of type CustomOperation:

m_nam->sendCustomRequest("OPTIONS", request);

Did you like the article? Help by giving a star to Cutelyst and/or supporting me on Patreon

May 16, 2018

Elisa is a music player developed by the KDE community that strives to be simple and nice to use. We also recognize that we need a flexible product to account for the different workflows and use-cases of our users.
We focus on a very good integration with the Plasma desktop of the KDE community without compromising the support for other platforms (other Linux desktop environments, Windows and Android).
We are creating a reliable product that is a joy to use and respects our users privacy. As such, we will prefer to support online services where users are in control of their data.

 Improvements of Elisa Interface

We have got a new application icon from Paul Lesur. Thanks for the help.

128-apps-elisaNew Elisa Application Icon

Diego Gangl has been working on improving the design of the interface. Among the changes some where suggested quite some time ago by the KDE VDG.

The main controls of playback are now all on the same horizontal bar. This way, it should be much easier to locate them.

The view selector list has also a new simpler and cleaner look. I especially appreciate the removal of the not quite working color animations of the current item indicator.

Alexander Stippich added a small button that allows to sort the views in ascending or descending order. They are now sorted by default. The data comes from the tracks database in sorted order (done by Kevin Ottens). The case is ignored.

Screenshot_20180516_223706Current Interface with Many Improvements

Many Improvements on Tracks Properties

A lot of work has recently went into Baloo and KFileMetaData frameworks. While this is not strictly related to the Elisa project, it is a huge improvement.

Elisa got hugely improved support for discovering existing image files with a cover. This work has been done by Kevin Ottens and Alexander Stippich. There are still cases where the cover might not be found if for example the cover file name has spaces. We may also want to be able to select the best one among many.

Elisa got fixes to better support track properties with multiple values. The current state is still not able to fully support authors list for example but we will eventually get there.

Performance Improvements when Checking Existing Music at Start

Elisa stores your discovered music in a small database to allow a quick start. Due to that, it needs to check if known tracks have changed or have been moved or removed. It also has to check if new music has been added.

This had been quite fast when using the Baloo support but was really slow for big music collections indexed by the Elisa specific indexer.

It is now storing the latest modification time of the files (possible by requiring Qt 5.10) and will only parse the properties of a track if needed. I did tests with a collection of around 4000 tracks and the improvement is really noticeable.

Please if you still notice problems, send us your feedback.

Ongoing work

Alexander Stippich is working on file system browsing from inside Elisa.

This work will be especially useful for playing tracks with no or bad properties.

It will also benefits everybody because when doing this work it has resulted in fixes for shared code like falling back to file name when no title property is there.

I am working to allow to browse the music by genre. This has led to many improvements to the automatic tests and the tracks database.

Screenshot_20180516_235410Work In Progress: Browsing by Genre

One of the interesting side improvements is that now the only view that is visible is loaded in the interface. This should improve startup time and resource consumption.

Next Steps

We have decided to modify a little bit our release schedule to have two months before the feature freeze and only one more month before the release of the next stable release (i.e. the 0.2 version). The next step is the 2nd of June.

We Need your Help

There are quite some small tasks that are open in the Elisa workboard. They are a really good opportunity to join the project. Everybody will be happy to help and guide you. We will identify some junior jobs (I borrowed the idea from a recent blog post from KDE Connect team).

We also need help with every other tasks like: triaging bugs, working on code, improving the design and helping with the promo.

Coming close to the next release of LabPlot, the last new feature in this release that we want to introduce is the support for live data. This feature developed by Fábián Kristóf during “Google Summer of Code 2017” program. In this context, the support for live data refers to the data that is frequently changing and the ability of the application to visualize this changing data.

Prior to the upcoming release, the only supported workflow in LabPlot was to import the data from an external file into LabPlot’s data containers and to do the visualization. On data changes, the user needed to re-import again. With LabPlot 2.5 we introduced the “Live Data Source” object that is “connected” to the actual data source and that takes care of re-reading the changed data according to the specified options.

Add Live Data Source

The supported data source are files and named pipes, Unix/UDP/TCP sockets and serial port. The data can be read periodically where the user can specify the time interval for when to read the new data or alternatively on data changes. At the moment, the only supported formats are ASCII and binary data.

The consumption of the data in plots is pretty much the same as when using spreadsheets – the user simply selects the columns in such a live data source object as the sources of the data to be plotted.

The following video shows a combination of Gnucap and LabPlot and demonstrates LabPlot’s ability to monitor a file, to re-read it on changes and to automatically update the visualization of the data. A small application written in python and Qt controls the definition of Gnucap’s circuit file for a biquad filter. The user is able to change the values of the resistances via changing the values of the sliders. After each change, the circuit simulation is re-calculated in Gnucap to obtain the frequency response of the filter. The results of the simulation are written out to a file which is consumed by LabPlot in a “Live Data Source” object. The Bode plot in LabPlot is updated automatically on every change of one of the resistance values.

This example was contributed by Orestes Mas from the Technical University of Catalonia. Fábián’s blog contains more examples and details for this feature.

Another feature that is not directly related to the actual reading of live data but that comes in handy when dealing with such data is the ability to quickly specify the amount of data points that has to be plotted. In addition to the already available “free ranges” where the user can freely navigate through the data, the options “Show first N points” and “Show last N points” were added in the plot. Couple of examples for this new data range options are given in another blog post.

Here is GCompris 0.91, a new bugfix release to correct some issues in previous version and improve a few things.

Every GNU/Linux distribution shipping 0.90 should update to 0.91.


With 68 commits since last release, the full changelog is too long for this post. But here is a list to summarize the changes.


  • fix English text in several activities
  • fix score position in several activities
  • block some buttons and interactions when needed in several places
  • lots of fixes for audio in several activities
  • number_sequence (and others based on it), fix base layout
  • update dataset for clickanddraw, drawnumbers and drawletters
  • crane, add localized dataset
  • lightsoff, add keyboard support and other fixes
  • algorithm, add keyboard support and other fixes
  • money, fixes for locale currency used
  • ballcatch, improve audio feedback
  • calendar, several little fixes
  • memory-case-association fix icons size

Other changes:

  • re-enable sound effects on linux
  • improved playback of sound effects, no more delay
  • add captions to images and OARS tags in the appdata
  • add Scottish Gaelic to core, and update some datasets for it
  • main bar, fix some items size
  • remove unused images

You can find this new version on the download page, and soon in the Play store and Windows store.

On the translation side, we have 16 languages fully supported: British English, Catalan, Catalan (Valencian), Chinese Traditional, Dutch, French, Greek, Indonesian, Irish Gaelic, Italian, Polish, Portuguese, Romanian, Spanish, Swedish, Ukrainian.
We also have 15 languages partially supported: Norwegian Nynorsk (97%), Hindi (96%), Turkish (90%), Scottish Gaelic (86%), Galician (86%), Brazilian Portuguese (84%), Belarusian (84%), German (81%), Chinese Simplified (79%), Russian (78%), Estonian (77%), Slovak (76%), Finnish (76%), Slovenian (69%), Breton (65%).

If you want to help completing one of these translations or adding a new one, please contact us.

Else you can still help by making some posts in your community about GCompris and don’t hesitate to give feedbacks.

Thank you all,
Timothée & Johnny

Some days since the Ceph and CloudStack Day in London last month now. It was a great event, great presentations and a lot of networking with the local community.

You can find my presentation on "Email Storage with Ceph" online as also the break slides with some impressions from some of the last few Ceph events.

Some of the other presentations can be found here and some pictures from the day in this album.

We are getting close to releasing the Qt 3D Studio 2.0 and the first Beta is released today. First beta packages are now available through the Qt online installer & Qt download. Let’s have a quick summary of the changes & new features we are introducing. For detailed information about the Qt 3D Studio please visit our web pages at:

New Runtime & Viewer Application

One of the biggest changes in the 2.0 release is the new Qt 3D Studio runtime which is built on top of the Qt 3D module. From user perspective this change is not directly visible, but a very important item under the hood. Using Qt 3D means deeper and easier integration to the Qt framework. It also makes it easier for us to introduce new features from both tooling and 3D engine perspective. First example of the new features is the Qt 3D Studio 2.0 Viewer Debugging and Profiling UI which shows the basic information about the rendering performance and structure of the 3D scene.

Qt 3D Studio Viewer Profile and Debug view

Qt 3D Studio Viewer Profile and Debug view

Deploying your UI project to the Viewer application in the target device with debugging and profiling enabled allows you to immediately see what the potential design performance bottlenecks are. You can also spot cases where you are using large textures or 3D models have a lot of parts which are not visible.

Improved Data Input

Data Inputs are a mechanism for integrating the user interface to the application logic. The Data Input functionality in the 1.1 release was somewhat limited and basically offered support only to control animation timelines and changing slides. With the 2.0 release we have introduced several new data types which can be now easily tied to different object properties in the 3D scene.

Improved Data Input

Improved Data Input

For more details on using Data Inputs please refer to documentation 

Editor Improvements

Biggest change in the editor side is the new timeline view which has been totally rewritten. This rewrite makes it easier for us to introduce new features in the future and already in the 2.0 release we have already made several small usability improvements.

New timeline

New timeline

We have also made changes to the shortcut keys and mouse usage so that changing between different Camera Views (Perspective, Top, Scene Camera etc.) and panning and orbiting is easier, and the behavior is closer to the common practices in 3D design tools. For more details please refer to keyboard shortcuts documentation.


Qt 3D Studio 2.0 beta releases are available through Qt online installer under the Preview section. Qt online installer can be obtained from Qt Download page and commercial license holders can find the packages from Qt Account.

Some example projects can be found under examples folder in the installation directory. Additional examples and demo applications can be found from repository. If you encounter issues with using Qt 3D Studio or you would like to suggest new feature, please use Qt3D Studio project in the

The post Qt 3D Studio 2.0 Beta Available appeared first on Qt Blog.


I am Gun Park, and I’m excited to finally join the wonderful KDE community through this amazing opportunity called Google Summer of Code 2018. Thanks for all the people that have supported and led me to this journey!

My project is porting the Keyboard configuration module in System Settings to the modern Qt Quick framework, with Wayland in mind. Right now, it’s only capable of configuring Xkb. But Xkb alone is useless without an IME when trying to input languages like Chinese, Japanese, and Korean. So far, if you spoke one of those languages, you had to go to the command line, and manually install fcitx and the corresponding module for your language in order to use your language at all. So I’m planning to add a seamless interface for configuring the IME, to do all that automatically.

Currently the Keyboard module codebase is ancient, depends on a lot of legacy stuff, and a bit messy after standing the Test of Time. It needs a new backend, and a fancy new UI with modern Qt Quick too.

So far I have been experimenting with QML, and have replicated the existing interface in QML. But it seems like they have to be changed a lot. Let’s look at them over.

This is the first screen you see when you go into System Settings -> Inputs -> Keyboard (actually, my replica of it in QML):

Hardware Panel

Also the second panel:

Layouts Panel

The third panel, “Advanced”, is a bunch of miscellaneous settings from the xkb configuration file, and not all of them might be necessary, and they could certainly be placed in better places. So this needs to be completely redesigned with collaboration with the KDE Visual Design Group.

I have also been learning how QAbstractItemModels work, and my mentor told me about how we can use these models and proxy models to make the program much more flexible and easy to work with. I could definitely see why, and I thought this was very cool. So I have been experimenting with the layouts and the keyboard model’s models.

The current backend relies on legacy libraries like xlib and xkblib. We need to transition to a libinput-based solution. (This seems like the biggest work we will need to do, but I still don’t know a lot about it.)

That is what I have figured out so far, thanks to the immense help from my mentor Eike Hein, as the coding period starts.

Qt for Automation has been launched in conjunction with Qt 5.10 as an AddOn to Qt for Application Development or Qt for Device Creation. One module in that offering is our client-side solution for MQTT called Qt MQTT.

Qt MQTT focusses on the client side, helping developers to create sensor devices and or gateways managing data to be sent via MQTT.  MQTT describes itself to be lightweight, open and simple. The principle idea is to reduce the protocol overhead as much as possible. The most used version of this protocol is MQTT 3.1.1, usually referred to as MQTT 4. The MQTT 5 standard has been agreed on recently, and we are working on adding support for it in Qt MQTT. But that will be part of another announcement later this year.

To verify the functionality of a module and also to provide guidelines for developers on its usage, The Qt Company created a demo which is called SensorTag. We will use this demo as a basis for this blog series.

A brief introduction can be viewed in this video:

The source code of this demo is located in our Boot 2 Qt demo repository here ( ).

Basically, this demo describes a scenario in which multiple sensors report data to a gateway (in this case Raspberry Pi3) via Bluetooth, which then again sends data to an MQTT broker in the cloud. Multiple gateways mesh up to generate a sensor network.


Each sensor propagates updates to what they measure, more specifically

  • Ambient Temperature
  • Object Temperature
  • Acceleration
  • Orientation / angular velocity
  • Magnetism
  • Altitude
  • Light
  • Humidity

As the focus of this series is about data transmission, the Sensor / Gateway combination will be summed up as “device”.

The demo serves two purposes; It has a pleasant user interface, which appeals to many, and it showcases how easy it is to integrate MQTT (and Qt MQTT).

MQTT is a publish/subscribe protocol, which implies that data is sent related to a specific topic and other recipients register themselves to a broker (server) to receive notifications on each message published.

For the devices above, available messages are:

  • [Topic: Sensors/active, Data: ID]: Every 5 seconds a sensor publishes an “Online” message, notifying subscribers that the device is still active and sending data. On initial connect it also includes a Will message “Offline”. A will message is sent whenever a device disconnects to notify all subscribers with a “Last Will”. Hence, as soon as the network is disconnected, the broker broadcasts the last will to all subscribed parties.
  • [Topic: Sensor/<sensorID>/<datatype>/, Data:<value>]: This is send from each sensor whenever a value for a specific datatype like in above list changes. The user interface from the video subscribes to these messages and updates the graphics accordingly.

Side-note: One additional use-case could be to check the temperature of all devices. In that case, “wildcard” subscriptions can be very useful. Subscribing to “Sensor/+/temperature will lead to receiving temperature updates from all sensors.

Currently, there are around 10 sensors registered at the same time at peak times, mostly when the demo is presented at tradeshows. As mentioned above, demo code exists to showcase an integration, not necessarily the most performant or energy-saving solution. When going towards production, a couple of questions need to be asked:

  • What would happen in a real-world scenario? Would the demo scale up to thousands of devices reporting data?
  • Does the demo fit to requirements on hardware and/or battery usage?
  • Is it within the boundaries of communication limitations of Low Power WAN solutions?

In case you are not familiar with LPWAN solutions like LoRA or Sigfox, I highly recommend Massimo’s talk ( ) at the Qt World Summit 2017.


To simplify the source to look at and to reduce it to a non-UI minimal example, there is a minimal representation available here . In that the SensorInformation class has a couple of properties, which get updated frequently:

class SensorInformation : public QObject

    Q_PROPERTY(double ambientTemperature READ ambientTemperature WRITE setAmbientTemperature NOTIFY ambientTemperatureChanged)
    Q_PROPERTY(double objectTemperature READ objectTemperature WRITE setObjectTemperature NOTIFY objectTemperatureChanged)
    Q_PROPERTY(double accelerometerX READ accelerometerX WRITE setAccelerometerX NOTIFY accelerometerXChanged)
    Q_PROPERTY(double accelerometerY READ accelerometerY WRITE setAccelerometerY NOTIFY accelerometerYChanged)
    Q_PROPERTY(double accelerometerZ READ accelerometerZ WRITE setAccelerometerZ NOTIFY accelerometerZChanged)
    Q_PROPERTY(double altitude READ altitude WRITE setAltitude NOTIFY altitudeChanged)
    Q_PROPERTY(double light READ light WRITE setLight NOTIFY lightChanged)
    Q_PROPERTY(double humidity READ humidity WRITE setHumidity NOTIFY humidityChanged)


Whenever a property is updated the client publishes a message:



The device update rate depends on the type of sensors, items like temperature and light intensity are updated less frequently than, for instance, acceleration.

To get an idea of how much data is sent, example Part1B hooks into the client’s transport capabilities. MQTT in its standard has only a limited number of requirements for the transport. Whatever transmits the data must send it ordered, lossless and bi-directional. Theoretically, anything starting from QIODevice is capable of this. QMqttClient allows to specify a custom transport via QMqttClient::setTransport(). Here, we use the following:


class LoggingTransport : public QTcpSocket
    LoggingTransport(QObject *parent = nullptr);

     qint64 writeData(const char *data, qint64 len) override;
    void printStatistics();
    QTimer *m_timer;
    QMutex *m_mutex;
    int m_dataSize{0};

Inside the constructor a timer is created to invoke printStatistics() at a regular interval. writeData simply stores the length of data to be send and then passes on to QTcpSocket::writeData().

To add the LoggingTransport to a client, all one needs to do is:

    m_transport = new LoggingTransport(this);
    m_client = new QMqttClient(this);
    m_client->setTransport(m_transport, QMqttClient::AbstractSocket);

The output shows that after 11 seconds one sensor sends about 100KB of data. This is just one sensor. Considering the “real-world” example this is clearly unacceptable for distribution. Hence, the effort is now to reduce the number of bytes to be published without losing information.

The demo itself uses one connection at all times, meaning it does not need to dis- or reconnect. The connect statement in MQTT 3.1.1 is around 10 bytes plus the ID of the client. In case a device would reconnect each time to send data, this can add up to a significant amount. But in this case, we “optimized” it already.

Consequently, we move on to the publishing step. There are two options, reduce the size of each message and reduce the number of messages.

For the former, the design of a publish message for ambient temperature is the following:

Bytes Content
1 Publish Statement & Configuration
1 Remaining Length of the message
2 Length of the topic
71 Topic: qtdemosensors/{8f8fde60-933d-44cf-b3a7-8dac62425a63}/ambientTemperature
2 ID of the message
1..8 Value (String for double)

It is obvious that the topic itself is to be taken responsible for the size of the message, especially as the payload storing the value is just a fraction of the size of a message.

Concepts which can be applied here are:

  • Shorten the “root” topic (qtdemosensors -> qtds)
  • Shrink the size of the ID (UUID -> 8 digit number)
  • Replace the clear text of sensortype with an enum (ambientTemperature -> 1)

All those approaches come with a price. Using enums instead of clear text property reduces the readability of a message, the subscriber always has to know what type of data corresponds to an ID. Reducing the size of the ID potentially limits the maximum number of connected devices, etc. But applying those items leads to more than three times longer period until the 100KB barrier is reached (See example Part 1C).

At this stage, it becomes impossible to reduce the message overhead without losing information. In the showcase, I mentioned that the simulated sensors are to be used in the field, potentially sending data via LPWAN. Typically, sensors in this area should not send data on such a high frequency. If that is the case, there are two additional options.

First, the messages are getting combined to one single message containing all sensor properties. The table above showed that the amount of data for the value part has just been a fraction of the message overhead.

One approach is to use JSON to propagate properties, this can be seen in example Part 1d. QJsonObject and QJsonDocument are very handy to use, and QJsonDocument::toJson() exports the content to a QByteArray, which fits perfectly to an MQTT message.


void SensorInformation::publish()
    QJsonObject jobject;
    jobject["AmbientTemperature"] = QString::number(m_ambientTemperature);
    jobject["ObjectTemperature"] = QString::number(m_objectTemperature);
    jobject["AccelerometerX"] = QString::number(m_accelerometerX);
    jobject["AccelerometerY"] = QString::number(m_accelerometerY);
    jobject["AccelerometerZ"] = QString::number(m_accelerometerZ);
    jobject["Altitude"] = QString::number(m_altitude);
    jobject["Light"] = QString::number(m_light);
    jobject["Humidity"] = QString::number(m_humidity);
    QJsonDocument doc( jobject );
    m_client->publish(QString::fromLatin1("qtds/%1").arg(m_id), doc.toJson());


The size of an MQTT publish message is now at around 272 bytes including all information. As mentioned before, it comes at the cost of losing information, but also at significantly reducing the bandwidth required.

To summarize this first part, we have looked into various solutions to reduce the amount of data being sent from a device to an MQTT broker with minimal effort. Some approaches trade off readability or extensibility, others come with a loss of information before data transmission. It really depends on the use-case and the scenario in which an IoT solution is put into production. But all of these can easily be implemented with Qt. Until now, we have only covered Qt’s feature set on JSON, MQTT, networking, and connectivity via Bluetooth.

In the meantime, you can also find more information on our website and write your comments below.

The post Optimizing Device Communication with Qt MQTT appeared first on Qt Blog.


I am Andrey Cygankov, and I am participating in Google Summer of Code 2018.

Currently LabPlot supports importing data from some data sources and I am working on expanding this list adding web services to it. I have written a proposal explaining what I am going to do in this project.

During the community bonding period I have been acquainted with the code and the overall architecture in LabPlot. Also I am going to start developing a feature for importing data in the JSON format. I already had some nice conversations with my mentor (Alexander Semke) for some questions.

The coding period has started and I am ready to focus all my energy on project.

Contribution of source code is now allowed via Qt systems such as bug reports and forums. Traditionally all source code contributions to the Qt Project are governed via Contribution License Agreement (CLA), except possibility given to the commercial license holders to provide bug fixes and similar small modifications that The Qt Company has pushed into Qt. We have now updated the Qt Account service terms to more clearly state that source code can be contributed via the Qt systems.

The preferred way to contribute source code to the Qt Project is still via the CLA, according to the contribution guidelines. But sometimes a user who has not accepted the CLA has a patch that would, for example, fix a bug in Qt. Providing such a patch is now also possible via the Qt systems, for example via the bug reports or forum posts.

When such a “casual contribution” is done, it will be the responsibility of The Qt Company to pick up the contributed source code and complete the needed steps of pushing the fix into Qt. So the contributed code will not automatically go in as-is, but via the regular contribution process that ensures good quality of the source code in the Qt repositories.

The earlier service terms of the Qt Account and other Qt systems already provided adequate rights for The Qt Company to publish the content provided by the registered users. However, the earlier version did not explicitly mention that this includes source code, so we wanted to make the clarification. As we take these matters seriously, we will only use source code contributed from now on. In case you have earlier submitted a patch via some of the Qt systems, please submit it again.

In addition to providing source code, there are many other ways to contribute to Qt, for example by reporting bugs, supporting others in Qt mailing lists or forums, translating to other languages, and writing documentation.

If you have any questions regarding contributions to Qt, please do not hesitate to ask from our legal.

The post Code contributions via bug reports and forum posts appeared first on Qt Blog.

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.