Tuukka Turunen

Qt Roadmap for 2018

Published Thursday February 22nd, 2018
29 Comments on Qt Roadmap for 2018
Posted in Biz Circuit & Dev Loop, Qt, Releases, Roadmap

Qt 5.9 LTS is a solid baseline, which continues to improve still during 2018. Qt 5.10 was released in December, but there is more cooking. We are currently finalizing the Qt 5.11 release for May and looking towards Qt 5.12 LTS in November. In addition to the Qt framework we are actively developing our tooling offering. Tune in for an overview what we have in the works for 2018.

This blog post is a continuation of roadmap posts I have written for 2016 and 2017. As always, there is more to tell than what reasonably fits in a blog post, but I will try to talk about the most interesting items. There will be many more blog posts, videos, webinars and of course product releases throughout 2018 to provide details of the numerous items we are developing. Just like in the earlier posts, I would like to thank each and every Qt developer for their contributions. Most of the functionality is created by The Qt Company, but we also have a great ecosystem with many contributors. They have provided multiple extremely valuable contributions throughout the years and continue to shape Qt also in the future. In addition to those contributing code, we have also a large number of people active in the Qt Project forums, on mailing lists, as well as reviewing code and testing the Qt development releases. Together we create Qt!

Timelines for Qt 5.11, Qt 5.12 LTS, a lot of great tools and more

For 2018 we are planning to have two Qt feature releases: Qt 5.11 in May and Qt 5.12 LTS (Long Term Support) in November. As usual, we offer pre-releases for testing the new features. We will also create patch releases for these to address issues reported by users. In addition, we continue to make Qt 5.9 LTS patch releases throughout 2018.

For Qt Creator we are planning to have three feature releases: Creator 4.6 in March, Creator 4.7 in July and Creator 4.8 in November, providing incremental improvements and new functionality for our awesome IDE. The latest addition to our tooling offering, Qt 3D Studio, is planned to release a major new version in June: Qt 3D Studio 2.0 with new runtime based on Qt 3D. During the second half of 2018, we are planning to release Qt 3D Studio 2.1 in September and Qt 3D Studio 2.2 in December.

For our industry offering we continue to develop Qt for Automation and Qt Automotive Suite further. A major new version, Qt Automotive Suite 2.0, is planned to be released soon, followed by incremental update releases. We are also introducing new Qt Safe Renderer 1.0 for use in safety critical applications of Qt.

So, a busy year ahead of us. Now, let’s dive a bit into the features and functionality included in these releases.

What is coming with Qt 5.11 and Qt 5.12 LTS

Qt 5.9 LTS has been a solid baseline with multiple patch releases providing bug fixes and other improvements. We have already fixed over one thousand user reported issues with the Qt 5.9.x patch releases and intent to continue these during 2018. Qt 5.9 LTS has recently entered the Strict phase, which means we will fix the most important bugs, but the less important fixes will be targeted to Qt 5.11 (and later 5.12 LTS). In addition to continuously improving the quality, we are actively focusing into performance of the key use cases. We are constantly measuring performance in order to identify commits that have caused a performance regression in some area – and we also improve performance whenever possible. With the focus in both fixing bugs and improving performance, new Qt releases run the existing applications faster and more reliably.

When it comes to new features, we have many things ongoing related to graphics, so I’ll start with that. One of the biggest things for 2018 is the unification of our 3D engines. Qt 3D Studio 1.x releases use the 3D engine contributed by NVIDIA. While it is a good and solid engine, the benefits for migrating on top of Qt 3D are clear: easier to use both pre-defined and programmatically created content in the same application, improved support for different operating systems and hardware, and of course also avoiding the need to develop and maintain two different 3D engines.

Activities for being able to run Qt 3D Studio applications on top of Qt 3D have been ongoing for a long time and there are quite many improvements also to Qt 3D itself done during the process. Some of these are the improvements done to Qt 3D performance and reducing memory consumption of Qt 3D needed to efficiently run complex Qt 3D Studio applications on top of it. A great example of the benefits of unification is that these performance improvements to Qt 3D benefit also the existing Qt 3D applications – in addition to the upcoming Qt 3D Studio 2.0 applications.

Another major item for graphics is asset conditioning, essential for being able to reach optimal performance on target hardware. Both for 2D and 3D graphics, the size of assets is often a significant part of the overall application size and especially runtime memory footprint. During 2018 we continue to improve the asset conditioning support in Qt by adding more supported texture compression and packaging formats and making it easier to handle the graphical assets in build system and tooling.

Basic support for ETC1, ETC2 and ETC2_EAC compression was added already with Qt 5.10. Qt 5.11 improves the texture compression implementation and adds support for the commonly used KTX (Khronos Texture) texture file format. Modern GPUs with OpenGL ES 3.x support can handle the compressed textures efficiently, leading into improved memory usage and performance with the new Qt versions. We aim to continuously improve the asset conditioning capabilities of Qt and are currently looking into texture atlassing and other possibilities in order to further improve the performance and memory usage of textures.

Other areas we are working within the graphics are improved support for Vulkan and introduction of initial Metal support with Qt 5.12. We have also been looking into support for hardware graphics layers especially when using Qt Wayland. This is still quite hardware specific, but we have already enabled it with some commonly used SoCs.

Completely renewed gesture handling a.k.a. Pointer Handlers as a new approach for mouse, touch and gesture event handling is a major area we have been working on for quite some time now. The main issue addressed with the new functionality is versatility especially in multi-touch and multi-monitor applications, which is an area where the previous functionality has not been enough to tackle all aspects. The new functionality enables implementing other kinds of control mechanisms in Qt applications, for example based on hand gestures detected by a camera or a proximity sensor.

Pointer Handlers provide lightweight declarative API for recognizing and handling the most common mouse, touch and multi-touch gestures (press-hold-release, drag, swipe, and pinch) from mouse and touchscreen, in parallel across the scene. You can interact with multiple Items simultaneously, across multiple screens when necessary. First introduced as a Qt Labs feature, this is planned to graduate to a fully supported feature with Qt 5.12. Pointer Handlers can be extended to handle more use cases and are intended to have a public C++ API in upcoming releases.

Qt Quick Controls 2 received the initial capability for image-based styles with Qt 5.10. We are looking forward to completing the offering in Qt 5.11 and new design templates, including a template for Inkscape (in addition to Sketch, Illustrator and Photoshop templates). We are also well in progress for a new, performance optimized, table view implementation for Qt Quick, aiming to land in Qt 5.12. The target is to offer the new table view as a patch to be tested on top of Qt 5.11 in order to get early feedback. The implementation is done from the ground up with performance in mind, and we believe it is now on a good level.

So, quite many new things for Qt Quick users, but not to worry – we have not forgotten users of Qt Widgets. On the contrary, already during the past year we have been increasingly addressing open bugs of Qt Widgets and intend to continue doing so during 2018 and beyond. Both Widgets and Qt Quick have their strong points and they complement each other nicely as fully supported parts of the Qt offering.

Qt WebEngine, our HTML5 engine based on Chromium, will get an update to Chromium version 65 with Qt 5.11. For Qt 5.12 LTS we are looking into possibilities for decoupling Qt WebEngine from Qt release schedules to allow more frequent updates of Qt WebEngine. This is still under research, but there seem to be quite tangible benefits from carving out Qt WebEngine to a separate item. Current thinking it that as a separate item we should be able to release Qt WebEngine every three months, following nicely the schedule of Chromium releases every six weeks. For Qt 5.12 LTS users this would mean the possibility to get not only the security updates, but a full new Chromium version supported on top of the long-term-supported release of Qt.

A big new thing we aim to release during 2018 is Qt for Python, i.e. bindings to Python programming language. Initially started as PySide, the work has continued for quite some time already. After a lot of work, we are reaching the point of being able to offer a technology preview to be used on top of Qt 5.11. For those not familiar with what Qt for Python is, it offers a set of bindings to enable Python applications to leverage Qt functionality. For example, Qt is a great framework to create the user interface of a Python application. Python is a powerful programming language with a large and growing user base. According to Stack Overflow, Python is the fastest growing programming language. Based on their analysis, the amount of Python developers exceeded the amount of C++ developers in 2012 and is currently over three times larger. Tiobe index ranks C++ to be still more popular than Python, but also based on their study Python is on a growth trajectory. Our hope is that many of the Python developers will find Qt valuable to use in their applications.

To complete the list of Qt framework items, let’s talk a bit about our ongoing research of Qt for WebAssembly. We have earlier looked into Qt for Native Client and emscripten and the current work for WebAssembly continues along the same path. Since 2017 the four leading browsers (Chrome, Edge, Firefox, and WebKit / Safari) have agreed upon the use of WebAssembly, so it is reaching to be a stable platform to run Qt on. We will blog more about running Qt applications on WebAssembly later, for now you can take a look at the code and build instructions.

Improved and new tooling for Qt development

In the tooling area, we have been working hard to create the new Qt 3D Studio based on the NVIDIA contribution we received a year ago. Qt 3D Studio is a great tool for creating interactive 3D user interfaces and applications. The editor is a cross-platform Qt application running on Windows, Mac, and Linux. Qt 3D Studio is not a tool for designing 3D models, these can be imported from commonly used tools such as AutoDesk Maya, MODO by the Foundry and even Adobe Photoshop, to mention some examples. Qt 3D Studio comes with a large set of materials and other assets to complement the models imported from other tools. The big thing for 2018 is the Qt 3D Studio 2.0 release where we switch the runtime to be based on Qt 3D. This allows deeper integration with other Qt functionality, improved portability, reduced maintenance effort and many other benefits.

While many of our Qt 3D Studio examples are geared towards Automotive and Digital Cockpit use cases, it is by far not just a tool for Automotive. Need for 3D user interfaces exists in multiple other industries such and automation, medical, entertainment, home appliances and more. Qt 3D and Qt 3D Studio are also fit for the creation of AR and VR applications – a raising technology area that has many benefits both for consumer and business needs. Automotive is an important area for Qt and we continue to develop Qt 3D Studio according to the needs of it, but not as the only industry to cater for.

In Qt 3D Studio 2.0 as well as the 2.x releases later in 2018 we focus especially into interoperability with other parts of Qt, for example, seamless integration with Qt Quick as well as improved integration with Qt Creator IDE. One of the upcoming key improvements in the editor is completely rewritten timeline component, providing greatly improved ergonomics and workflow. With 2.0 we also aim to provide the final and fully supported Behavior API and Data Node API. We also continue to improve examples and documentation in order to make the creation of 3D user interfaces with Qt efficient, easy and fun.

In addition to tooling for 3D UI creation, we are looking into ways to improve our tooling for 2D UI creation. In many cases, Qt Quick is all that is needed for the UI as it allows efficient creation of dynamic and interactive user interfaces. One of the areas we aim to improve is better support for importing assets from commonly used design tools. This has been possible before, but we want to make it better and easier also for people who are not experts in software development. Other key improvement areas include the functionality, ergonomics, and usability of the tooling – again also for people other than developers. The third key area to improve is the possibility to easily see the outcome of design changes in the target application, even in the target device. Ease of deployment to target device has always been a strong point of Qt Creator, but there is still room to improve. We are planning to have the improved 2D UI design offering ready for the first release during the latter part of 2018 – and will certainly provide more information of this during the year.

For Qt Creator, we have many incremental improvements planned to be done in the upcoming releases during 2018. Some of the main areas we are looking into are leveraging Clang code model, Python support, support for upcoming Qt target platforms (e.g. Qt for WebAssemby) and improved CMake support. Using Clang provides us with code-assistant functionality for modern (and future) C++ language standards. With Qt for Python, it is essential to offer Python support in Qt Creator, to allow convenient development and debugging of Python applications.

In addition to the high-profile features listed above, we continue to improve all the important areas of Qt Creator. For example, debugger support, code editor features (complementary to clang/qml code models) and releasing (improvements to the installation process, pre-releases via the online installer). Continuously improving CMake support in Qt Creator is needed to keep the growing CMake-using customer base satisfied. We also continue the development of QBS and maintenance of qmake, keeping also these as viable options for Qt applications. Just like with Qt in general, we are also continuously looking into the performance of Qt Creator and doing performance improvements.

A completely new component coming in 2018 is Qt Safe Renderer 1.0, which allows the creation of safety critical user interfaces much easier than before. It consists of two key items: integration to Qt Creator for the creation of safety critical user interface, and the renderer component for rendering the safety critical user interface. We are in the final steps to receive functional safety certification for the Qt Safe Renderer, including both the safety critical tooling and runtime parts.

Automation, Automotive, and other industries

In addition to improving the generic product offering according to feedback from customers and focused industries, we also have some items developed especially for the needs of certain industries. These are available for any industry but expected to be most relevant for the one they are named after. Prime examples of these are Qt for Automation and Qt Automotive Suite.

To learn more about Qt for Automation, check the blog post introducing it. The main items we have been cooking for 2018 are fully supported MQTT, KNX and OPC/UA implementations. Qt Mqtt and Qt Knx technology preview have been available since last year and both will be fully supported with the upcoming releases of Qt. Qt OpcUa is a new item, which we aim to first provide as a technology preview with Qt 5.11 and then finalize it for use with Qt 5.12 based on the feedback.

Qt Automotive Suite, available since 2016 is reaching 2.0 version soon. Based on Qt 5.9 LTS, Qt Automotive Suite 2.0 is a combination of automotive specific functionality from The Qt Company and our partners KDAB and Luxoft. Version 2.0 bundles with the Qt Safe Renderer, Qt 3D Studio, and includes an overhaul of QtIVI with the ability to generate APIs from an QFace IDL, improvements and added features to the Neptune UI, Application Manager and the GammaRay runtime introspector.

Get involved

If you want to learn more about upcoming things for Qt, please stay tuned for new blog posts and webinars about the upcoming features, contact our sales teams or join the discussion in the Qt mailing lists and developer forums. We are always delighted to see new contributors in the Qt Project as well as feedback to the pre-releases of Qt via bugreports.


Do you like this? Share it
Share on LinkedInGoogle+Share on FacebookTweet about this on Twitter

Posted in Biz Circuit & Dev Loop, Qt, Releases, Roadmap


TheBootroo says:

Huge !

But no word on the ongoing refactor of the QML engine ?
Neither on the discussed idea from QtCS17 to rebase QtQuick upon Qt3D or not ?

Would like to hear on those…

@TheBootroo: QML engine has been under active development in the past years and the key goals for it are same as in general for existing features: improve performance and quality. Qt 5.11 introduces the rewritten compiler pipeline for the QML engine, allowing to directly generate byte code and store that as the intermediate representation. Plan is to have a separate blog post summarizing the changes it has received throughout the past few versions of Qt, which have resulted into significantly improved performance especially on 64-bit ARM and possibility to cache and to pre-generate the byte code. For Qt 3D the major item is to leverage it as basis of Qt 3D Studio applications, which is explained in the text. There is no work ongoing to rebase Qt Quick on top of Qt 3D, but rather to continuously improve the development workflow and functionality to allows seamless mixing of 2D and 3D items in the same Qt application.

PS says:

Please provide a blog post/tutorial about this new bytecode feature before the final release comes out (so that we can beta test).

Vincent says:

Are there any plans to develop Qt for machine learning? What I can come up with are neural network visualization toolkit, interactive neural network simulation environment ……

Jason says:

I am currently doing AI, and I don’t see much overlap between the two, and I think any effort to merge the two would be extremely hasty (implying wasteful). There’s a lot of iteration going on in AI, as a TF, Keras and PyTorch compete. I do see there to be a potential integration between Qt and AI in the future, but it would be hinging on Qt providing data straight from the hardware to the AI for forward propagation only. I also see the potential for Qt to to take a compiled & trained AI model and have it execute using OpenCL on your embedded device using the GPU. But I think the “interactive neural network simulation environment” you request would just be a GUI made in Qt. However, a lot of times, this is better done in the web/JavaScript. However, I routinely make GUIs in Qt to aid my AI training. Maybe having a Repository of Trainer GUIs is a good idea?

Vincent says:

Hi Jason,

Would you mind open sourcing your AI training GUIs? Perhaps your GUIs can be used in the web via Qt WebGL plugin or WebAssembly in future.

Jason says:

Due to the amount of training data, WebGL is not yet practical. For example, I have a CSV file that has 4 output columns and one text column. The UI allows the user to score the text, setting 0 or more of the output columns to 1. The local version of the UI is pretty much instantaneous at 1000 training lines. However, it noticeably lags with even just 10 in WebGL ITech preview1). The core is a a TextDocument.

Jason says:

I am happy to hear about the upcoming Python support, and I look forward to being able to do 3D UIs in QML with no real 3D Knowledge!

I humbly request that “Pointer Handlers” be renamed to “Pointing Handlers” so that the pointers being referred to are not confused with their smart, unique and weak varieties.

Areas where I would like to see Qt:
1. Javascript (NodeJS) support in QtCreator.
2. QML for Web development. I’ve tried WebGL and it’s cool, but is lacking. I think a combination approach of that plus QMLWeb is what is needed (put more, most, of the work on the client)
3. Maybe look at replacing JS of QML and using ChaiScript

Python is taking off because of ML, but JS is still more popular.

PS says:

A note to the pointer handlers:
1.) Yep, the name is confusing.
2.) Please sort out the existing problems with pointer handlers (and also pre- pointer handlers touch). Bug reports about the problems have been posted for a while.

Pablo Rogina says:

+1 for “Pointing Handlers” naming…

Alexander says:

I wonder if Qt will finally get proper cross-platform per-monitor HiDPI support in widgets…
That includes Linux, where the scale-factor based scaling is blurry (and disables font hinting) and dpi-based scaling has too many rough corners.

Alexander says:

… and of course the application writer has to write lots of code (like scaling widget minimumSize properties and such, depending on DPI) when targeting Windows and dpi-scaled Linux.

Pablo says:

What about qt widgets? Any updates? How should modern desktop applications render their ui today and in the next 10 years?

@Pablo: Widgets are fully supported part of Qt offering and we intend to keep it that way also in the future. The choice between Widgets and Qt Quick Controls 2 for a desktop application can sometimes be a touch one as both of them have their strong points. Typically if you are after a classic desktop application that looks just like any other Windows or Mac etc application, Widgets is a good choice. If you want to have a custom look, dynamic UI transitions or make variants of the same application to different kinds of devices etc you may want to go with Qt Quick Controls 2.

matthias says:

To me, the declarative syntax of QML, the interact with ‘compile-to-js’ languages, the fact that it separates UI code from logic and the build in GPU acceleration are all reasons to use Qt Quick when ever possible.

Also QMLWeb is an argument, since is very underrated from all those ‘young and potent’ projects in the Qt community.

Jakub Narolewski says:

“We are also well in progress for a new, performance optimized, table view implementation for Qt Quick, aiming to land in Qt 5.12. The target is to offer the new table view as a patch to be tested on top of Qt 5.11 in order to get early feedback.”

Awesome 😀 That really made my day.
Don’t want to seem impatient, but do you have timeframe for that?

Mohammad says:

Are there any plans to develop AR/VR module? for example easy integration for most popular AR SDKs like ARKit/ARCore and in another hand, vofuria or easyAR in Qt applications.

and another question, Is there any plan to implement Microsoft Fluent Design in Qt Quick Controls 2?

Stu says:

If please make Qt for python installable from pypi (using WHL) and available across platforms. Then you will be onto a winner.


Piotr says:

The question is – will you be committed to maintaining Python bindings a.k.a. PySide or once again PyQt will prove to be the stable and constantly maintained counterpart that doesn’t lag behind Qt releases .

Juha says:

What about TreeView component?
Long time waited.

zlutor says:

Inkscape was mentioned in the post – does.it mean improved SVG support?

Current one is quite limited – e.g in Image item…

Marco Piccolino Marco Piccolino says:

I don’t think the Inkscape mention is related to SVG. It should only be a styleguide of components meant for PNG export according to standard naming conventions, so that it can be used in the Imagine QQC2 style.

Roman says:

I think QtCreator now is quite competitive with commercial C++ IDEs. Why don’t you offer it commercially for non-opensource projects? Buying whole Qt license is too expensive when you don’t plan to use Qt. If priced competitively, like VisualAssist/Resharper/Clion etc I think it can have it’s own market niche.

Toni says:

i have a question about the licence qt quick compiler and hope someone can clarify this.
if i understood corectly the current state is that the fuctionality of the qt quick compiler is only partially under lgpl/gpl licence, meaning you can cache qml files but not compile them into c++, is that right?

@Toni: Correct. Qt 5.10 offers possibility to cache, but to pre-compile a QML application the Qt Quick Compiler is needed. With Qt 5.11 the QML engine is changing so that separate Qt Quick Compiler is not needed.

Jacob says:

Please make python bindings that work with pypy

stlcours says:

As Qt for Python in 5.11 is for the python developers, do you have any plan to support calling python by C++/Qt? Because Python has so many interesting libraries that are impossible to be rewritten in C++. Don’t forget the callback, between C++ and Pyton, is important because C++ developers need know what is the progress now. Thanks for your work hard.

Jean-Michaël Celerier says:

To call Python from C++ the library pybind11 works extremely well : https://github.com/pybind/pybind11 ; I’d rather see more bugs fixed and missing features / implementations (looking at you QtMultimedia) done than existing working stuff being reimplemented.

Oliver Knoll says:

You guys all rock! Qt rocks! 3D graphics getting all this love – phantastic!

The only two key technologies missing seem to be Machine Learning(tm) and Blockchain(cash). Nah, just joking 😉

(But hey! Integrating TensorFlow into a nice Qt API… why not :))

Commenting closed.

Get started today with Qt Download now