Subscribe to Planet KDE feed
Planet KDE -
Updated: 1 min 15 sec ago

CppCon Special Report

6 hours 9 min ago

KDAB has long supported the C++ community, as C++ is the backbone of Qt and up-to-date knowledge of its changes keeps us on the leading edge in the Qt world.

Later this year we shall be supporting Europe’s Meeting C++ in Berlin, but now that this year’s talks have been released we felt it was time for a Special Report on CppCon which ran from September 17th-23rd this autumn in Bellevue, WA.

KDAB’s Kévin Ottens was on the program committee and reviewed the talks at this year’s show, while Giuseppe D’Angelo (Peppe) contributed a day’s training on Programming with Qt Widgets, and two Lightning Talks on Qt (see them here and here), as well as attending the rest of the event.

We asked Kévin and Peppe to list their top three talks so we could get the insider as well as the attendee perspective. This is what they gave us:

Kévin’s top three

1. C++ on the Web: Let’s have some serious fun (Video)

  • “Shows that C++ is very versatile and can be used even in the trendy web field unlike what most engineers assume.”

2. Iterator Haiku, Casey Carter (Video)

  • “Because iterators in general reduce opportunities of errors in your code, and it will become even better with the ranges.”

3. How to test static_assert? (Video)

  • “I love static_assert to catch mistakes and wrong assumptions even earlier in the development process, but I also want my code to be tested as much as possible. As the title implies, it’s a perfect match.”

Peppe’s top three

1. Lifetime Safety… By Default: Making Code Leak-Free by Construction (Video)

  • “It was the keynote by Herb Sutter. Great speaker and great content.”

2. What C++ Programmers Need to Know about Header <random> (Video)

  • “Because everyone has a program that needs a random integer between 1 and 42 and does it wrong. <random> does it right.”

3. My Little Optimizer: Undefined Behavior is Magic (Video)

  • “In case you were looking for arguments why you should never ever ever ever trigger undefined behavior: compilers see your bluffs and do terrible things.”

You can see Giuseppe’s blog post about CppCon here.

The post CppCon Special Report appeared first on KDAB.

Akonadi EWS Resource – first bugfix release

Wed, 2016/10/26 - 10:10pm

In the initial release announcement I have promised to focus on calendar support. Unfortunately I haven’t had that much time for development as I initially anticipated. In the meantime some early adopters have uncovered a number of issues that have since been fixed. In order to deliver those fixes I have decided to issue a bugfix release (0.8.1).

This release doesn’t bring any significant new features to the Akonadi EWS Resource. The most important changes include:

  • Improved collection tree retrieval:
    • Fixed full collection tree synchronisation for some servers (bug #2).
    • Fixed incremental collection tree synchronisation.
    • Reduced the number of full collection tree retrievals by keeping the state persistent.
  • Fixed Qt 5.7 compatibility
  • Fixed crash upon encountering a distribution list item (bug #7).
  • Improved behaviour in case of temporary server connection loss.
  • Added option to customise User Agent string sent to the server.
  • Added option to enable NTLMv2 authentication.
  • Allow specifying an empty domain name (bug #3). Requires KF 5.28 to have any effect.
  • Fixed dates when copying items from other resources to the Sent Items folder (bug #5).
  • Improved batch item retrieval performance (will be effective with KDE Applications 16.12).
  • Add synchronisation of collection tree upon connection. Fixes empty collection tree after adding a new resource until a manual mail fetch is triggered (bug #15).

As promised before I intend to focus on calendar support and hope to get it running in the next release.

digiKam Recipes 5.0.1 Released and digiKam AppImage Package Coming

Wed, 2016/10/26 - 7:29pm

Hot on the heels of the major digiKam 5.x.x release comes a thoroughly revised version of the digiKam Recipes book. Although it doesn’t include any new material, the entire content and all screenshots have been revised and updated to reflect changes in the latest version of digiKam. In addition to that, some obsolete content has been removed. But a shiny new book cover featuring catchy colors makes up for that.

Speaking of digiKam releases, the upcoming version 5.3.0 will be available as an AppImage 64-bit package. Continue reading

Global Menu’s Returning!

Wed, 2016/10/26 - 5:11pm

Application Menu PlasmoidApplication Menu Plasmoid

With Plasma 5.8 LTS out the door it’s time to look ahead at future Plasma releases. In our first long term support release we introduced “modifier only shortcuts” that allow you to open the application launcher with just the Meta key. Judging from feedback on the Internet this is one of the best features introduced in all of KDE’s history ;) I was quite surprised to find that the global menu is a close second.

Global Menu in Qt 5.7

Since Qt 5.7, thanks to Dmitry Shachnev, QGenericUnixTheme out of the box supports exporting a QMenuBar over DBus and registering it to the com.canonical.AppMenu.Registrar. When I updated to said version I was disappointed that it didn’t “just work”. The reason being that Plasma ships its own Qt Platform Theme that is responsible for enforcing Plasma look and feel settings on Qt applications as well as providing the file dialog. We do this by inheriting from QPlatformTheme which isn’t the aforementioned unix theme, which is private. Since the Plasma-Integration repository is bound to a specific Qt version already anyway, I now use private Qt imports to get hold of the unix theme so we don’t need to re-implement all of that logic, which was the reason I waited for Qt 5.7 for all of this.

What about Wayland?

The global menu infrastructure works by having an application notify a registrar service that it has a menu bar on a certain window accessible on a certain DBus service:

com.canonical.AppMenu.Registrar /com/canonical/AppMenu/Registrar com.canonical.AppMenu.Registrar.RegisterWindow WinId /MenuBar/123 Global Menu on Wayland – the window decoration menu button will also return! Window positioning on Wayland needs to be tweaked a bit ;)Global Menu on Wayland – the window decoration menu button will also return! Window positioning on Wayland needs to be tweaked a bit ;)

Those of you familar with Wayland might notice that it uses global window IDs, which don’t exist in a Wayland world. That means, no global menu on Wayland, I thought, not without significant re-engineering effort.

Martin Gräßlin then came up with the brilliant idea of writing the DBus service name (it’s omitted in the above call since the registar knows who is calling) and object path onto the windows as properties. This way we don’t need to deal with any window IDs and can even omit the registrar! All we need to do is query the active window for those properties:


On Wayland we then make use of Qt’s Extended Surface protocol which allows you to set arbitrary properties on a window. To my surprise kwin_wayland was engineered in such a way that it works with X clients going through Xwayland with no further adjustment needed!

It works with non-KDE applications, however: VLC player in its full global menu glory!

When we return a new QDBusMenuBar from our platform theme, we then write the properties on the window the menu bar is attached to. This required some changes to Qt code so it actually tells us the window. Unfortunately, we now have to ship a copy of QDBusMenuBar – still better than duplicating everything. I’ve also seen a ticket on Qt’s bug tracker about providing public better access to Qt’s DBus menu implementation. We currently also ship our own system tray implementation for the same reason (and because ours is older but we’d love to get rid of it).

What about non-Qt applications? Google Chrome sporting a classy decoration menu buttonGoogle Chrome sporting a classy decoration menu button

As you could probably tell by the Registrar service name, this stuff wasn’t invented by us. In theory, any application could export its menu through DBus and both Chrome and Firefox do exactly that. I’ve also seen LibreOffice do it at some point but I couldn’t get it to work and neither could I with Gimp and Inkscape.

They won’t work with this new approach anyway, right? We kept the Registrar but all it now does is write the DBus service name and object path on the window with the ID in the RegisterWindow call. This way we don’t need any special-casing in KWin, even. Unfortunately, this won’t work on Wayland then.

What’s up next?

The last bit in this feature frenzy is the application menu KRunner plugin, aka “Unity HUD”. It allows you to search through a potentially complex menu structure of an application using KRunner. Back in Plasma 4 I stopped remembering shortcuts just used it to find all actions I needed.

One issue I came across is that for the application menu runner to work, an application would need to export its menu. However, non-KDE applications like VLC player and Firefox hide their menu bars in this case. This means you cannot really use the application menu runner when you don’t want a global menu or window decoration menu button. I don’t know how to proceed here…

My initial plan was to have three options in Applicaton Behavior settings, Menu “in application” (the default with no global menu service running), “window decoration button” and “in a widget”. Theoretically you could use the window decoration and global menu applet simultaneously, though.

Another obstacle is keyboard activation. When you press Alt+F it would open the “File” menu. With global menu or decoration button I found no way of implementing this. There’s a “request activaton” signal but I never saw anybody actually emit it. What I could perhaps do is add another “modifier only shortcut” when just pressing Alt which then passes focus to and/or opens the menu. Do you know how Unity handles this?

If you like what you saw and want to help make this happen, especially if you have answers to my above questions, be sure to ping me in #plasma on Freenode IRC!

Automotive, what an opportunity for KDE!

Wed, 2016/10/26 - 3:15pm
During the last year I've focused a significant part of my effort on driving the GENIVI Development Platform, together with some Codethink colleagues and other GENIVI professionals and community members.
What is GENIVI Development Platform?

GENIVI Development Platform (GDP) is a project and an outcome.

As a project, it can be defined as the delivery side of the GENIVI Alliance. Today is a fairly standard Open Source project, done in the open following many of the most common practices any FLOSS developer would expect.

As an outcome, GDP is a Linux base distribution (Poky) derivative, built with Yocto, that integrates the software that GENIVI community (automotive professionals) develop as Open Source software.

It still a small project but the quality of the platform and the number of people involved has grown this last year significantly.

GENIVI Alliance is a consortium of +140 companies so obviously most of the overall effort is done by paid developers. Changhyeok Bae (community member) together with Tom Pollard and Robert Marshall (Jonathan Maw before him) from Codethink Ltd, constitute the maintainers team, who are responsible for the integration, testing and release of GDP.

These guys are supported by people like myself, doing coordination, marketing, documentation, IT services, infrastructure, testing and many other key tasks which provides the project a level of robustness and scalability that any serious attempt of this nature requires nowadays.

I am interested, where can I get more?

You can find more general information about the project in the following resources:

GDP-ivi9 is the current stable version although we have moved so fast this last year in terms of the software shipped, that I recommend you to try the following:
  • If you are interested in a solid base system, try GDP 11 RC2
  • If you are interested in checking the latest UI and demo applications, try GDP 11 RC3
  • If you are interested in building from scratch you own images with the latest software, do it directly to GENIVI's rolling release, called Master for now. You can get the latest software there. It should most ly work since we put stabilization effort on it, following the openSUSE Tumbleweed mindset in this regard.
Currently GDP supports RPi2 & 3, Minnowboard MAX and Turbot, Renesas Porter and Silk and Qualcomm Dragonboard 410c. GDP ships Qt 5.6 at the moment, since it is based in Yocto 2.1...

...which makes GDP a great target for KDE software, specially for Plasma.

Putting the effort on having KDE well supported in Yocto would provide the project a third life, landing on an industry that is heavily investing in Open Source with a key piece of software, with no clear competitor today in the open.

It would revamp the interest of many KDE developers in porting their apps to embedded/mobile environments and would bring attention to the project from Qt professionals all over the world. Currently KDE is significantly better than anything else that is open in automotive. It would just require the effort to include it and maintain it in Yocto, which is not small, and adapting Plasma a little initially, not much.

GENIVI launched a Challenge Grant Program that might help to put some funding in the equation ;-)

Whatever effort done to put Plasma on Yocto (so GDP) would also be picked up by GDP's competitor, AGL UCB (Auto Grade linux Unified Code Base), the Linux Foundation automotive group Linux (again, Yocto) based distribution. So there would be at least two players for the cost of one.

It wouldn't surprise me if Qt companies would jump in on this effort too. In order to play in the open filed today, they need to Open Source their products, which is a big risk for most of them. Playing with KDE, which is based in the technologies they are familiar with, would be simpler for them. I bet the Qt company would be heavily interested in promoting this effort. It would help to dissipate all the pushing back from the automotive industry to the current Qt license model, GPLv3 based. And it would do it in the best possible way, by providing great ready-to-use software with no competitor.

I have been one year preaching about how big the opportunity currently is for KDE, but this is not the kind of challenge that can be sustained on volunteer basis, sadly, since keeping KDE up to date in the Yocto project would require a high level of commitment from KDE as a whole. The community probably needs first a small success story and some company/corporate push before really jumping on it, I think. The support of a couple of KDE or Qt companies would catalyze the effort.

GENIVI and AGL make a significant promotion effort around the world within the automotive industry, participating in forums where KDE is unknown. Many companies that currently develop close source Qt applications for automotive would be interested in KDE which would increase our potential targets for our Corporate program.

Having KDE on GDP and AGL UCB would increase the incentive of developing new applications for many of our young developers who currently do not have automotive as a "professional target". 

Companies like LG, Renesas, Bosch, Hartman, Intel, Jaguar Land Rover, Toyota, Visteon, Fujitsu, Mitsubishi, Volvo, among many others.... are key stakeholders of GENIVI and AGL. Isn't it this attractive enough?

A success story like the one I am proposing would be yet another example of how KDE can play a key role for the Qt ecosystem. Sadly not everybody in this ecosystem understand what a great "tool" KDE can be for them. After a hit like this one, it would be undeniable.

Think about the exposure, think about where we are today... Something like this would place KDE where Unity, Android (AOSP) or GNOME are not... yet. I believe this is the kind of strategic decision that would change KDE future. But also the business perspective of those companies (specially Qt ones) who would get involved.

Let's do it now... or somebody else will.

Your most wanted icon set for KDE

Wed, 2016/10/26 - 2:21pm


I did a lot of work for breeze icons and l think it fits the kde desktop, gnome core and libreoffice very well.

But kde mean community, customization, open for 3rd party. So I would like to help icon designers to ship there icon sets for kde or libreoffice. I don’t want to start a new icon set. I’d like to help open source designers to ship there awesome work for kde.

Are you an icon designer and need help? Are you a user and want to have a better integration of your favorite icon set? Are you an app developer and your app wasn’t supported with breeze icons.

Leave a comment, for a better open source experience.

Qt Creator 4.2 Beta released

Wed, 2016/10/26 - 1:04pm

We are happy to announce the release of Qt Creator 4.2 Beta.

Qt SCXML Editor

Flat Dark Theme - Qt Creator 4.1

Qt SCXML is a new module in Qt that allows you to create state machines from State Chart XML and embed them into Qt C++ and Qt Quick applications (Overview). It was released as Technical Preview in Qt 5.7 and will be released fully supported with Qt 5.8.

Qt Creator 4.2 now supplements the module by offering a graphical editor for SCXML (experimental). It features editing states and sub-states, transitions, events, and all kinds of properties. The editor is experimental and the plugin is not loaded by default. Turn it on in Help > About Plugins (Qt Creator > About Plugins on macOS) to try it.

Projects Mode

We reworked how you select the project and it’s diverse settings in Projects mode. Instead of nested tabs, you now select the project from a dropdown, and the settings that you want to edit from a tree that shows all available kits and other categories, making for a much cleaner UI. Enabling use of a kit for a project is now easily done by clicking the entry in the tree. Please provide feedback on any remaining issues through our bug tracker.

Qt Quick Designer

Qt Quick Designer has received many smaller features in this release. In the connections editor there is a new section for managing the imports and property definitions that are necessary for using C++ backend objects (documentation). Also support for padding (Qt Quick 2.6) was added, and you can now edit the when condition of states, and the diverse font properties of text items.

Other Additions and Improvements

When profiling your QML code you now have the option to show memory usage and allocations as flame graphs as well.

We added Tools > Diff > Diff Current File and Diff Open Files for showing a local diff of the modifications of files in Qt Creator with respect to their versions on disk.

CMake integration has added support for platforms and toolsets, and for predefined options for properties.

There were many more changes, which are described in more detail in our change log.

Get Qt Creator 4.2 Beta

The opensource version is available on the Qt download page, and you find commercially licensed packages on the Qt Account Portal. Please post issues in our bug tracker. You can also find us on IRC on #qt-creator on, and on the Qt Creator mailing list.

The post Qt Creator 4.2 Beta released appeared first on Qt Blog.

OpenStack Summit Barcelona Presentation

Wed, 2016/10/26 - 10:45am

Yesterday I conducted my talk at the OpenStack Summit in Barcelona. You can find the presentation here: "Vanilla or Distributions: How Do They Differentiate?" and the video from the session on the OpenStack Foundation youtube channel

Any feedback would be welcome, please don't forget to rate the presentation in the OpenStack Foundation Summit app.

Tuple And Pair in C++ APIs?

Wed, 2016/10/26 - 9:18am

Quick: When you design C++ APIs, when and how should you use pair and tuple?

The answer is as simple as it is surprising: Never. Ever.

When we design APIs, we naturally strive for qualities such as readability, ease-of-use, and discoverability. Some C++ types are enablers in this regard: std::optional, std::variant, std::string_view/gsl::string_span, and, of course, std::unique_ptr. They help you design good interfaces by providing what we call vocabulary types. These types may be trivial to implement, but, just like STL algorithms, they provide a higher level of abstraction (a vocabulary) in which to reason about code. Unlike algorithms, though, which appear mostly in the implementation, and don’t affect APIs much, vocabulary types are at their best when used in APIs.

So, I asked myself, are std::pair and std::tuple vocabulary types?

Vocabulary Types

To answer the question, I looked at what these types help model. This should be trivial to answer for vocabulary types, much as it’s trivial to remember what an STL algorithm does just by looking at the name.

Take std::optional, for example. It models a value that may be absent, i.e. an optional value. This is great. When you start looking for uses, you can’t help but see lots of opportunities just jumping out at you: std::optional is the perfect value type for hash tables that use open addressing. The atoi() return value could finally distinguish between a zero and an error:

if (auto result = atoi(str)) std::cout << "got " << *result << std::endl; else std::cout << "failed to parse \"" << str << "\" as an integer: " << "???" << std::endl;

But what if you want to return an error code, or a human-readable error description? Then std::optional is not the prime choice. There should never be an error and a valid parsed value returned from the same invocation of atoi(), so something like std::variant seems perfect.

But is it?


auto result = atoi(str); if (auto i = std::get_if<int>(&result)) std::cout << "got " << i << std::endl; else if (auto error = std::get_if<std::error_code>(&result))) std::cout << "failed to parse \"" << str << "\" as an integer: " << error.message() << std::endl; else std::cout << "oops, variant was in invalid state" << std::endl;

Some people may call this good API, I call it horrible. If you force your users to query the result with a chain of get_ifs, then you are abusing std::variant, which is designed to contain alternative types with similar purpose, so that it can be efficiently handled using a static visitor. You could use a visitor to handle the result of atoi(), but is that really an API you’d want to work with?

A New Vocabulary Type

Put yourself into the position of the users of your API. What they want is a std::optional where the option is not between presence and absence of a value, but between a value and an error code. So, give it to them:

template <typename T> class value_or_error { std::variant<T, std::error_code> m_v; // space-saving impl detail public: explicit value_or_error(std::error_code e) : m_v(std::move(e)) {} explicit value_or_error(T t) : m_v(std::move(t)) {} std::error_code error() const { if (auto e = std::get_if<std::error_code>(&m_v)) return *e; else return std::error_code(); } T& operator *() { return std::get<0>(m_v); } T const& operator *() const { return std::get<0>(m_v); } explicit operator bool() const { return !error(); } bool operator !() const { return error(); } };


if (auto result = atoi(str)) std::cout << "got " << *result << std::endl; else std::cout << "failed to parse \"" << str << "\" as an integer: " << result.error().message() << std::endl;

There, we just created a possible new vocabulary type.

But ok, I digress. Back to std::pair and std::tuple. What do they model?

As best as I can put it, a std::pair models a pair of two values, and std::tuple models a … tuple of zero to (insert your implementation limit here) values. Sounds simple, but what does that actually mean? Since std::pair is a subset of std::tuple, let’s restrict ourselves to just tuples.

We have a language construct, inherited from C (boo!), that allows us to package a pair or a triple or … of values into one object: it’s called struct. It doesn’t even have a limit on the arity of the object. Surprise!

Pair Models … Struct, Tuple Models … Struct

So, what’s the advantage of a tuple over a struct?

I have no idea! But I guess the answer is “none”.

Ok, so what’s the advantage of a struct over a tuple?

Where should I begin?

First, you get to choose names for the values. The std::set::insert() function could be as easy to use as

template <typename Iterator> struct insert_result { Iterator iterator; bool inserted; }; auto result = set.insert(obj); if (!result.inserted) *result.iterator = obj;

Sadly, what we got is std::pair:

auto result = set.insert(obj); if (!result.second) // or was it .first?! - I can never remember... *result.first = obj;

Second, you can enforce invariants amongst the data members by making them private and mediating access via member functions, as we did in the value_or_error example, where accessing the value when an error was set would throw an exception.

Third, you can add (convenience) methods to the struct, possibly making it a reusable component in its own right:

template <typename Iterator> struct equal_range_result { Iterator first; Iterator last; friend auto begin(const equal_range_result &r) { return r.first; } friend auto end(const equal_range_result &r) { return r.last; } }; for (auto && [key, value] : map.equal_range(obj)) // ...

None of this is possible if you use std::pair or std::tuple in your APIs.

Variadic Woes

There’s just one problem with structs: they cannot be variadic (yet), and that’s when using tuples as API is somewhat acceptable, because we have nothing else at the moment. But there’s hardly a handful of such cases in the standard library, and most deal with implementing std::tuple in the first place (std::tie(), std::make_tuple(), std::forward_as_tuple(), …). About the only example that’s not in <tuple> is the zip() function that’s being discussed:

auto v1 = ...; //... auto vN = ...; for (auto &&e : zip(v1, ..., vN)) // ...

And you need Structured Bindings to make that acceptable:

for (auto && [e1, ..., eN] : zip(v1, ..., vN)) // ... Conclusion

I hope I could convince you that using std::pair and std::tuple in APIs is a bad idea. Or, to say it in the style of Sean Parent: “No raw tuples.”

Defining a small class or struct is almost always the superior alternative. C++ currently lacks just one feature that would all but obsolete tuples: a way to define variadic structs. Maybe the static reflection work will yield that mechanism, maybe we need a different mechanism.

In any case, if you are not in that 0.01% of cases where you need variadic return values, then there’s already no reason to continue using tuples and pairs in APIs.

Since we’re a Qt shop, too, I’ll leave you with an example of how even Qt, which somewhat rightfully prides itself for its API design, can get this wrong:

// Qt 5: typedef QPair<qreal, QColor> QGradientStop; // Qt 6 (hopefully): struct QGradientStop { qreal location; QColor colour; };

The post Tuple And Pair in C++ APIs? appeared first on KDAB.

GammaRay 2.6.0 – a major new release

Wed, 2016/10/26 - 8:40am


GammaRay Model Inspector. GammaRay 2.6 brings you three major new features:
  • We merged the previous model and selection models tools into a new, unified QAbstractItemModel inspector, allowing you to now also see selections and cell flags, as well as to inspect deactivated cells.
  • The new Wayland compositor inspector enables you to observe Wayland clients of a QtWayland compositor, including their surface content and event activity.
  • QMetaObject validation will indicate common problems in property or signal/slot declarations that can cause issues when using the corresponding objects e.g. within QML.

Of course there are also plenty of improvements for your productivity all over the place, such as more widely available object navigation and extended in-app object picking. GammaRay now also supports property editing of nested value types, which is needed, for example, for editing widget size policies.

Meanwhile development on the next version is already under way, bringing a new Qt3D geometry inspector, an improved enum/flag property editor and inspection of QStyle style hints.

The source code can be found on GitHub here.

Tarballs and zipballs for v2.6.0 are available here.

GammaRay is also available as part of the Qt Automotive Suite.

GammaRay is a tool to poke around in a Qt-application and also to manipulate the application to some extent. GammaRay uses various DLL injection techniques to hook into an application at runtime and provide access to a lot of interesting information.

More information about GammaRay.


GammaRay Wayland compositor inspector.

The post GammaRay 2.6.0 – a major new release appeared first on KDAB.

My QtCon + Akademy 2016

Tue, 2016/10/25 - 2:57pm

From August 31th to September 10th I was em Berlin attending two amazing conferences: QtCon and Akademy.

QtCon brought together five communities to host their respective conferences at a same time and place, creating one big and diverse conference. Those communities were Qt, KDAB, KDE (celebrating 20th birthday), VLC and FSFE (both celebrating 15th birthday).


Main conference hall of QtCon at bcc

That diversity of themes was a very interesting characteristic of QtCon. I really appreciated see presentations of Qt and KDAB people, and I was surprised about topics related with VLC community. The strong technical aspects of trends like Qt in mobile, Qt in IoT (including autonomous cars), the future of Qt, Qt + Python, contributing to Qt, and more, called my attention during the conference.

On VLC I was surprised with the size of the community. I never imagined VLC had too much developers. In fact, I never imagined VideoLAN is in fact an umbrella of a lot of projects related with multimedia, like codecs, streaming tools, VLC ports to specific devices (including cars through Android Auto), and more. Yes, I really appreciated to find these persons and watch their presentations.

I was waiting for the VLC 3.0 release during QtCon, but unfortunately it did not happen. Of course the team is improving this new release and when it is finished I will have a VLC to use together with my Chromecast, so, keep this great work coneheads!

FSFE presentations were interesting as well. In Brazil there are several talks about political and philosophical aspects of free software in conferences like FISL and Latinoware. In QtCon, FSFE brought this type of presentation in an “European” style: sometimes the presentations looks like more pragmatically in their approaches. Other FSFE presentations talked about the infrastructure and organizational aspects of the foundation, a nice overview to be compared with others groups like in Brazil.

Of course, there were a lot of amazing presentations from our gearheads. I highlight the talks about KDE history, Plasma Desktop latest news, Plasma Mobile status, KF5 on Android, the experience of Minuet in mobile world, among others.

The KDE Store announcement was really interesting and I expect it will bring more attention to the KDE ecosystem when software package bundles
(snap/flat/etc) be available in the store.

Other software called my attention was Peruse, a comic book reader. I expect developers can solve the current problems in order to release a mobile version of Peruse, so this software can reach a broad base of users of these platforms.

After the end of QtCon, Akademy had place in TU Berlin, in a very beautiful and comfortable campus. This phase of the conference was full of technical sessions and discussions, hacking, and fun.

I attended  to the Flatpack, Appstream, and Snapcraft BoFs. There were a lot of advanced technical discussions on those themes. Every Akademy I feel very impressed with the advanced level of the technical discussions performed by our hackers in KDE community. Really guys, you rocks!

The Snapcraft BoF was a tutorial about how to use that technology to create crossdistro bundle packages. That was interesting and I would like to test more and give a look in Flatpack in order to select something to create packages for Cantor.

Unfortunately I missed the BoF on Kube. I am very interested in an alternative PIM project for KDE, focused in E-Mail/Contacts/Calendar and more economic in computational resource demand. I am keeping my eyes and expectations on this project.

The others days basically I spent my time working on Cantor and having talk with our worldwide KDE fellows about several topics like KDE Edu, improvements in our Jabber/XMPP infrastructure, KDE 20th years, Plasma in small-size computers (thanks sebas for the Odroid-C1+ device &#x1f609; ) WikiToLearn (could be interesting a way to import/export Cantor worksheets to/from WikiToLearn?), and of course, beers and Germany food.

And what about Berlin? It was my second time in the city, and like the previous one I was excited with the multicultural atmosphere, the food (<3 pork <3) and beers. We were in Kreuzberg, a hipster district in the city, so we could visit some bars and expat restaurants there. The QtCon+Akademy had interesting events as well, like the FSFE celebration in c-base and the Akademy daytrip in Peacock Island.

So, I would like to say thank you for KDE e.V. for funding my attendance in the events, thank you Petra for help us with the hostel, and thank your for all the volunteers for work hard and make this Akademy edition a real celebration of KDE community.


Some Brazilians in QtCon/Akademy 2016: KDHelio, Lamarque, Sandro, João, Aracele, Filipe (me)

Mobile IMG 20161025-140532

Tue, 2016/10/25 - 2:08pm

New mobile IMG update,

  • Updated packages
  • Newer libwayland then one available in Ubuntu repositories
  • Experimental activity switcher applet

You can flash using instructions at

OpenStack Summit Barcelona

Tue, 2016/10/25 - 8:26am
Today the OpenStack Summit started in Barcelona, Spain, with the keynotes.

Looking forward to my talk later today: Vanilla or Distributions: How Do They Differentiate? and a interesting summit the next days.

Kdenlive packages available for testing

Mon, 2016/10/24 - 8:35am

Getting the correct dependencies and up to date version of required libraries has always been a challenge for Kdenlive users. So we are pleased to announce that we now provide binary packages for download. These packages contain the latest Kdenlive development version (git master), as well as current development versions of MLT, Frei0r, OpenCV. The GPU movit library is not included at this stage. There might be some performance hit due to the nature of the formats, but these packages will be most helpful to debug and test the alpha/beta versions so that we can provide better releases. It will also help to identify issues linked to missing dependencies or outdated libraries on your system.

So if you are ready, you can download Kdenlive’s first AppImage here:
Then, simply make the file executable and run it! In a terminal:

  • chmod a+x kdenlive-16.12-alpha1-x86_64.AppImage
  • ./kdenlive-16.12-alpha1-x86_64.AppImage

We also provide a Snap package available for testing on Ubuntu distros:

  • sudo snap install --edge --force-dangerous --devmode kdenlive-devel
  • kdenlive-devel

The snap package is in the edge channel and requires “devmode” because of current limitations in the snap format.

These packages will not touch your system’s libraries, and can easily be removed. Please leave your feedback in the comments or on our mailing list(registration required) / forums.

We will provide several updates to this packages before the Kdenlive 16.12 release so that you can follow the development / bug fixes.

KDE Applications 16.12 Schedule finalized

Sun, 2016/10/23 - 10:45am

It is available at the usual place

Dependency freeze is in 2.5 weeks and Feature Freeze in 3.5 weeks, so hurry up!

Plasma 5.8.2, Applications 16.08.2 and Frameworks 5.27.0 available in Mageia

Sun, 2016/10/23 - 9:35am

Mageia KDE Team just finished to push in Mageia cauldron :
– Plasma 5.8.2 ( the Plasma LTS version )
– KDE Applications 16.08.2
– KDE Frameworks 5.27.0

If you find packaging bugs don’t hesitate and come in Mageia Bugtracker

And if you want to join KDE Team and help you can mail us or find us on IRC ( freenode  : #mageia-kde ).

Happy 20th birthday, KDE!

Sun, 2016/10/23 - 5:22am

KDE turned twenty recently, which seems significant in a world that seems to change so fast. Yet somehow we stay relevant, and excited to continue to build a better future.

Lydia asked recently on the KDE-Community list what we were most proud of.

For the KDE community, I'm proud that we continue to grow and change, while remaining friendly, welcoming, and ever more diverse. Our software shows that. As we change and update, some things get left behind, only to re-appear in fresh new ways. And as people get new jobs, or build new families, sometimes they disappear for awhile as well. And yet we keep growing, attracting students, hobbyist programmers, writers, artists, translators, designers and community people, and sometimes we see former contributors re-appear too. See more about that in our 20 Years of KDE Timeline.

I'm proud that we develop whole new projects within the community. Recently Peruse, Atelier, Minuet, WikitoLearn, KDEConnect, Krita, Plasma Mobile and neon have all made the news. We welcome projects from outside as well, such as Gcompris, Kdenlive, and the new KDE Store. And our established projects continue to grow and extend. I've been delighted to hear about Calligra Author, for instance, which is for those who want to write and publish a book or article in pdf or epub. Gcompris has long been available for Windows and Mac, but now you can get it on your Android phone or tablet. Marble is on Android, and I hear that Kstars will be available soon.

I'm proud of how established projects continue to grow and attract new developers. The Plasma team, hand-in-hand with the Visual Design Group, continues to blow testers and users away with power, beauty and simplicity on the desktop. Marble, Kdevelop, Konsole, Kate, KDE-PIM, KDElibs (now Frameworks), KOffice (now Calligra), KDE-Edu, KDE-Games, Digikamkdevplatform, Okular, Konversation and Yakuake, just to mention a few, continue to grow as projects, stay relevant and often be offered on new platforms. Heck, KDE 1 runs on modern computer systems!

For myself, I'm proud of how the KDE community welcomed in a grandma, a non-coder, and how I'm valued as part of the KDE Student Programs team, and the Community Working Group, and as an author and editor. Season of KDE, Google Summer of Code, and now Google Code-in all work to integrate new people into the community, and give more experienced developers a way to share their knowledge as mentors. I'm proud of how the Amarok handbook we developed on the Userbase wiki has shown the way to other open user documentation. And thanks to the wonderful documentation and translation teams, the help is available to millions of people around the world, in multiple forms.

I'm proud to be part of the e.V., the group supporting the fantastic community that creates the software we offer freely to the world.

Second Beta for Krita 3.1 Available

Sat, 2016/10/22 - 9:50am

We’re still fixing bugs like madmen… And working on some cool new features as well, but that’s for a later release. In any case, here is the second Krita 3.1 beta! Yes, you’re reading that correctly. Originally, we had planned to use 3.0.2 as the version for this release, but there is so much news in it that it merits a bigger version bump. Plus, with the acceptance of Julian Thijssens’ Google Summer of Code work by the Qt Project, we’re reaching a really big milestone:

From the next release on, Krita will officially support OSX.



That means that the OpenGL canvas works fully and that we’re committed to fixing OSX-specific bugs, just like we’re fixing bugs on Windows and Linux. It means we’re confident that you can use Krita 3.1 on OSX and be productive, instead of experimenting. So, please test this beta, and help us find bugs and issues!

Of course, Krita 3.1 will have much more new stuff. A new brush engine that supports really big brushes, Jouni’s Google Summer of Code work on adding new features to animation, Wolthera’s Google Summer of Code work that adds color managed high-channel depth color selectors and soft proofing to Krita, a stop-based gradient editor, ffmpeg-based export to animated gif and video formats. And much more.

Note: the beta still contains the colorize mask/lazy brush plugin. We will probably remove that feature in the final release because the current algorithm is too slow to be usable, and we’re still looking for and experimenting with new algorithms. With the current beta you will get a preview of how the user interface will work, but keep in mind that the we know that it’s too slow to be usable and are working on fixing that

The second beta is also much more stable and usable than the first beta (, and we’d like to ask everyone to try to use this version in production and help us find bugs and issues!

Windows Linux

There is also a snap image available in the Ubuntu App Store, in the beta channel.

OSX Source code

Plasma 5.8.2, Applications 16.08.2 and Frameworks 5.27.0 available in Chakra

Fri, 2016/10/21 - 7:05pm

This announcement is also available in Spanish and Taiwanese Mandarin.

The latest updates for KDE's Plasma, Applications and Frameworks series are now available to all Chakra users.

The Plasma 5.8.2 release provides additional bugfixes to the many new features and changes that were introduced in 5.8.0 aimed at enhancing users' experience:

Applications 16.08.2 include more than 30 recorded bugfixes and improvements to 'kdepim, ark, dolphin, kgpg, kolourpaint, okular, among others'.

Frameworks 5.27.0 include a new set of mimetype icons, in addition to the usual bugfixes and improvements.

Other notable package upgrades and changes:


  • plasma-workspace now provides by default the ksuperkey package functionality.
  • php 7.0.11. The 5.6 series is now provided as php56.
  • gconf has been introduced as a dependency of plasma-pa.
  • intel-ucode 20160714
  • laptop-mode-tools 1.70
  • openssl 1.0.2.j
  • rust 1.12.0
  • filesystem 2016.09
  • gnutls 3.4.15
  • lua 5.3.3
  • vim 8.0.0045

  • libreoffice 5.2.2
  • kexi 3.0.0, now ported to Frameworks 5. If you get a warning about files already existing on the filesystem, please follow our FAQ documentation.
  • mpv 0.21.0
  • wireshark 2.2.1
  • nmap 7.30

  • filezilla 3.22.1

  • steam
  • wine 1.9.21
  • q4wine 1.3.3

    It should be safe to answer yes to any replacement question by Pacman. If in doubt or if you face another issue in relation to this update, please ask or report it on the related forum section.

    Most of our mirrors take 12-24h to synchronize, after which it should be safe to upgrade. To be sure, please use the mirror status page to check that your mirror synchronized with our main server after this announcement.
  • Spektrum: Preset for Modern Architecture Photography

    Fri, 2016/10/21 - 12:31pm

    Like many photographers, I have a handful of hand-made favorite presets (most of them are included in the Daily Curves Set) in my photographic toolbox. But there is one preset in particular I use more often than others. I named it Spektrum, as it’s inspired by images from the Spektrum Berlin photo book by Matthias Heiderich.

    Continue reading