Language Selection

English French German Italian Portuguese Spanish

Kde Planet

Syndicate content Planet KDE
Planet KDE
Updated: 2 hours 3 min ago

Vídeo de Plasma Bigscreen, KDE en tu TV

Friday 27th of March 2020 08:14:00 PM

Debería hablar de ciertos temas como el último podcast de KDE España, el próximo de mañana o un aniversario que no ha pasado desapercibido para algunos (muchas gracias Victorchk), pero no me apetece por diversos motivos. Hoy quiero compartir un vídeo de Plasma Bigscreen, el proyecto que fue presentado ayer por la Comunidad KDE y que tiene todos los números de convertirse en un bombazo.

Vídeo de Plasma Bigscreen

Lo cierto es que cuando las tecnologías libres se conjuntan pueden salir proyectos maravillosos. Es el caso de Plasma Bigscreen, el nuevo proyecto de la Comunidad KDE que fue presentado ayer en sociedad con un excelente artículo en el dot de KDE.News.

Para resumir, el proyecto tangible de Plasma Bigscreen (y digo tangible porque ya lo puedes tener en tu televisor) es la unión de varias tecnologías libres:

  • Las increíbles Raspberry Pi, un proyecto que proporciona el hardware necesario para que funcione el resto del Software. Con menos de 50 € puedes tener tu pequeño PC con el que trastear y conectar donde quieras: un monitor, una pequeña pantalla, un televisor moderno e, incluso, con un televisor con entrada RCA.
  • El proyecto MyCroft AI, un software que convierte tu pequeña Raspberry Pi en un asistente de personal controlado por tu voz.
  • El Software de la Comunidad, que con su concepción camaleónica y sus propiedades de escalibilidad, se puede adaptar a nuevos formatos de visualización y control.

El resultado es este Plasma Bigscreen que podemos ver en funcionamiento en este vídeo de poco más de 3 minutos donde se muestra su precioso aspecto visual (recordemos que nos encontramos ante una versión todavía beta del proyecto), su control vía MyCroft que nos permite buscar vídeos en youtube o música en SoundCloud, la posibilidad de instalación de aplicaciones o su nuevo navegador web Aurora o la posibilidad de jugar a juegos libres en una gran pantalla.


Más información: Aix’s Blog


New QML language features in Qt 5.15

Friday 27th of March 2020 01:58:08 PM

While big changes are on their way for Qt 6.0, QML got some new language features already in 5.15. Read on to to learn about required properties, inline components and nullish coalescing.

Krita Weeky #13 | 4.2.9 released

Friday 27th of March 2020 10:41:48 AM
So one of the toughest Krita releases is up today. Tough not in the sense there were a lot of regressions to solve but the mountain of build issues faced by the team.

It’s just a matter of selecting the right search terms

Friday 27th of March 2020 07:13:10 AM

Once more, I wanted to push a small change to a Git repository to which the owner gave me write access. This repo is currently the only one for me, for which I need to use https as transport protocol and therefore have to enter username and password for each and every push.

On the other hand, I keep all my valuable credentials in Pass: The Standard Unix Password Manager for a couple of years now. It stores them with strong GPG encryption on my disk, is nicely integrated into Firefox by a plugin and there is also a KDE plasma widget available, created by my fellow KDE developer Daniel Vrátil. So why can’t Git read (I was about to use pull here, but that might be confusing in the context of Git) the credentials from my password store? There must be a way!

Next, I started reading the documentation about git-credentials which seems to provide all that is needed. Just that pass was not on the list of helpers. Reading the specs, I expected it to be pretty easy to write a small wrapper that solves the issue. But: this sounds like a problem too obvious and to be solved already. So the search began.

Using all kinds of combinations of git-credentials, pass, password-store and some more I don’t remember, I always ended up on some general Git documentation, but no sign of what I was looking for. So maybe, it really does not exist (oh, I have not consulted the yellow pages) and I have to develop and provide it to the internet community myself.

Reading the specs more thoroughly – now that i need to understand the interface to such a wrapper – I came across the search pattern used by Git to find those credential helpers. I was tempted to name mine git-credential-pass since it is a helper for pass. But wait: one more trial using this name as pattern for the search engine of choice, et voilà: I found pass-git-helper, a nice python based script which does exactly what I looked for (and maybe a few more things).

It already exists for a couple of years, so I wondered if I can find it in my distro’s repo to save some time and get automatic updates. Bad news, it does not exist.

So it was a matter of git clone, manual installation and configuration to gain some more integration and automation.

% git clone % sudo python3 install # test drive % pass-git-helper get protocol=https ^D Unable to parse mapping file %

Ah, I needed that mapping file, it does not work without it. OK, let’s do it then.

% mkdir -p ~/.config/pass-git-helper % cat > ~/.config/pass-git-helper/git-pass-mapping.ini [*] Target=${host} ^D % pass-git-helper get protocol=https ^D password=git-password username=login: git-username %

Hmm, works, but the lead-in text login: for the username is not a good idea to be returned to Git. Problem: I have that in most of my pass records and the firefox plugin can cope with it pretty well. But that could be tweaked by an extension to the mapping.ini file based on my favorites: regular expressions.

% cat > ~/.config/pass-git-helper/git-pass-mapping.ini [DEFAULT] username_extractor=regex_search regex_username=^login: (.*)$ [*] target=${host} ^D % pass-git-helper get protocol=https ^D password=git-password username=git-username

Looks good to me. Now on to Git:

% git credential fill url= ^D # at this point, the normal 'enter username' dialog popped # up, which I cancelled error: unable to read askpass response from '/usr/lib/ssh/ssh-askpass' Username for '': ^C

Now it was just a matter to configure Git to use the new helper. This is done by setting the Git credential.helper option, which can be achieved with the following command executed in the top directory of the project:

git config credential.helper '!pass-git-helper $@' # test drive % git credential fill url= ^D protocol=https username=git-username password=git-password

Yeah! That’s it. Now I am prepared for the next git push to that repo.

The search engine btw, seems to have learned in the meantime: now when I enter my initial search arguments it presents pass-git-helper right away. Maybe other users benefit from this learning as well.

Testing for the Beta – help needed!

Thursday 26th of March 2020 09:05:14 PM

Kubuntu 20.04 Testing Week

The Kubuntu team is delighted to announce an ‘Ubuntu Testing Week’ from April 2nd to April 8th with other flavors in the Ubuntu family. April 2nd is the beta release of what will become Kubuntu 20.04 and during this week, there will be a freeze on changes to features, the user interface and documentation. Between April 2nd and final release on April 23rd, the Kubuntu team and community will focus on ISO testing, bug reporting, and fixing bugs. Please join the community by downloading the daily ISO image and trying it out, even beginning today.

QA tracker:

From this main page, click on the ‘Kubuntu Desktop amd64’ link to arrive at the testcases page. On the testcases page, you can download the ISO by clicking the ‘Link to the download information’ and report test results to the various test cases for Kubuntu. If you see other flavors needing testing on the main page, please test for them as well.

Chat live on IRC (#ubuntu-quality) or Telegram (UbuntuTesters: if you like, during this time of pandemic social distancing.

If you have no spare computer to use for testing, no problem! You can test without changing your system by running it in a VM (Virtual Machine) with software like Virtualbox, or running it in the live session from a USB or DVD, so you can also test if your hardware works correctly. We encourage those that are willing, to install it either in a VM or on physical hardware–requires at least 6GB of harddisk space–and use it continuously for a few days, as more bugs can be exposed and reported this way.

The easy way to report a bug is to open up Konsole by pressing alt+space and typing konsole or Menu > Konsole and then typing `ubuntu-bug packagename`, where packagename is the program or application where you experience the bug.

If you prefer working in the terminal, open the virtual console (terminal) by pressing control + alt + F2, 3, 4 etc. and typing `ubuntu-bug packagename`, where packagename is the program or application where you experience the bug. Control + Alt + F1 to return to your desktop. If a crash has landed you in the terminal, login with your usual user name and password, and report the bug as above.

Here is a nice youtube video showing the entire process, including one way to figure out what packagename is appropriate in GNOME:

Using ‘ubuntu-bug’ will automatically upload error logs and/or other files to Launchpad that developers need to fix the bug. By the way, the installer’s packagename is ubiquity. Experience tells us that is the most useful packagename to know for ISO testing when things go wrong with the installation. The live session software package is casper, should you encounter bugs affecting the live session itself, not programs. Other programs with bugs should be filed against their packages, for instance firefox, dolphin, vlc, etc. Only the bug *number* is needed when reporting the results of a test on the QA tracker.

Please test programs / applications that you regularly use, so you can identify bugs and regressions that should be reported. New ISO files are built every day; always test with the most up-to-date ISO. It is easier and faster to update an existing daily ISO with the command below (first right-click on the ISO’s folder in Dolphin and select ‘Open in Terminal’) or just open konsole or yakuake and `cd path-to-ISO-folder`. Zsync downloads only changes, so it’s very quick.
$ zsync

Plasma Bigscreen, la apuesta de KDE para conquistar los televisores

Thursday 26th of March 2020 07:37:44 PM

Al final se ha materializado y ha sido presentado al gran público Plasma Bigscreen, la apuesta de KDE para conquistar los televisores, esos aparatos que tenemos en casa , que en realidad son ordenadores con una gran pantalla y que tienen software privativo que no sabemos qué puede hacer.

Plasma Bigscreen, la apuesta de KDE para conquistar los televisores

La gran ventaja que tiene el Software Libre es que te da una seguridad de que tu privacidad está garantizada, cosa que no ocurre con otro tipo de Software. Muchos utilizamos en nuestro PC y en nuestro portátil sistemas GNU/Linux, que nos aportan confianza. Y suspiramos por tener smartphones y tabletas con GNU/Linux, pero poco nos preocupamos por una pieza que suele estar en nuestro salón, el televisor inteligente de 56 pulgadas.

Es por ello que la Comunidad KDE, cuyo lema es «Un mundo en el que todos tienen control sobre su vida digital y disfrutan de la libertad y la privacidad.» se ha fijado en este detalle y se ha puesto manos a la obra.

Fruto de este trabajo es el anuncio en la página de noticias de KDE (comúnmente conocido como dot) del proyecto Plasma Bigscreen,  la interfaz de la Comunidad KDE para televisores de gran pantalla.

En palabras de los desarrolladores:

«Plasma Bigscreen proporciona la interfaz de un ordenador monoplaca y utiliza el asistente de voz de la IA Mycroft para ofrecer una plataforma de TV inteligente. Plasma Bigscreen no sólo ofrecerá aplicaciones ricas en medios, sino también aplicaciones de escritorio tradicionales rediseñadas para adaptarse a la experiencia de Bigscreen.»

Toda una declaración de intenciones que se sustenta en sus grandes ventajas ya que Plasma Bigscreen:

  • Es Software Libre y Open Source.
  • Ofrece innovación ya que supone un reto de adaptación de las aplicaciones a una nueva forma de interaccionar con ellas.
  • Puede ser controlado por voz.
  • Es abierto y, por tanto, puede ser fácilmente ampliado con nuevas funcionalidades y aplicaciones.
  • Está soportada por la Comunidad KDE, garantía de calidad.

Plasma Bigscreen ya ha sido probado con una Raspberry Pi conectada a un TV por su entrada HDMI, lo cual significa que ya es una realidad ya que puede utilizarse en cualquier televisor actual. Y evidentemente, funciona con cualquier monitor, con lo que creo que pronto lo probaré en casa.

Más información: Plasma Bigscreen


Latte bug fix release 0.9.10

Thursday 26th of March 2020 12:00:00 PM

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

Go get  v0.9.10  from*

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


The new code that ignores ALL plasma popups has a side effect to ignore also KRunner and Yakuake. For v0.9.x unfortunately I can not add any workaround, for v0.10~ users this is already fixed.

  • dodge all windows, work properly after the dock becomes hidden and not show inappropriately when any window touches the dock
  • fix mask calculations for NO COMPOSITING environments
  • fix blur for Latte panels when exiting edit mode
  • protect LastActiveWindow application data updating in multi-screen environments and dont assign faulty application name and icons to irrelevant last active windows
  • fix right click context menu for Group plasmoid. Take note that Group plasmoid can only be used in Single Layout mode and NOT in Multiple Layouts mode. It is scheduled to be fixed in next major stable version
  • fix Indicators positioning when a Task is bouncing or requires attention
  • x11: smart way to ignore all plasma popups
  • wayland: smart way to ignore all plasma popups but first Plasma needs to update its popup flags in order to work correctly
  • support Chromium/Chrome audio channels for Tasks previews and context menu


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

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

Krita 4.2.9 Released

Thursday 26th of March 2020 10:38:40 AM

Today we’re finally releasing Krita 4.2.9! It’s been one of the most complicated releases we’ve ever attempted. When we updated the version of Python that’s embedded in Krita, scripting broke on Windows. When Apple updated its notarization protocol, building broke on macOS. And then we updated to a newer version of some of the libraries we build Krita on, and that broke all kinds of things. And then we needed to figure out a new way of packaging Krita for the Windows Store, which unfortunately broke our nice icons…

Krita 4.2.9 however is really stable after all the testing it had during the beta period. And there are even some new features to enjoy!

  • Dmitry improved the brush outline: it no longer flickers when you hover over the canvas:
  • He also added “Airbrush” and “Airbrush Rate” to the Color Smudge brush, and a new Ratio setting, also for the Color Smudge brush, which allows making the shape of the brush flatter using the different sensors. Ramón Miranda has even made a video demonstrating these features:
  • New contributor Saurabh Kumar added a “Split Layer into Selection Mask” feature:

As for the bugfixes… There are a lot of them, and this list isn’t even completely complete!

  • Fix transparency checkers looked white on HDR display bug 406698
  • Several fixes to file dialogs for overwriting and jpg files bug 412651
  • Fix Grow Selection expanding in one direction bug 414647
  • Fix crash using onion skins on non-animated layers bug 414668
  • Increase the limit in Layer Offset to 100k bug 414625
  • Fix crash opening .kra with incorrect clone source (related to bug 414699
  • Prevent crash on addition of color to deleted palette with colorpicker bug 413548
  • Make Add subbrush off on changing multibrush tool’s type from Copy Translate bug 415651
  • Improve rendering of predefined default Rect dab
  • Set the default location for restored files to QStandardPaths::PicturesLocation bug 415810
  • Don’t crash if remoteArguments is called when there isn’t a mainwindow bug 415794
  • On Android, default to TouchGesture for Kinetic Scrolling
  • Delay initialization of brush paintop widget state bug 415033
  • Reenable breeze: with the latest release, the bug with comboboxes has been fixed
  • Show the hand cursor if there is no colorize mask yet bug 415935
  • Fix logic for enabling/disabling options in stroke selection dialog bug 415896
  • ORA export, write entire layers instead of cropping them
  • Fix endless recursion when assigning a profile bug 414818
  • Fix a crash when cancelling Transform Tool action bug 414672
  • Fix an obviously wrong assert in the gradients bug 414550
  • Fix 1px brush offset in line tool bug 407405
  • Fix Layer Filter Combobox with Breeze theme bug 406595
  • Fix comparison of double spin box
  • Fix PaletteDocker not showing palettes bug 414890
  • Fix undo of replacing vector selection bug 412808
  • Separate krita log dialog from system information
  • Resource bundle: turn assert into check bug 399008
  • Fix the python Canvas.setRotation method bug 416126
  • Store and restore the geometry of the svg editor window bug 416097
  • Fix number of asserts with continued transform bug 415625
  • Fix Touch Docker save button not working on new files bug 407905
  • Fix blur Filter inconsistencies bug 416241
  • Fix border artifacts in layer styles bug 414582
  • Use Qt::Popup for color selectors popup widgets bug 410959
  • Always show color popup below the cursor bug 394139
  • Remove the strength compatibility with older paintop presets bug 416335
  • Fixed unneeded error message in Render Animation. bug 412599
  • Fix canvas offset calculation bug 416352
  • Layers with alpha channel disabled correctly export as “svg:src-atop” for ORA
  • Add icon to Close button of “About Krita” dialog box
  • Fix memory leak in preset history docker
  • Warn that Krita needs to be restarted after enabling/disabling plugins bug 416575
  • Workaround Qt 5.14’s colormanagement preventing png files from being saved bug 416515
  • Fixes with last used filter command. bug 416706
  • Fix Increase/Decrease Brush Size and Switch To Previous Preset buttons
  • Fix Warp and Cage transform in master bug 416505
  • Fix crazy snapping when resizing shapes bug 414336
  • Fix hiccups when doing canvas actions bug 414576, 415773
  • Fix animation rendering problem on small images (< 100px in size) bug 415367
  • Fix display of vector shapes when transformed with transform tool bug 417016
  • Fix hangup when loading image with generator/file layers bug 415891
  • Fix slowdown associated with the quick hide function of Shift+click on layer visibility icons
  • Fix canvas border color issue
  • Fix issue when saving preferences
  • Hide SubWindow decoration on macOS
  • A number of fixes with L*A*B* and CMYK thanks to L.E Segovia’s Season of KDE work
  • Android: Make it possible to select opengles
  • Set setRedirectPolicy as per discussion on KDE mailing lists
  • Fix crash when loading asl with tdta OSType
  • Make “Save Incremental Version” update recently used files
  • Correct logic for determining whether there are multiple backups requested bug 417914
  • Fix incorrect common curve in very old presets bug 417748
  • Fix layout issue in the history docker
  • Fix strobbing of the brush outline because of subpixel precision bug 374551
  • Make local selection outline visible on layer converted to selection mask
  • Fix freeze on vector layers bug 412746
  • Fix artifacts on filter masks applied to adjustment layers bug 417673
  • Fix ratio option on lower precision brushes
  • Fix opening Appimages bug 418230
  • Set image as modified after a legacy action (fix Channels docker not updating in some cases) bug 417992
Download Windows

If you’re using the portable zip files, just open the zip file in Explorer and drag the folder somewhere convenient, then double-click on the krita icon in the folder. This will not impact an installed version of Krita, though it will share your settings and custom resources with your regular installed version of Krita. For reporting crashes, also get the debug symbols folder.


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


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

Source code md5sum

For all downloads:


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

Support Krita

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

Plasma on TV: Presenting Plasma Bigscreen

Thursday 26th of March 2020 08:43:40 AM

Plasma Bigscreen main menu.

Plasma Bigscreen is KDE's user interface for big TV screens.

Plasma Bigscreen powers the interface on a Single Board Computer and uses the Mycroft AI voice assistant to provide a Smart TV platform. Plasma Bigscreen will deliver not only media-rich applications, but also traditional desktop applications redesigned to fit the Bigscreen experience.

Advantages of Plasma Bigscreen
  • Free (as in Freedom) and Open Source: One of the most important goals of this project is to hand control over to the people and the industry so they can build and power smart devices without the limits of other closed TV environments. Plasma Bigscreen is completely Free and Open Source and gives everyone the freedom to use, acquire, change and redistribute the software how they see fit. It also gives people the freedom to create, innovate and improve on top of the Plasma Bigscreen and share their work with the world.
  • Innovative: Plasma Bigscreen transforms the traditional plasma workspace experience into something that is controlled with a regular TV remote control. This is new territory for KDE interface designers and requires a new thinking of how to layout applications and how to make it easy for people to interact with Plasma from their couches.
  • Voice Control: Talking of interacting from the couch, voice control provides users with the ultimate comfort when it comes to TV viewing. But most big brands not only do not safeguard the privacy of their customers, but actively harvest their conversations even when they are not sending instructions to their TV sets. We use Mycroft's Open Source voice assistant to solve this problem.

    For the current beta img, the team connects to Mycroft's Home server, which by default uses Google's STT (Speech to text) which sends anonymized utterances to Google. This, of course, is not ideal, but being Open Source, you can switch out the back end and use whatever you want, even self-hosted systems like Mozilla Deepspeech. Or you can de-activate voice recognition altogether. Your choice.

    With Mycroft AI, the Bigscreen team intend to give users all the comfort of a smart voice controlled assistant with the advantages of the control over you privacy you can only achieve with Open Source software.

  • Easy to Expand: Mycroft's AI uses what are called "skills". Skills allow the assistant to learn about and perform different tasks. A weather skill, for example, lets Mycroft know about the weather and tell you what the day is going to be like; a cooking skill retrieves recipes and instructions and you can then ask Mycroft to help you make a delicious meal. There are already many skills in Mycroft's library and Mycroft AI's graphical framework for skills is built on top of Qt and Kirigami, two mature development frameworks. This allows third-party developers to use Python and QML to develop rich voice skills for the platform, which means features on KDE Bigscreen will multiply and provide even more functionalities to viewers.

    Simple settings make Bigscreen easy to tweak.

  • Community Supported: Plasma Bigscreen was created and is being maintained by KDE developers. KDE is one of the oldest, largest Free Software communities in existence and builds and maintains literally hundreds of projects, spanning from a full-featured desktop environments and development frameworks, to educational software and creativity apps. With the support of KDE, Plasma Bigscreen will develop quickly and grow to have as many features as users require.
Coming to a Screen Near You

The upcoming beta release for Plasma Bigscreen is already working on the Raspberry Pi 4. It's targeted to run on a TV screen, but will also work fine on a regular monitor.

The interface is largely designed to be easy to use with a remote control. There is experimental support for HDMI-CEC in the beta image, so anyone with a TV that supports HDMI-CEC can choose to use their TV remotes.

The YouTube app.

As one of the key features of Plasma Bigscreen is Mycroft's voice-controlled applications/skills, it's recommended to use a USB/Bluetooth remote with a microphone to try it out. Some recommended generic USB remotes are the WeChip G20 / W2 remote controls. It can also be used with a keyboard / mouse and any USB microphone.

For a more in-depth look at Plasma Bigscreen, check out Marco Marin's and Aditya Mehra's write ups on this new project.

Cosas que hacer con KDE estando encerrado en casa, próximo podcast de KDE España

Wednesday 25th of March 2020 04:50:29 PM

Me complace invitaros al próximo podcast en directo de KDE España que ha decidido titular de forma muy original y adecuada «Cosas que hacer con KDE estando encerrado en casa» y que se va a realizar el próximo 28 de marzo, a las 11:00, una forma de proponer ideas en estos tiempos de confinamiento.

Cosas que hacer con KDE estando encerrado en casa, próximo podcast de KDE España

Nos ha tocado vivir una pandemia, y la mejor forma de colaborar para que sea lo menos traumática para todos (teniendo en cuenta que lo más traumático es el dolor y la muerte) es quedarnos en casa.

Para algunos será motivo de aburrimiento y hastío (que os aseguro que no es mi caso) así que a los integrantes de KDE España se les ha ocurrido la idea de realizar un podcast titulado «Cosas que hacer con KDE estando encerrado en casa» en el que os daremos ideas para que se os pase el tiempo más rápido y de paso contribuyáis al desarrollo de Software Libre (si, los desarrolladores del Software Libre no son solo los programadores que hacen código).

Así que ya sabéis, estad atentos para escuchar en directo el próximo podcast de KDE España que emitiremos utilizando los servicios de Jitsi para reunir a los contertulios y los servicios de streaming de Youtube para poder transmitirlo en vivo.

¡Os esperamos el sábado 28 de marzo a las 11:00 CET!


Y no olvidéis que hoy tenéis otro podcast de altura con Yoyo Fernández, Paco Estrada, Juan Febles y Rubén Gómez a las 20:00 con el tema Linux y Teletrabajo.

Los podcast de KDE España

En un afán de acercarnos más a todos los simpatizantes de KDE hace un tiempo que empezamos a realizar podcast. En ellos varios miembros de la Comunidad KDE de España nos reunimos para hablar un poco de los diversos proyectos.

Hemos hablado de muchos temas como por ejemplo Akademy, KDE Connect, Plasma Mobile, Kirigami, KDE y el mundo empresarial y un largo etcétera de temas. Por supuesto, os animo a ayudarnos proponiendo temas en los comentarios de esta entrada, en el grupo de Telegram de Cañas y Bravas o en la sección especial en la web de bugs que hemos creado para la ocasión.

Podéis seguirnos en el canal de Youtube de KDE España o en Ivoox, donde estamos subiendo poco a poco los audios emitidos. Esperamos que os gusten.

Plasma Bigscreen – A Dive Into Mycroft Skills, Voice Applications & More

Wednesday 25th of March 2020 12:26:35 PM
A Plasma Bigscreen Beta Image For Raspberry Pi 4

In this blog post I would like take you through an introduction to Mycroft GUI Skills and Voice Applications technology on Plasma Bigscreen and showcase some of the interesting stuff I have been working on for the Plasma Bigscreen Project which are available on the beta image release for the Raspberry PI 4. This beta image show cases not only media-rich voice applications but also applications specialised to fit the Bigscreen experience all developed under an open process, more information on them in the sections below.

Plasma Bigscreen is the free open-source user interface experience for those big TV Screens, It consist of KDE Plasma technology powering the User Interface with Mycroft AI’s voice assistance technology packaged together on the image to provide a Smart TV platform and is based on KDE Neon.

The experience when sitting 10 feet away from your TV just isn’t complete without having the ease of access to control it and that’s exactly the space in which Mycroft AI the open-source voice assistant experience fits right in to provide you with that hands free easy interaction.

Discover Mycroft AI GUI Skills

Mycroft AI skills allow the assistant to learn and perform different tasks. A weather skill, for example, allows Mycroft to discover the weather and tell you what the weather on a day is going to be like; a cooking skill retrieves recipes and instructions and you can then ask Mycroft to help you make a delicious meal. There are already many voice skills available in the Mycroft skill repository that you can explore and more being quickly developed everyday.

Mycroft AI Date-Time Skill Mycroft AI Weather Skill

Mycroft AI’s graphical framework for skills is built on top of Qt and Kirigami, two mature development frameworks. This allows developers to use Python and QML to develop rich voice skills with graphical user interfaces for multiple platforms, Voice Applications featured on Plasma Bigscreen beta image are based on this combination of both voice and display technologies, where we expand Mycroft Skills with a GUI to also work as applications that can be controlled voice and physical key interaction.

A Look Into Voice Application

Voice can be a very powerful tool for interacting with applications, it can complement an application by reducing the number of actions required to execute a certain task by the user be it searching for a file or searching for music, simply asking an application for example to play a song can make things a lot simpler than opening an application, hitting the search tab / field, typing a song and hitting the play button.

Voice applications on the beta plasma bigscreen image are designed to be simple and powerful to use no matter what method is chosen to interact with them, let’s look at the Youtube Voice Application for instance.

The Youtube Voice Application is a GUI based skill for Mycroft AI, All of its logical functions are handled and called within its skill class, Adding a desktop entry and icon for the gui based skill is what partially turns the GUI skill into a Voice Application, the other bits include simply adding a landing page or the “homescreen” and registering it in the skill class using the gui event handler that is first presented to users when they execute the skill from the desktop entry, some more in-depth information on installation and this architecture can be read in the Voice Application Guidelines.

Simple Starting Point For Key Based Navigation in Mycroft Skills With A GUI Interface the “Homescreen”

The homescreen of a voice application can be considered the traditional equivalent of a home tab on a normal application, in the case of the Youtube Voice Application it consist of showing several categories of available videos, your recently watched history and search, It is presented to be navigable by simple arrow keys for selecting and browsing videos from the various video categories. The homescreen can be a simple page showcasing Mycroft Examples or as complex as the skill author requires the page to be as is the case above.

Youtube Voice App Homepage Youtube Voice App Search Page Simple Homepage With Skill Examples

The API documentation for developing Voice and GUI based skills and converting them to Voice Applications for Plasma Bigscreen is available on the following links below:

Aura Browser – Designed To Be Controlled By Just Your Remote Aura Browser

I would like to introduce you to the Aura Browser, It is a new browser based on QtWebEngine that I had the opportunity to work on for the Plasma Bigscreen beta image, It is completely designed to work with simple arrow key navigation that complements browsing the web with just a Remote Control without the requirement of a physical mouse. It features a virtual mouse controlled by arrow keys with auto scrolling, has support for tab based browsing, basic bookmarks and basic downloads and permission management.

This browser in its early stages but is available on the Plasma Bigscreen beta image release for the Raspberry Pi 4. The browser source can be found at:

Aura Browser Start Page Aura Browser – Website View With Virtual Mouse

Plasma Bigscreen

Wednesday 25th of March 2020 12:20:00 PM

Today I want to introduce a project I have been working on together (mostly in the background) with some colleagues of mine… Now with beta status reached, it’s time to more publicly talk about it: enter Plasma Bigscreen.

Smart TVs are becoming more and more complete computers, but unfortunately there the experience tends to be a tight walled garden between proprietary platform, services and privacy-infringing features. Features which are very cool, like voice control, but in order to not pose a threat to the user privacy should be on a free software stack and depending less on proprietary cloud platforms where possible.

Plasma BigScreen is a platform intended to use on smart TVs (trough a powerful enough small computing platform, such as the Raspberry Pi4, or any tiny computer if you need more power) with big remote-friendly UI controls, and Voice activation. What technology did we use for it? Plasma (of course!) and Mycroft.

Plasma Bigscreen main user interface

Plasma Bigscreen is an user interface for TVs providing a 10 foot UI for a smart TV experience (on TVs or any screen with an HDMI connection). It is a Plasma Shell, just like our beloved Plasma Desktop and Plasma Mobile.

It uses the familiar look and feel of Plasma but optimizes all the user interaction to be perfectly readable from the distance and controllable with ha simple basic remote control… from your couch.

Besides interaction with a remote control, it also supports a modern way of iteracting that is revolutionizing the UX on all kind of devices: voice interaction. Optionally, it can integrate seamlessy with Mycroft: an opensource project aimed to offer a completely free voice assistant.

Mycroft offers what are the so-called “skills”. Each skill, takes care of a particular voice interaction. there is an huge variety available, from the weather, do date/time and reminders, to online services clients such as soundcloud and Youtube, with comprehensive QML bindings to show a rich User Interface in a Plasma Environment.

We prepared a beta image for the Raspberry Pi4 for anyone to try, in which we pre-configured Plasma Bigscreen with Mycroft integration ready to go.

If you have a Raspberry Pi4, you can try this image immediately: you can find it here: just flash the file on a MicroSD and is ready to go on any Pi4.

Note that on that image, we point the device to the official Mycroft company’s “Mycroft Home” service, which internally uses the Google STT (Speech to text) which does use google but in a more anonymized fashion as this is not tied to your Google account (nor requires having one). Tough not ideal, it’s possible to configure the Mycroft core to use different services, even those you can self-host like Mozilla Deepspeech.

In here to emphasize voice controls, we prepared some skills (some preinstalled, some can come from the kde store) to fully show voice controls. In particular a Youtube client skill which is perfectly usable both from a remote control and voice only.

Youtube skill shipped in the image

As remote control, you can use the remote of your TV directly if it supports the CEC standard, or any of those remotes with an usb dongle which are “seen” as a keyboard with just few standard keys (some have also an integrated microphone, so giving voice commands is very easy).

In the next days, there will be more posts explaining the architecture and the technical choices we made, in the mean time, have a try and if you want to get in contact with us about the project, you can find directions here.

How do most KDE websites use the same theme?

Wednesday 25th of March 2020 11:50:00 AM
A unified theme? Why? Why not?

Nearly all KDE websites use a unified theme across the board. This is part of the consistency goal, chosen as a KDE goal at the last Akademy in Milano (Italy).

Using a unified theme has multiple advantages:

  • It strengthens KDE’s brand, since websites are more visible than applications or projects part of the KDE community. Websites with a unified look help visitors immediately identify an application or subproject as being part of a bigger organization.

  • It is easier to maintain only one theme and the tooling behind it than a theme for each project. We all wish Free and Open Source projects had unlimited budgets and manpower, but that is not realistic and maintaining a theme is not an easy task.

This doesn’t mean the KDE theme should be used for every KDE project, in fact, there are legitimate reasons not to. Sometimes an application under the KDE umbrella wants to create their own brand and does have the manpower and talent to design their own website. Krita is a good example here. The team has built a beautiful website that does not use the unified theme.

What theme does KDE use?

KDE is using the Aether theme. This is a theme designed and initially developed by Ken Vermette, the talented artist that is also behind most of the Plasma wallpapers and some interesting design concept like DWD.

This theme was originally based on one of the first Bootstrap 4 alpha version and later rebased on a stable Bootstrap 4 version. Using Bootstrap has its advantages and disadvantages.

The biggest advantage is that it has a large community and a lot of bootstrap themes exist for CMS and static site generators. It can be easily adapted to your specific needs without starting from scratch every time.

Another advantage is that Bootstrap is built using SASS and is designed to be extendable with tons of variables a developer can modify to globally change colors, layouts and a lot more. You can also specify the modules you want to use, and add your self-made components. For those interested in extending a Bootstrap theme, the official documentation is a great start. These capabilities were sadly not used when creating the Aether theme, but we are slowly moving to use more of the Bootstrap theming capabilities over time.

The problem with Boostrap is that, because it is so popular, in its default from it looks like a generic website without any personal identity. Changing only the colors won’t help to make your website more unique.

Building the websites

In KDE we use a lot of different web frameworks for our websites. Most of the applications websites are now using Jekyll or Hugo, but some are also using Wordpress, Drupal 7 and Drupal 8.

Jekyll has first-class support for creating a shared theme, so we created a Jekyll theme for KDE using the Aether theme that offers a lot of options. Here are two examples:

  • Should it display a Made By KDE logo? This is useful for application websites but shouldn’t appear on, for example, the KDE e.V. website.

  • Should it display a KDE logo or the application logo?

This allows for small customizations with only a few changes for each website without having to maintain different versions.

Some websites are using Hugo instead of Jekyll. The reason for this is that Hugo is faster when generating the webpages and has more advanced internationalization features included by default. The internationalization features are used for and the monthly application release announcements.

For my WIP replacement for the KDE Dot, I needed the performance of Hugo. With Jekyll, I gave up generating the website after 10 minutes, but with Hugo, it only took a few seconds to generate.

In the case of Content Management Systems, creating a theme is also well-supported but it isn’t as pleasant to do. I have a limited experience with Wordpress, but creating a theme was still possible and not too complicated. In the case of Drupal 7, creating a theme from scratch is almost impossible. It requires messing with a lot of PHP arrays and the security responsibility is on the side of the theme developer.

Deployment of the theme

To deploy the theme, I use Symfony Encore. Sympfony Encore is a webpack wrapper. I chose Symfony Encore because I’m very familiar with its PHP framework and I have been working with it since I was in high school (using Webpack alone would have been completely fine too).

Webpack is used to compile and optimize the SCSS and ECMAScript (aka JavaScript). After each commit to the master branch, a CI job compiles and deploys the compiled CSS and ECMAScript to a CDN host and the hosted CDN asset is then used by all the new KDE websites. This means that my changes are immediately propagated to all websites… or so I thought initially. In reality the CSS and JS files are cached for a long time and often visitors get an old version.

I’m solving this problem in two ways:

  • For dynamic websites: I also generate a versioned version of the assets and resolve the version in the backend. This is what I used in the MediaWiki plugin, for example.

  • For static websites: In this case, I can’t dynamically resolve the last version in the backend, so instead I add a GET parameter to the URL (e.g. main.css?v=10) and increase the number each time I fix a bug. This doesn’t happen often, so it is still easy to manage.

How you can help

We always need help with the websites, fixing papercuts, upgrading old websites to the new Jekyll/Hugo infrastructure, making sure information on the website is up-to-date, creating new beautiful home pages for your favorite projects and a lot more.

The Elisa maintainers are still looking for someone who wants to create a website and we created a junior job task for this. Maybe that someone could be you?

You can also join the web team through our Matrix channel, our IRC channel (#kde-www) or our Telegram channel.

welcome to heck: lessons learned from Ikona writing rust bindings to C++ the hard way

Wednesday 25th of March 2020 02:04:06 AM

rust is quite a neat language, isn't it? gigantic library ecosystem, memory safety, tons of developer-friendly tools in it. for Ikona, I decided to utilise this language, and instead of relying on binding generators that hide half the magic away from you, I wrote all bindings by hand.

rust –> C++ by hand: how?

obviously, rust and C++ are different programming languages and neither of them have language-level interop with each other. what they do both have is C. C—the lingua franca of the computing world. unfortunately, C is a very bad lingua franca. something as basic as passing arrays between programming languages becomes boilerplate hell fast. however, it is possible and once you set up a standardised method of passing arrays, it becomes far easier.

rust to C

so, in order to start going from rust to C++, you need to stop at C first. for Ikona, I put C API bindings in a separate crate in the same workspace. you have a few best friends when writing rust to C here: – #[no_mangle]: keeps rustc from mangling your symbols from pure C – unsafe: because C is ridiculously unsafe and Rust hates unsafety unless you tell it that you know what you're doing – extern "C": makes rust expose a C ABI that can be eaten by the C++ half – #[repr(C)]: tells rust to lay out the memory of a thing like C does – Box: pointer management – CString: char* management

memory management

Box and CString are your friends for memory management when talking to C. the general cycle looks like this:

pub unsafe extern "C" new_thing() -> *mut Type { Box::into_raw(thing) // for non-rustaceans, the lack of a semicolon means this is returned } pub unsafe extern "C" free_thing(ptr: *mut Type) { assert!(!ptr.is_null()); Box::from_raw(ptr); }

into_raw tells rust to let C have fun with the pointer for a while, so it won't free the memory. when C is done playing with the pointer, it returns it to Rust so it can from_raw the pointer to free the memory.


for Ikona, I didn't bother attempting to convert Rust structs into C structs, instead opting for opaque pointers, as they're a lot easier to deal with on the Rust side.

an average function for accessing a struct value in Ikona looks like this:

#[no_mangle] pub unsafe extern "C" fn ikona_theme_get_root_path(ptr: *const IconTheme) -> *mut c_char { assert!(!ptr.is_null()); // make sure we don't have a null pointer let theme = &*ptr; // grab a reference to the Rust value the pointer represents CString::new(theme.root_path.clone()).expect("Failed to create CString").into_raw() // return a char* from the field being accessed }

this is very similar to how calling methods on structs is bridged to C in Ikona.

#[no_mangle] pub unsafe extern "C" fn ikona_icon_extract_subicon_by_id( ptr: *mut Icon, id: *mut c_char, target_size: i32, ) -> *mut Icon { assert!(!ptr.is_null()); // gotta make sure our Icon isn't null assert!(!id.is_null()); // making sure our string isn't null let id_string = CStr::from_ptr(id).to_str().unwrap(); // convert the C string into a Rust string, and explicitly crash instead of having undefined behaviour if something goes wrong let icon = &*ptr; // grab a reference to the Rust object from the pointer // now let's call the method C wanted to call let proc = match icon.extract_subicon_by_id(id_string, target_size) { Ok(icon) => icon, Err(_) => return ptr::null_mut::<Icon>(), }; // make a new Box for the icon let boxed: Box<Icon> = Box::new(proc); // let C have fun with the pointer Box::into_raw(boxed) } enums

enums are very simple to bridge, given they aren't the fat enums Rust has. just declare them like this:

#[repr(C)] pub enum IkonaDirectoryType { Scalable, Threshold, Fixed, None }

and treat them as normal. no memory management shenanigans to be had here.

ABI? what about API?

C has header files, and we need to describe the C API for human usage.


since Ikona operates on opaque pointers, C just needs to be told that the type for a struct is a pointer.

typedef void* IkonaIcon; enums

enums are ridiculously easy.

#[repr(C)] pub enum IkonaDirectoryType { Scalable, Threshold, Fixed, None }


typedef enum { ScalableType, ThresholdType, FixedType, NoType, } IkonaDirectoryType;

not much to it, eh?


methods are the most boilerplate-y part of writing the header, but they're fairly easy. it's just keeping track of which rust thing corresponds to which C thing.

this declaration

pub unsafe extern "C" fn ikona_icon_new_from_path(in_path: *mut c_char) -> *mut Icon {


IkonaIcon ikona_icon_new_from_path(const char* in_path); C to C++

once a C API is done being written, you can consume it from C++. you can either write a wrapper class to hide the ugly C or consume it directly. here in the KDE world where the wild Qt run free, you can use smart pointers and simple conversion methods to wrangle with the C types.


the big advantage for Ikona here is the library ecosystem for Rust. librsvg and resvg are both Rust SVG projects that Ikona can utilise, and both are better in many ways compared to the simplistic SVG machinery available from Qt. heck, resvg starts to near browser-grade SVG handling with a huge array of things to do to SVGs as well as general compatibility. Ikona barely taps into the potential of the Rust world currently, but future updates will leverage the boilerplate laid in 1.0 in order to implement new features that take advantage of the vibrant array, high performance, and fast speed of available Rust libraries.

what I would have done differently

writing a bunch of rust to C boilerplate isn't fun, especially with arrays. since glib-rs is already in the dependency chain of Ikona, I should have utilized the GList instead of writing my own list implementation.

tags: #libre

Season of KDE, 2020

Wednesday 25th of March 2020 12:00:00 AM

Finally, I am going to write about my experience as a student of Season of KDE 2020. A winter learning new things, learning what matters is not just writing code but writing good code. I would like to thank GCompris and KDE for giving me such an opportunity to be a part of the community and to try to bring happiness to people and kids using it around the world.

I had to complete the following tasks during this period:

  1. Improve multiple datasets of clock game activity.
  2. Add multiple datasets to balance scales.
  3. Add multiple datasets to balance scale with kgs.
  4. Add multiple datasets to balance scales with ounce.

Since few weeks are still left for SoK to come to an end. Till now, I have completed the following tasks:

  1. Implemented new multiple datasets to clock game activity which got merged to the multiple_dataset branch.
  2. Added multiple datasets to balance scales activity which is under review by the mentors.
  3. Added multiple datasets to balance scales with kgs activity which is under review by the mentors.
Clockgame Activity:

I started my work on this activity. The goal of this activity is to teach a child how to see the clock. Initially, this activity contains dataset only with two different level selections. I have added the multiple dataset to this activity with 5 different level selections to better fit to the french school learning programs.

I have also added a OK button to check the answer. Finally, the datasets has been merged to multiple_dataset branch.

Balance scales activity:

This activity goal is to teach the child about the arithemetic calculation by balancing the scales of different weights. The balance scales activity has 3 sub activities as mentioned above:

  1. Adding multiple datasets to balance scales.
  2. Adding multiple datasets to balance scales with kgs.
  3. Adding multiple datasets to balance scales with ounce.

I have added multiple datasets to balance scales and balance scales with kgs which is under review by the mentors.

I am left with the following work which I would complete in the coming weeks.

  1. To add multiple datasets to balance scale with ounce.
  2. Test the activities on a different platforms.

I am thankful to my mentor Johnny Jazeix and Emmanuel Charruau for giving me this opportunity and helping me always during the SoK period. I have learned a lot of things during this period and have a great learning experience as of development coding. I am looking forward to add multiple datasets to other activities after the end of the SoK period.

Deepak Kumar !!!

Season of KDE Final Report, 2020

Wednesday 25th of March 2020 12:00:00 AM

SoK ended finally on 17th February 2020. I am happy to share that I have completed the project “Add multiple datasets to several activities” and passed the final evaluation!!!

I was left with some work to complete as:

  1. To implement multiple datasets to balance scale with ounce.
  2. Test the activities on a different platform.

As now I have implemented datasets to all of the activities as mentioned in my proposal.

As these activities teach the child arthmetic operations by balancing the scales using pounds or ounce. So, I have added the datasets with five different configurations.

What after SoK ???

The day I started contributing to this project I have faced a lot of difficulty in the beginning as this was one of my first open source to which I have contributed. But now I am familiar with all of the concepts, principles, and codebase of GCompris. I am looking forward to adding multiple datasets to other activities and add a new activity “Garbage Recycle” to GCompris.

Once again a big thanks to all of my mentors Johnny, Emmanuel, Timothee for all of their help and support. I would also like to thanks the KDE community for conducting such a great program every year.

Deepak Kumar !!!

Linux y teletrabajo, podcast especial el 25 de marzo

Tuesday 24th of March 2020 05:42:42 PM

En estos tiempos de confinamiento están apareciendo muchas iniciativas para que el tiempo pase algo más rápido. De esta forma, el gran Rubén ha reunido a la flor y nata del mundo del poscasting linuxero (aunque uno de ellos no se considere así) y van a realizar una charla distenida cuyo tema principal será Linux y teletrabajo, un tema candente en estos momentos.

Linux y teletrabajo, podcast especial el 25 de marzo

El número de teletrabajadores ha experimentado un aumento considerable estos días por razones más que obvias. Oficinistas, profesores, presentadores de radio y televisión, administrativos y muchos otros, se han tenido que preparar su estudio de realización en casa e intentar sus labores desde casa.

Decenas de aplicaciones online están siendo promocionadas, explicadas, utilizadas y, porqué no decirlo, sobresaturadas debido al gran incremento de uso que están sufriendo, y entre estas, existen muchas que son de código libre excelentes y capaces de realizar la mayoría de las funciones.

Este apasionante tema, Linux y teletrabajo, será justo el que será tratado a fondo este miércoles 25 a las 20:00 horas CES con cuatro de los podcasters más conocidos dentro del mundo GNU/Linux: Paco Estrada (de Compilando Podcast), Juan Febles (de Podcast Linux), Yoyo Fernández (de Salmorejo Geek) y Rubén Gómez (de KDE España). Os recomiendo esta entrevista del 2018 si no conocéis a los tres primeros.

En un principio, a lo largo de una hora hablarán de las alternativas libres (y es posible que se cuele alguna privada) que tenemos para poder realizar las tareas encomendadas o voluntarias que vamos a realizar en nuestra casa durante el tiempo en le que estemos confinados.

En esta ocasión, será emitido en directo por el canal de youtube de KDE España  (que pondré mañana) y Spreaker de Yoyo Fernández (

Un acontecimiento que, si pudiera, no me lo perdería. No perdáis la ocasión.



foss-north – or doing many things at once

Tuesday 24th of March 2020 02:39:46 PM

When placing this year’s foss-north event over a quarter break I knew that I would be busy both at work and at the conference. Little did I know what was beyond the horizon ;-)

As a consequence of the COVID-19 situation, the event has to be converted from a physical meeting to a virtual event. This means many things to an organizer: renegotiating all sponsorship contracts, renegotiating with the physical venue, setting up the infrastructure for a virtual event, rescheduling all speakers, and so on.

We at foss-north are lucky. All sponsors continue to stay with us and the venue was very cooperative when it came to rescheduling the event.

I have started to document our virtual conference setup so that other conferences in the same situation can learn. Pull requests are welcome!

This Sunday we decided to stress test the infrastructure by running the lightning talks. This is a good test case, as it involves a maximum number of speaker transitions, as well as more frequent QA sessions. From an organizer perspective, this is really like running a full day of the conference in 90 minutes.

I’m happy to tell you that the talks went well! You find them below. Following the links you find slides as well as recordings of the sessions.

Develop better software with usability testing by Andreas Nilsson Running Android on the Raspberry Pi by Chris Simmonds The Yocto Project 10 minute quick-start guide by Ron Munitz Getting started with your smart, connected, vehicle project by Dimitris Platis Seven years in Tibet^W^Wat Home by Kristoffer Grönlund Linux on RISC-V by Drew Fustini Singularity container platform by Anders Björklund

We’ve also been able to get most of the conference schedule in place and just have a few rough edges to fix before the big event. I am extremely pleased with how this has turned out. We still have a stellar speaker setup and I hope that you will all join in and watch the streams. The event is free for all and open to all and runs from March 29 – April 1.

Interview with Anilia

Tuesday 24th of March 2020 11:48:23 AM

Could you tell us something about yourself?

I’m Anilia, a freelance illustrator. I’m cooperating with many authors from all around the world. The key part of my job is to transform authors’ visions into shapes, forms, emotions and characters on drawings. Thanks to that global cooperation, many fantastic stories were published.

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

At first digital painting was my hobby but shortly it became my full time job and one of most important parts of my life.

What genre(s) do you work in?

Mainly I make illustrations and character designs and portraits.

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

David Revoy. I’m constantly getting back to his works and trying to learn new stuff from him.

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

I bought my first tablet while I was still studying at Silesian University of Technology, so a few years ago…

What makes you choose digital over traditional painting?

Digital painting offer so much more for artist! When you have basic knowledge about the technical side of digital painting, you can do almost everything with your piece. You can transform everything, add or cut elements if you like. This technique gives you unlimited options of change for every element of your drawing. Digital painting allows you to control every part of your work, that’s fantastic.

How did you find out about Krita?

From internet search. I was searching for a better solution than Gimp and Photoshop.

What was your first impression?

Amazing! When I first opened Krita I thought – This is exactly what I need, that’s my perfect tool.

What do you love about Krita?

Everything, but the most important thing is that Krita gives me exactly what I need for digital painting. I have all necessary tools in one place and those tools works perfectly with my tablet. I don’t need to spend hours to customize the program and search for options.

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

Elements that are not related to painting – I still use a second program to add text, edit vector elements and export my works to pdf files.

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

Functionality. Krita works perfectly with my tablet. The float of the brush is fantastic. I just need to pick a tool and it works exactly like it should. Additional I have many useful tools designed for drawing (reference images, painting assistant, blending options, etc.). I feel that someone really knew what is important when you draw and designed every tool perfectly.

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

That question is very hard. I usually like my last painting but I always have in mind some improvements… I’m constantly learning so with every piece I have a new idea how to make it better.

What techniques and brushes did you use in it?

I usually use David Revoy brushes (basic set in Krita) and lately I use hard light blending mode to add shadows and then I only correct painting with a final layer.

Where can people see more of your work?

My portfolio:


Anything else you’d like to share?

Krita is a fantastic tool for digital drawing and painting. My work developed with this program. If you are a beginner – try Krita, it will open for you a fantastic world of digital art. If you are painting professionally – try Krita, your work will be so much easier.

Debugging and Profiling Qt 3D applications

Tuesday 24th of March 2020 10:00:53 AM

Qt 3D, being a retained mode high level graphic API abstraction, tries to hide most of the details involved in rendering the data provided by applications. It makes a lot of decisions and operations in the background in order to get pixels on the screen. But, because Qt 3D also has very rich API, developers can have a lot of control on the rendering by manipulating the scene graph and, more importantly, the frame graph. It is however sometimes difficult to understand how various operations affect performance.

In this article, we look at some of the tools, both old and new, that can be used to investigate what Qt 3D is doing in the back end and get some insight into what is going on during the frame.


Built in Profiling

The first step in handling performance issues is, of course, measuring where time is spent. This can be as simple as measuring how long it took to render a given frame. But to make sense of these numbers, it helps to have a notion of how complex the scene is.

In order to provide measurable information, Qt 3D introduces a visual overlay that will render details of the scene, constantly updated in real time.


The overlay shows some real time data:

  • Time to render last frame and FPS (frames per second), averaged and plotted over last few seconds. As Qt 3D is by default locking to VSync, this should not exceed 60fps on most configurations.
  • Number of Jobs: these are the tasks that Qt 3D executes on every frame. The number of jobs may vary depending on changes in the scene graph, whether animations are active, etc.
  • Number of Render Views: this matches loosely to render pass, see below discussion on the frame graph.
  • Number of Commands: this is total number of draw calls (and compute calls) in the frame.
  • Number of Vertices and Primitives (triangles, lines and points combined).
  • Number of Entities, Geometries and Textures in the scene graph. For the last two, the overlay will also show the number of geometries and textures that are effectively in use in the frame.

As seen in the screen shots above, the scene graph contains two entities, each with one geometry. This will produce two draw calls when both objects are in frame. But as the sphere rotates out of the screen, you can see the effect of the view frustum culling job which is making sure the sphere doesn’t get rendered, leaving a single draw call for the torus.

This overlay can be enabled by setting the showDebugOverlay property of the QForwardRenderer to true.


Understanding Rendering Steps

To make sense of the numbers above, it helps to understand the details of the scene graph and frame graph.

In the simple case, as in the screen shots, an entity will have a geometry (and material, maybe a transform). But many entities may share the same geometry (a good thing if appropriate!). Also, entities may not have any geometry but just be used for grouping and positioning purposes.

So keeping an eye on the number of entities and geometries, and seeing how that effects the number of commands (or draw calls), is valuable. If you find one geometry drawn one thousand times in a thousand separate entities, if may be a good indication that you should refactor your scene to use instanced rendering.

In order to provide more details, the overlay has a number of buttons that can be used to dump the current state of the rendering data.

For a deeper understanding of this, you might consider our full Qt 3D Training course.

Scene Graph

Dumping the scene graph will print data to the console, like this:

Qt3DCore::Quick::Quick3DEntity{1} [ Qt3DRender::QRenderSettings{2}, Qt3DInput::QInputSettings{12} ] Qt3DRender::QCamera{13} [ Qt3DRender::QCameraLens{14}, Qt3DCore::QTransform{15} ] Qt3DExtras::QOrbitCameraController{16} [ Qt3DLogic::QFrameAction{47}, Qt3DInput::QLogicalDevice{46} ] Qt3DCore::Quick::Quick3DEntity{75} [ Qt3DExtras::QTorusMesh{65}, Qt3DExtras::QPhongMaterial{48}, Qt3DCore::QTransform{74} ] Qt3DCore::Quick::Quick3DEntity{86} [ Qt3DExtras::QSphereMesh{76}, Qt3DExtras::QPhongMaterial{48}, Qt3DCore::QTransform_QML_0{85} ]

This prints the hierarchy of entities and for each of them lists all the components. The id (in curly brackets) can be used to identify shared components.

Frame Graph

Similar data can be dumped to the console to show the active frame graph:

Qt3DExtras::QForwardRenderer Qt3DRender::QRenderSurfaceSelector Qt3DRender::QViewport Qt3DRender::QCameraSelector Qt3DRender::QClearBuffers Qt3DRender::QFrustumCulling Qt3DRender::QDebugOverlay

This is the default forward renderer frame graph that comes with Qt 3D Extras.

As you can see, one of the nodes in that graph is of type QDebugOverlay. If you build your own frame graph, you can use an instance of that node to control which surface the overlay will be rendered onto. Only one branch of the frame graph may contain a debug node. If the node is enabled, then the overlay will be rendered for that branch.

The frame graph above is one of the simplest you can build. They may get more complicated as you build effects into your rendering. Here’s an example of a Kuesa frame graph:

Kuesa::PostFXListExtension Qt3DRender::QViewport Qt3DRender::QClearBuffers Qt3DRender::QNoDraw Qt3DRender::QFrameGraphNode (KuesaMainScene) Qt3DRender::QLayerFilter Qt3DRender::QRenderTargetSelector Qt3DRender::QClearBuffers Qt3DRender::QNoDraw Qt3DRender::QCameraSelector Qt3DRender::QFrustumCulling Qt3DRender::QTechniqueFilter Kuesa::OpaqueRenderStage (KuesaOpaqueRenderStage) Qt3DRender::QRenderStateSet Qt3DRender::QSortPolicy Qt3DRender::QTechniqueFilter Kuesa::OpaqueRenderStage (KuesaOpaqueRenderStage) Qt3DRender::QRenderStateSet Qt3DRender::QSortPolicy Qt3DRender::QFrustumCulling Qt3DRender::QTechniqueFilter Kuesa::TransparentRenderStage (KuesaTransparentRenderStage) Qt3DRender::QRenderStateSet Qt3DRender::QSortPolicy Qt3DRender::QTechniqueFilter Kuesa::TransparentRenderStage (KuesaTransparentRenderStage) Qt3DRender::QRenderStateSet Qt3DRender::QSortPolicy Qt3DRender::QBlitFramebuffer Qt3DRender::QNoDraw Qt3DRender::QFrameGraphNode (KuesaPostProcessingEffects) Qt3DRender::QDebugOverlay Qt3DRender::QRenderStateSet (ToneMappingAndGammaCorrectionEffect) Qt3DRender::QLayerFilter Qt3DRender::QRenderPassFilter

If you are not familiar with the frame graph, it is important to understand that each path (from root to leaf) will represent a render pass. So the simple forward renderer will represent a simple render pass, but the Kuesa frame graph above contains eight passes!

It is therefore often easier to look at the frame graph in term of those paths. This can also be dumped to the console:

[ Kuesa::PostFXListExtension, Qt3DRender::QViewport, Qt3DRender::QClearBuffers, Qt3DRender::QNoDraw ] [ Kuesa::PostFXListExtension, Qt3DRender::QViewport, Qt3DRender::QFrameGraphNode (KuesaMainScene), Qt3DRender::QLayerFilter, Qt3DRender::QRenderTargetSelector, Qt3DRender::QClearBuffers, Qt3DRender::QNoDraw ] [ Kuesa::PostFXListExtension, Qt3DRender::QViewport, Qt3DRender::QFrameGraphNode (KuesaMainScene), Qt3DRender::QLayerFilter, Qt3DRender::QRenderTargetSelector, Qt3DRender::QCameraSelector, Qt3DRender::QFrustumCulling, Qt3DRender::QTechniqueFilter, Kuesa::OpaqueRenderStage (KuesaOpaqueRenderStage), Qt3DRender::QRenderStateSet, Qt3DRender::QSortPolicy ] [ Kuesa::PostFXListExtension, Qt3DRender::QViewport, Qt3DRender::QFrameGraphNode (KuesaMainScene), Qt3DRender::QLayerFilter, Qt3DRender::QRenderTargetSelector, Qt3DRender::QCameraSelector, Qt3DRender::QTechniqueFilter, Kuesa::OpaqueRenderStage (KuesaOpaqueRenderStage), Qt3DRender::QRenderStateSet, Qt3DRender::QSortPolicy ] [ Kuesa::PostFXListExtension, Qt3DRender::QViewport, Qt3DRender::QFrameGraphNode (KuesaMainScene), Qt3DRender::QLayerFilter, Qt3DRender::QRenderTargetSelector, Qt3DRender::QCameraSelector, Qt3DRender::QFrustumCulling, Qt3DRender::QTechniqueFilter, Kuesa::TransparentRenderStage (KuesaTransparentRenderStage), Qt3DRender::QRenderStateSet, Qt3DRender::QSortPolicy ] [ Kuesa::PostFXListExtension, Qt3DRender::QViewport, Qt3DRender::QFrameGraphNode (KuesaMainScene), Qt3DRender::QLayerFilter, Qt3DRender::QRenderTargetSelector, Qt3DRender::QCameraSelector, Qt3DRender::QTechniqueFilter, Kuesa::TransparentRenderStage (KuesaTransparentRenderStage), Qt3DRender::QRenderStateSet, Qt3DRender::QSortPolicy ] [ Kuesa::PostFXListExtension, Qt3DRender::QViewport, Qt3DRender::QFrameGraphNode (KuesaMainScene), Qt3DRender::QLayerFilter, Qt3DRender::QRenderTargetSelector, Qt3DRender::QBlitFramebuffer, Qt3DRender::QNoDraw ]

Hopefully this is a good way of finding out issues you may have when building your custom frame graph.

Draw Commands

On every pass of the frame graph, Qt 3D will traverse the scene graph, find entities that need to be rendered, and for each of them, issue a draw call. The number of objects drawn in each pass may vary, depending on whether the entities and all of their components are enabled or not, or whether entities get filtered out by using QLayers (different passes may draw different portions of the scene graph).

The new profiling overlay also gives you access to the actual draw calls.

So in this simple example, you can see that two draw calls are made, both for indexed triangles. You can also see some details about the render target, such as the viewport, the surface size, etc.

That information can also be dumped to the console which makes it easier to search in a text editor.


Built in Job Tracing

The data above provides a useful real time view on what is actually being processed to render a particular frame. However, it doesn’t provide much feedback as to how long certain operations take and how that changes during the runtime of the application.

In order to track such information, you need to enable tracing.

Tracing tracks, for each frame, what jobs are executed by Qt 3D’s backend. Jobs involve updating global transformations and the bounding volume hierarchy, finding objects in the view frustum, layer filtering, picking, input handling, animating, etc. Some jobs run every frame, some only run when internal state needs updating.

If your application is slow, it may be because jobs are taking a lot of time to complete. But how do you find out which jobs take up all the time?

Qt 3D has had tracing built in since a few years already, but it was hard to get to. You needed to do your own build of Qt 3D and enable tracing when running qmake. From thereon, every single run of an application linked against that build of Qt 3D would generate a trace file.

In 5.15, tracing is always available. It can be enabled in two ways:

  • By setting the QT3D_TRACE_ENABLED environment variable before the application starts (or at least before the aspect engine is created). This means the tracing will happen for the entire run of the application.
  • If you’re interested in tracing for a specific part of your application’s life time, you can enable the overlay and toggle tracing on and off using the check for Jobs. In this case, a new trace file will be generated every time the tracing is enabled.

For every tracing session, Qt 3D will generate one file in the current working directory. So how do you inspect the content of that file?

KDAB provides a visualisation tool but it is not currently shipped with Qt 3D. You can get the source and build it from GitHub here. Because jobs change from one version of Qt 3D to the next, you need to take care to configure which version was used to generate the trace files. Using that tool, you can open the trace files. It will render a time line of all the jobs that were executed for every frame.

In the example above, you can see roughly two frames worth of data, with jobs executed on a thread pool. You can see the longer running jobs, in this case:

  • RenderViewBuilder jobs, which create all the render views, one for each branch in the frame graph. You can see some of them take much longer that others.
  • FrameSubmissionPart1 and FrameSubmissionPart2 which contain the actual draw calls.

Of course, you need to spend some time understanding what Qt 3D is doing internally to make sense of that data. As with most performance monitoring tools, it’s worth spending the time experimenting with this and seeing what gets affected by changes you make to your scene graph or frame graph.

Job Dependencies

Another important source of information when analysing performance of jobs is looking at the dependencies. This is mostly useful for developers of Qt 3D aspects.

Using the profiling overlay, you can now dump the dependency graph in GraphViz dot format.

Other Tools Static capabilities

Qt 3D 5.15 introduces QRenderCapabilities which can be used to make runtime decisions based on the actual capabilities of the hardware the application is running on. The class supports a number of properties which report information such as the graphics API in use, the card vendor, the supported versions of OpenGL and GLSL. It also has information related to the maximum number of samples for MSAA, maximum texture size, if UBOs and SSBOs are supported and what their maximum size is, etc.

Third Party Tools

Of course, using more generic performance tools is also a good idea.

perf can be used for general tracing, giving you insight where time is spent, both for Qt 3D and for the rest of your application. Use it in combination with KDAB’s very own hotspot to get powerful visualisation of the critical paths in the code.

Using the flame graph, as show above (captured on an embedded board), you can usually spot the two main sections of Qt 3D work, the job processing and the actual rendering.

Other useful tools are the OpenGL trace capture applications, either the generic ones such as apitrace and renderdoc, or the ones provided your hardware manufacturer, such as nVidia or AMD.



We hope this article will help you get more performance out of your Qt 3D applications. The tools, old and new, should be very valuable to help find bottlenecks and see the impact of changes you make to your scene graph or frame graph. Furthermore, improvements regarding performance are in the works for Qt 6, so watch this space!

About KDAB

If you like this blog and want to read similar articles, consider subscribing via our RSS feed.

Subscribe to KDAB TV for similar informative short video content.

KDAB provides market leading software consulting and development services and training in Qt, C++ and 3D/OpenGL. Contact us.

The post Debugging and Profiling Qt 3D applications appeared first on KDAB.

More in Tux Machines

Between Two Releases of Ubuntu 20.04 and Fedora 32

Both Ubuntu Focal Fossa and Fedora 32 released in the same time April this year. They are two operating systems from different families namely Debian and Red Hat. One of their most interesting things in common is the arrival of computer companies like Dell and Star Labs (and Lenovo's coming) that sell special preinstalled laptops and PCs. I make this summary to remind myself and inform you all growth of these great operating systems. Enjoy! Read more

Android Leftovers

LibreOffice: 7.0 Testing, Simulated Animation Effects (GSoC), Pareto Charts

  • LibreOffice 7.0 RC1 Bug Hunting Session

    LibreOffice 7.0 is being developed by our worldwide community, and is due to be released in early August 2020 – see the release notes describing the new features here. In order to find, report and triage bugs, the LibreOffice QA team is organizing the second Bug Hunting Session for LibreOffice 7.0 on Monday July 6, 2020. Tests will be performed on the first Release Candidate version, which will be available on the pre-releases server the day of the event. Builds will be available for Linux (DEB and RPM), macOS and Windows.

  • Simulated Animation Effects Week#4

    After getting simulated animation effects somewhat a presentable state in week 3 on my experimental branch, this week my goal was to make them saveable. Since I wanted them to be saveable on SMIL hierarchies, like the rest of the animations, I’ve started by creating new xml tokens that’ll be used and named them “motion-simulated” and “animateSimulation”. Made required connections for importing/exporting these animation effects mimicking how path motion is imported/exported. Later created a new animation preset on Effects.xcu for testing purposes and called it arbitarily “Simulated Basic”. And lastly, connected stuff with animation effects panel creating a new category there for simulated animations.

  • How to Create a Pareto Diagram [80/20 Rule] in LibreOffice Calc

    In this LibreOffice tip, you’ll learn to create the famous Pareto chart in Calc.

Arc Menu 47, Popular Gnome Extension Released With New Layout

Arc Menu 47, Popular Gnome Extension Released With New Layout Arc Menu v47 with a new menu layout called “Tognee” is now available for the download. Arc Menu is a Gnome shell extension designed to replace the standard menu found in Gnome 3. “Flip Layout Horizontally” and “Searchbar Location” options is now available in traditional panel layouts. Read more