Tuukka Turunen

Qt Roadmap for 2017

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

With Qt 5.7 and 5.8 released we have a completely new baseline for Qt 5 based applications and devices. In this blog, I want to provide a roadmap update on what we are currently working on in the Qt R&D and what the future directions are.

About a year ago I provided a roadmap update for 2016. Looking back the past year, I am very happy and proud that we have been able to develop and deliver all those great features and improvements. I would like to thank each and every Qt developer for their input. While most of the functionality is created by The Qt Company, we also have many community contributors who have provided multiple extremely valuable contributions throughout the years. 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 the Qt framework. Thanks!

Release Timelines

Throughout the lifetime of Qt 5 we have been steadily providing a new feature release of Qt every six months. While it has taken a bit longer than anticipated to release some versions, we have been able to keep this heartbeat steadily. Our plan is to continue to do so in the future. Therefore, after Qt 5.8 we will release Qt 5.9, Qt 5.10 and Qt 5.11 with roughly six month intervals.

Despite Qt 5.8 just being released, we already have the features of Qt 5.9 frozen and the alpha release will be available very soon. For those interested in taking a closer look into Qt 5.9 features, please check out the New Features of Qt 5.9 wiki page. Our target is to release Qt 5.9 in May 2017. Parallel to finalization of Qt 5.9, the development of Qt 5.10 is ongoing. Everything that is merged now to the dev branch of Qt is to become part of the Qt 5.10 release planned for November 2017. After Qt 5.10 is branched from dev, development of Qt 5.11 starts with planned release in May 2018.

New Features in Qt 5.9

Qt 3D was first released with Qt 5.7 and in Qt 5.8 the focus was mostly on stability and performance. With Qt 5.9 we are providing many new features which significantly improve the functionality of Qt 3D. Notable new features include support for mesh morphing and keyframe animations, using Qt Quick items as a texture for 3D elements, as well as support for physically based rendering and particles. There are also multiple smaller features and improvements throughout the Qt 3D module.

We are continuously focusing into improving graphics performance and Qt 5.9 brings new graphics features focusing especially on performance optimization. Applications utilizing OpenGL shaders will benefit from new shader disk cache, which will significantly reduce the initialization time of OpenGL shaders. With our measurements we have seen up to 10x improvement in shader performance compared to Qt 5.6 and up to 8x improvement compared to Qt 5.8 in some commonly used embedded devices. Other graphics related improvements in Qt 5.9 include sharing of resources such as bitmaps between processes reducing memory consumption in multiprocess systems, support for Wayland XDG Shell version 6 and support for Wayland IVI extensions.

On the QML engine side we introduced a major new approach with Qt 5.8: a disk cache for the just-in-time compiled QML and JavaScript. The work will continue towards introducing a completely re-implemented Qt Quick Compiler for ahead-of-time compilation of QML and JavaScript. Qt 5.9 offers the commercial-only ahead-of-time compilation with Qt Quick Compiler and the binary cache for just-in-time compiled QML to commercial and open-source users, just like Qt 5.8. In addition, Qt 5.9 provides a preview of a new ahead-of-time cache generation, which we aim to develop further for the Qt 5.10 release. The new approach is intended to replace the earlier Qt Quick Compiler with similar or improved performance on all supported platforms. For Qt 5.9, we are providing also some further improvements in the QML engine. Most notably the completely rewritten garbage collector offers a base line for improved speed and reduced memory consumption of future Qt Quick applications.

We have further tuned Qt Quick Controls functionality and added many new features improving the usage across desktop, mobile and embedded platforms. With Qt 5.9 we are adding ScrollView, an editable ComboBox and multi-touch support, to name a few of the most interesting new features. The new ScrollView provides flicking and non-interactive scroll indicators on touch and switches to interactive scroll bars when interacted with a mouse pointer. The editable ComboBox allows typing in auto-completed values using keyboard and multi-touch support allows interacting with multiple buttons and sliders at the same time.

Qt Network and especially QNetworkAccessManager (QNAM) have been improved in Qt 5.9. Previously, the behavior when encountering an HTTP redirect had to be defined per HTTP request by setting an attribute. Now there is also a new redirect policy that can be set globally in QNAM. If redirect behavior is to be specified in multiple ways, the first priority is defined per request with a policy, the second is per request with an attribute and finally the global QNAM policy takes control. Another major improvement is the HTTP Strict Transport Security (HSTS) support. HSTS is a web security policy, described in RFC6797, that allows a web server to declare that user agents should only interact with it using secure HTTPS connections.

We have some platform specific improvements as well as support for new platforms and compilers coming with Qt 5.9. Especially macOS is receiving many improvements, as we are updating the macOS platform plugin in order to support modern and future features of the operating system, especially on the graphics side. For Windows users, Qt 5.9 targets to bring support for the new VS2017 compiler. We may also be offering pre-built binaries for VS2017 with Qt 5.9 (depending on when VS2017 is released). With Qt 5.9 we are re-introducing support for INTEGRITY allowing creation of safety critical systems with Qt on top of the INTEGRITY RTOS.

These are examples of some of the new things coming with Qt 5.9, for full list of features please check http://wiki.qt.io/New_Features_in_Qt_5.9.

Directions for Qt 5.10 and Beyond

After the branching of Qt 5.9 the dev branch now contains what will become Qt 5.10. It is planned to be released in November 2017 and its development has already started. We are currently finalizing the development priorities and here are some items we have been considering to do for Qt 5.10.

Qt is very widely used with over one million developers and a vibrant ecosystem. Sometimes a user just starting with Qt may find it a bit challenging to get going. One reason for this challenge is the fact that Qt is so versatile – we often offer multiple ways of developing applications. Sometimes it may also happen that parts of our documentation and examples are slightly outdated or do not clearly highlight what is the best approach for the user. While the work with documentation and examples is a constant effort, with Qt 5.10 we are planning to have a further push to improve the experience of getting started with development of Qt application and devices.

Running Qt applications in a browser via Native Client (NaCl) has been possible since 2009 and since Qt 5.8 VNC can be used for remote control of Qt applications. However these options are often not as convenient as desired. With Qt 5.10 we are planning to support streaming of Qt Quick application UIs over a network to a browser using WebGL. This streaming of OpenGL commands will allow using a common browser as a remote display of a Qt application running e.g. in a nearby embedded system or far across a network. Input from touch/mouse as well as keyboard is transmitted back to the Qt application. WebGL streaming will be implemented as a platform plugin in Qt 5.10. The streaming plugin converts all painting commands to WebGL commands and transmits the streams to clients. In turn those clients transmit user input back. Clients can be Qt applications or any web browser capable of showing WebGL 1.0.

On the graphics domain we are working with some nice additions targeting Qt 5.10. The first one being support for arbitrary path rendering (i.e. shapes) in Qt Quick. This allows declaratively specifying complex shapes built from lines, curves and arcs directly in QML and rendering them in an accelerated manner. Continuing on the approach started with the scenegraph modularization in Qt 5.8, the solution is expected to have multiple backends internally. For instance, NVIDIA-based systems will be able to utilize the GL_NV_path_rendering OpenGL extension transparently to the applications. The second new item is to provide basic Vulkan enablers in Qt. These allow creating Vulkan-capable windows and integrating code performing rendering with Vulkan into Qt C++ applications on multiple platforms, while abstracting and hiding the platform and windowing system specific bits. The third item we are researching is to use modern OpenGL features in Qt. Especially those offered by OpenGL ES 3.2 are quite interesting to improve the Qt Quick scenegraph performance and to potentially introduce new features like e.g. built-in support for compressed textures.

In the 3D area, we recently received a major contribution from NVIDIA, who contributed their complete 3D UI development tooling to Qt. During the coming year we will develop the tooling and its Qt integration further to enable smooth creation of 3D UIs for Qt applications. We will improve the existing integration into Qt and introduce more Qt functionality within the tooling itself. In the long term, we are also aiming to port the tooling to fully leverage Qt to support Mac and Linux hosts for development (initially the tool is for Windows only). For deployment the tool will support all desktop, embedded and mobile platforms generally supported by Qt. To check out what is already possible with the tool, please read the the recent announcement blog post for Qt 3D Studio.

Patch Releases and Long-Term Support

In addition to feature releases we make patch releases providing improvements to functionality introduced in those new feature releases. The primary purpose of a patch release is to provide a collection of bug fixes to issues found in the .0 feature release. Typically, the first patch release contains many fixes which were already completed at the time of the .0 release, but were not considered critical. The bug fixes done after the .0 release will end up in the next patch level release, as well as merged up to the next feature release.

Unfortunately, we have not been as efficient in providing the patch releases as we would like to. For Qt 5.7 we only created one patch release in December, almost 6 months after the Qt 5.7.0 release. We are currently renewing the CI system infrastructure, which will increase the capacity of the Qt CI system and allows us to make more patch releases from Qt 5.9 onwards. Unless there are significant security or other issues found, we are not planning to provide any patch releases for Qt 5.8 to make sure that we release Qt 5.9.0 with the planned schedule. Qt Support will assist customers to overcome possible issues found in Qt 5.8.0 release.

For Qt 5.6 LTS we have already provided two patch level releases adding quite a lot of improvements. Going forward we will make less changes to the Qt 5.6 LTS version. Since Q4/2016 we have already reduced the number of fixes going into the 5.6 branch. While each fix as such is beneficial, they are also possible risks for behavior changes and regressions, which we want to avoid in LTS releases. Next patch release, Qt 5.6.3 LTS, is planned to contain only fixes for critical bugs and security issues. The planned timing of Qt 5.6.3 is after Qt 5.9 has been released.

We are considering possibilities to extend support of Qt 5.9. The decision has not yet been made whether it should be a generic LTS or something that is provided only for selected platforms (e.g. embedded only). In any case we intend to create more patch releases for it than we have been able to do for Qt 5.7 and 5.8. The ongoing improvements and increasing the capacity of our CI system will help achieve this.

Get involved

During the coming months we will be hosting several webinars about key features in Qt 5.8. There will also be many blog posts about the new innovations in Qt targeting Qt 5.9 and Qt 5.10. If you want to learn more about Qt, please 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.

If you are interested in working with us to shape the future of Qt, we have many open positions at The Qt Company.

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

29 comments

Raphael Araújo says:

I’m a great fan of you guys! You have my respect!

Qt is a superb and IMHO, this is the best C++/UI framework out there. Being using it since 2006 I could see how it evolved and turned so versatile. My only problem with it is that sometimes some regression here and there can happen, but that’s ok. We developers know that things like that can happen.

Currently I’m using 5.6 in my project (pgmodeler.com.br) and I’m pretty satisfied with its performance so I’ll wait until 5.9 to upgrade the framework and take advantages of so many improvements.

Keep up the good work!
Cheers from Brazil!

Carl Engh Carl Engh says:

Thanks for being a Qt ambassador and also linking to us on your site!

JBT says:

Hi there,

Is the vulkan work for 5.10 intended as a developer preview only at this point, or a live feature?

Kind regards. Jbt

Felix Zweig says:

It’s really sad that there won’t be a 5.8.1 release. We have been waiting for important fixes of regression, which now have to be postponed to 5.9.0. From experience, this will probably introduce some other regressions, which means we will have to wait for 5.9.1. This means we will have waited for about 1 year (5.7.1 to 5.9.1) to use a upgrade to a working Qt version. That’s a bit unfortunate.

Tuukka Turunen Tuukka Turunen says:

@Felix: With the CI improvements in place we should be able to make Qt 5.9.1 quite soon after Qt 5.9.0, so it should definitely not be a full year from Qt 5.7.1 release. We also actively try to avoid regressions to earlier versions, a regression is considered a release blocker.

Henk Jan says:

So you say that 5.9.0 will be the first .0 release without regressions…..
Using Qt commercial for 10 years that would be an unicum .0 release are in general not usefull for production.
Bug fixing is not the strongest point many P2 bugs do not get attention at all.
Is this going to change in the future?

Alex says:

I second that.

Vincas says:

I feel the same Felix, I try to avoid .0 releases too…

ZLB says:

I’m afraid I agree with this.

I am currently working on an iOS, Android, UWP app in Qt. The bug with QML Controls2 where Switch and CheckBox won’t work on Android with 5.8 are causing me a headache.

On the other hand, although I’ve been using Qt+Widgets on the desktop for many years, this is my first mobile app with Qt+QML and I’ve got to say, I’m very impressed with it. The development process has been (a few niggles aside) an enjoyable and productive one.

Thomas Kranz says:

Hey Tuukka,

I absolutely love the part about paint command streaming. How does this play out with some backend code transpiled from C++ via Emscripten or, in the future, compiled straight to WebAssembly? If we can map all widget rendering to WebGL and the non-GUI part entirely to JavaScript, we could potentially have most of an existing QML/C++ based desktop running inside a browser without proprietary technologies like [P]NaCl, correct? This is basically what we’ll need here in the not-too-far future – however, having to use electron or implement all that stuff using Chromium in some form on the desktop, with HTML/CSS based GUIs and WebChannel for the front-end/back-end interaction is pretty cumbersome as of today.

Totally looking forward to this! Thank you for all your efforts!

Tuukka Turunen Tuukka Turunen says:

@Thomas: Some more details and videos about streaming in another blog post: http://blog.qt.io/blog/2017/02/22/qt-quick-webgl-streaming

David Šmíd says:

Are there any preliminary plans for Qt 6 ?

@David: Time for Qt 6 could be in 2019. We want it to be highly source compatible, so that it is straightforward to migrate from Qt 5. As discussed in the post, there will be many nice Qt 5.x releases still to come with room for great new features.

Thomas Gulbrandsen says:

Hi, Tuukka!
Is there a chance that TableView/TreeView of Qt Quick Controls 2 will be released with Qt 5.9?
I am realy waiting for those two.

Regards,
Thomas Gulbrandsen

J-P Nurmi J-P Nurmi says:

Hi Thomas,

We’ve been working on a next generation TableView, on the side of other things, since October. The biggest challenge is that the Qt Quick item view framework was originally designed for a single-dimensional flow of items. In order for TableView to perform well with more than a few of columns, it must recycle delegates in both dimensions. That is, the item view framework needs some refactoring to add support for multiple columns. Furthermore, we need support for things like multi-selection and multiple delegate types in the same view. There is still a lot of work left to do, because there is basically nothing in Qt Quick Controls 1 that can be re-used in this area. Given that the feature freeze was already in the beginning of February, the next generation TableView won’t be available in Qt 5.9, unfortunately.

https://bugreports.qt.io/browse/QTBUG-51710
http://lists.qt-project.org/pipermail/development/2017-January/028344.html
https://codereview.qt-project.org/#/q/project:qt/qtdeclarative+branch:wip/itemviews,n,z

Luke Parry says:

Really nice overview of features and planned developments coming.

The past two weeks I’ve done pretty much a crash course on the new Qt3D facilities and the QtQuickControls v2 for the desktop. Generally a very good experience, and a very rapid turnaround for an application we are developing.

I think some effort could be spent to improve the Qt3D documentation a bit more. I had to use their manual test examples in the GitRepo to figure out basic things like creating a custom RenderGeometry, and also simple things like ObjectPicking. These would really help make learning alot quicker. Otherwise, Qt3D is really promising.

@Luke: Thanks for the feedback. I do agree that especially for the harder areas like 3D we should provide more tutorials and extensive documentation.

miksuh says:

Instead of just creating new features for the Qt, which ofcource is nice and important too, you really should also improve wery much the accessibility of Qt. I am talking about the accessibility with screen readers like Orca on Linux. Improving the accessibility of Qt would be wery important so that blind users and developers like me could better use Qt and develop apps using it. Currently the state of accessibility in Qt is not so good.You also REALLY should improve the accessibility of QtCreator. QtCreator should work well with Linux’s Orca screen reader and with other screen readers too. Currently it does not. Sure QtCreator sort of “works” but it is really far from being really accessible and usable for the application development if you are blind like I am. I used to develop Qt apps for the Symbian, MeeGo Harmattan and Sailfish, so I do know to use QtCreator. But I am blind now and it is really frustrating that Qt and QtCreator are not really accessible.

Second thing whic you really should do is to work with Jolla so Qt would officially support Sailfish OS.

Frederik Gladhorn Frederik Gladhorn says:

@miksuh we did a round of accessibility bug fixing for Qt 5.9, although this time it was mostly macOS bugs. I’d like to hear more about what the actual problems with Qt Creator are, I’m sure we can improve the situation. Consider contacting us at accessibility@qt-project.org so we can get things sorted out. We need good reports of what is not working correctly and what is most important to improve.

Albert says:

All i see in not providing patch releases are excuses. CI doesn’t let you release 5.8.1? Come on… You’re severely hurting yourselves for not providing patch releases, people on see regressions that are never fixed, they don’t care for new features they don’t have a use for if the things that used to work are broken.

@Albert: We are providing typically 1-2 patch releases for every feature release of Qt, more for LTS release. I fully agree that patch releases are important to users, and so does everyone at The Qt Company. We are working hard to make creation of patch releases more efficient, including significant improvement in the CI system capacity coming later this year. With these in place, we can reach the situation we want to be and create patch releases regularly from Qt 5.9 onwards.

Fabirhe says:

Unfotunately it seems that some of upvoted serious problems at qt bugtracker are being ignored for long time. And are not considered to be fixed in this roadmap. I talk from dev side about QML data model index unsafety due to architectural drawbacks. And many unfixed upvoted bugs with QML components.

Bartel says:

About the ahead-of-time compilation for QML files: Does this mean the Qt Quick Compiler will be fully integrated in the open-source Qt 5.9? So concerning performance, when using QML/Qt Quick, there is no added gain having a commercial license?

Does the 5.9 Alpha already contains this ahead-of-time compiler?

@Bartel: The new ahead-of-time compilation approach will be a technology preview with Qt 5.9, so for deployment it is recommended to use either the caching released already with Qt 5.8 or the commercial only Qt Quick Compiler, if you have a commercial license.

Tonu Jaansoo says:

I implemented Qt backend that streams GL commands and data over websockets to browser. It works. But even though I use huffman compression, simple UI takes some bandwidth. Using application in a browser will pull down about same amount of data when viewing youtube (have some animations, some texture uploads)
I am waiting to see Qt5 supporting emscripten. 🙂

Vincent says:

Is a package manager for Qt planned? Or prompt package managers for Qt like qpm?

Thulio Bittencourt says:

Are you planning to change the open-source license again in future versions, including v6?

As for the new Qt resource adherents, would it be possible to join the NoSQL format as well? Adding a new plugin with similar or similar support added to SQL?

arBmind says:

“We may also be offering pre-built binaries for VS2017 with Qt 5.9 (depending on when VS2017 is released).”

This is unnecessary. VS2017 uses the same runtime as VS2015. If you fix the issues with the new compiler the code can link against the binaries built for VS2015.

Commenting closed.

Get started today with Qt Download now