Tuukka Turunen

Qt Roadmap for 2016

Published Monday February 22nd, 2016
68 Comments on Qt Roadmap for 2016
Posted in Biz Circuit & Dev Loop, C++, Qt, Releases, Roadmap

The year 2016 is very exciting for Qt as we will publish three important Qt releases: Qt 5.6 in March, Qt 5.7 targeting May and Qt 5.8 targeting October. I’ll walk you through the most important content of the releases, and explain the rationale behind our roadmap.

Overall Strategy and Focus Areas

The overall Qt technology strategy is based on the following main principles:

  1. High-quality cross-platform application development- reach your end users on all of their screens
  2. Powering the future of embedded devices, and with an additional focus on certain key industries
  3. Shortening the overall time-to-market with a productive development environment and ready-made solutions

As Qt is a cross-platform toolkit catering dozens of different use cases in various industries, the items we do for the horizontal offering benefit the majority of Qt users. However, we have also taken explicit steps towards targeting our product offering more towards certain key industries. An example of this is the Automotive industry with our Qt Automotive Suite product offering. In addition, we are also looking closely to other industries such as Industrial Automation, Medical, Set-top-Box/DTV and Internet of Things.

Our philosophy of industry-specific development is to adjust Qt functionality according to the specific needs of the industry but generalizing it into the horizontal Qt offering so that will benefit the whole community—for instance instead of just building a Qt CANBus API, we are building a Qt SerialBus API with a CANBus implementation, and extend the API with other implementations such as Modbus or OPC-UA.

The roadmap items planned for 2016 and further are directly based on these three principles: improving our cross-platform functionality with stable and up-to-date desktop and mobile support, extending our offering for embedded industries, or facilitating the overall development workflow with more powerful and integrated tooling.

Qt 5.6 – The First Long-Term Supported Qt 5 Release

Qt 5.0 was released in 2012 and started a new era for Qt. Qt 5 is built from the ground up to leverage hardware acceleration for amazing graphics performance, and intuitive Qt Quick for application creation, while still based on the solid and performant C++ foundation proven with the earlier Qt versions. Since 2012 we have worked hard for bringing support for leading mobile platforms, extending the feature set, enabling efficient device creation, as well as improving tooling and maturity of the framework.

Long-Term Support with Qt 5.6

Qt 5.6 is the first Long-Term Supported (LTS) version of Qt since Qt 4.8. As part of our LTS promise, we guarantee that Qt 5.6 will be supported for three years via standard support, after which additional extended support can be purchased. During this time period, even though following Qt releases (Qt 5.7, Qt 5.8 and so on) are available, Qt 5.6 will receive patch releases providing bug fixes and security updates throughout the three-year period after the release.

With Qt 5.5 (released in June 2015) we had a strong focus on improving quality and providing feature parity between platforms, for example in multimedia and connectivity areas. Qt 5.6 is extending the same principle to provide a solid baseline especially for application development. Qt 5.6 provides support for both C++98 and C++11 compilers, just like before. The next release, Qt 5.7, will drop support for older compilers allowing to leverage C++11 functionality in the Qt modules themselves. So, for those wishing to use compilers such as VS2008, VS2010, and gcc 4.6, Qt 5.6 will be an excellent choice in the years to come.

Cross-platform High-DPI Support

One of the most important new features of Qt 5.6 is the cross-platform support for High-DPI screens, which allows applications written for standard resolution displays to be automatically scaled when shown on high-pixel-density displays. Using the new High-DPI support, Qt automatically adjusts font sizes, window elements, icons and graphics in general in a Qt application based on the pixel density. Applications can adjust automatically when the user moves a window from one display to another with a different pixel density.

We are in the final steps of getting Qt 5.6.0 released in March 2016. To learn more about what is included in Qt 5.6, check the wiki page for New features in Qt 5.6.

Qt 5.7 – A Lot of New Features and Changes in the Open Source Licensing

Leveraging C++11 in Qt Modules

Qt has supported use of C++11 in applications for a long time. With Qt 5.7 we are taking a major step and using C++11 also within the Qt libraries, allowing Qt to move forward together with the modern C++ development. Having Qt 5.6 as an LTS release enables us to provide good support for older, C++98, compilers for many years still while being able to leverage C++11 to make Qt 5.7 and beyond even better. One of the first modules taking advantage of C++11 is the new Qt SerialBus module which is built with C++11 from the ground up. Going forward, we will utilize the new features of the modern C++ language both within the existing Qt libraries and for the creation of new modules.

Overwhelming Amount of New Modules with Qt 5.7

Qt 5.7 will introduce a couple of new modules, which have been available as technology previews in the earlier Qt releases:

  • Qt Quick Controls 2 – Fully rewritten, performance optimized set of UI controls for Qt Quick applications
  • Qt 3D – Multi-threaded 3D engine for Qt C++ and Qt Quick
  • Qt SerialBus – Use various bus communication from a Qt application, initially CANBus and ModBus

There will also be two new technology preview modules included in Qt 5.7:

  • Qt Wayland Compositor TP – Multi-process support for embedded devices
  • Qt SCXML TP – Improving our state machine framework with new State Chart APIs

In addition, Qt 5.7 includes a lot of modules that have been previously available only with the commercially licensed Qt:

  • Qt Charts – Versatile set of chart types for 2D visualization of data
  • Qt Data Visualization – Versatile set of chart types for 3D visualization of data
  • Qt Purchasing – Cross-platform purchasing API for application stores
  • Qt Virtual Keyboard – Customizable virtual keyboard and handwriting recognition front end supporting multiple languages
  • Qt Quick 2D Renderer – Running Qt Quick 2 applications without OpenGL hardware acceleration

Changes in Open Source Licensing

There are changes to open source licensing with Qt 5.7. LGPLv3 was introduced as a license option with Qt 5.4 and with Qt 5.7 we are going all in with LGPLv3, no longer offering LGPLv2.1 as a license option. In addition to commercial and LGPLv3 licenses, there are options to use GPLv2 or GPLv3 for most of the Qt functionality. With this change, we are open sourcing a lot of the formerly-closed components under GPLv3 unifying the product offering for application development. As this is an important change, please check the License change FAQ or read the detailed blog post about the upcoming license changes.

We have been working on Qt 5.7 in parallel to Qt 5.6 and the feature set of Qt 5.7 is already frozen. Qt 5.7 Alpha will be released soon, and in the coming months, we will be releasing Qt 5.7 Beta and Release Candidate – according to the usual process. We are targeting to release Qt 5.7 in May 2016. To learn more about what is coming with Qt 5.7, check the wiki page for New features of Qt 5.7.

Qt 5.8 – Configurability, Optimization and Graphics Backend Renewal

We are planning a couple of very important improvements to Qt 5.8, which will be developed further by subsequent releases. The most important research and development items for Qt 5.8 include:

  • Increasing configurability
  • Optimization of memory requirements
  • Building the foundations for next generation graphics
  • Built-in Qt Quick Compiler

In addition to these, there will also be many other new features in different areas of Qt, but let’s go through the most important ones now.

Increased Configurability and Reduced Footprint

Qt 5 has a modular architecture allowing to take only the used modules into the application or device. Unfortunately, not all the modules are fully independent, so there often is need to include some unnecessary code in order to use the desired functionality. This is typically not a major issue for a desktop or even mobile application, but for embedded devices it often leads to manual work to optimize the binary size.

The intention is to create a minimal configuration for Qt Quick based devices by modifying Qt Core, Qt GUI, Qt Declarative, as well as possibly some other modules. We want to reduce the amount of dependencies and optimize the functionality in order to reduce the footprint for a low end configuration of Qt. As there are multiple different use cases, each requiring a slightly different set of features, we are also aiming to make it easier to only include the needed functionality into the application / device binary. This allows to expand the install-base of Qt powered devices and to utilize Qt technology in lower-level devices than before.

Enablers for the Next Generation Graphics

A recent trend in graphics has been enabling the use of hardware acceleration on a much lower level than before. The most important new low-level graphics API’s include DirectX 12 from Microsoft, Metal from Apple and the just released Vulkan from the Khronos group (the industry standard consortium behind OpenGL and many other well-known specifications). Qt has been pioneering use of OpenGL, and we naturally want to benefit also from the new possibilities provided by these graphics APIs.

Qt 5 graphics are tightly coupled to OpenGL, which we believe will be very important also in the years to come as OpenGL is widely available on most platforms. On Windows, we are using the the ANGLE library to provide mapping between OpenGL and the Windows’ graphics APIs. With Qt 5.8 we are aiming to remove the hard dependency to OpenGL from Qt SceneGraph and to create new backends for different graphics APIs. We do not expect this work to be complete with Qt 5.8 but to have the basics in place. This allows to leverage the latest graphics APIs and later on, also remove ANGLE from our Windows port.

Built-in Qt Quick Compiler

We introduced the Qt Quick Compiler with Qt 5.3 as a commercial-only feature. For Qt 5.8, we aim to bring a new kind of built-in Qt Quick Compiler for all Qt 5.8 users. The current Qt Quick compiler takes QML files and compiles them to native code showing a big difference in performance on operating systems where one cannot use a just in time compiler, namely iOS and WinRT. It is also very useful for improving load times of Qt Quick applications, as all of the parsing work now happens at compile time. This is especially interesting for startup times of applications and boot times of Qt based embedded devices. As a third benefit, the compiler helps to keep application source code safe, because it is no longer necessary to ship the sources as part of a Qt Quick application.

The new Qt Quick Compiler will be built into Qt Declarative providing two modes. In the Runtime mode it provides a storage (cache) of just in time compiled code on disk making second runs faster. In the Build time mode it works similar to the currently available Qt Quick Compiler, i.e. compiling QML to C++ during the application build time. Therefore, it makes also the first run faster and secures the source code better against reverse engineering.

These are a few examples of the things we are working on for Qt 5.8, but please note that none of the features is yet confirmed. During the next half a year we will be busy implementing these and other features for the Qt 5.8 release in October 2016.

Qt Creator 4.0 – New features, Modern Looks and Improved CMake Support

In addition to Qt versions, we are of course releasing new Qt Creator versions during 2016 – starting with Qt Creator 4.0 in April 2016. Many earlier commercial-only features such as Advanced Profiling, Static Analyzer and Qt Quick Designer features, will also be part of the open source version of Qt Creator 4.0. To celebrate the new major version of Qt Creator, the icon set and theme have received some polish providing modern looks. Behind the scenes, we are tuning the plug-in interface, leveraging Clang more than before and greatly improving the support for CMake.

During the coming months we will host several webinars about the key features in Qt 5.6 and 5.7. There will also be many blog posts about the new innovations in Qt, just like before. If you want to learn more, please contact our sales teams or join the discussion in Qt mailing lists and Qt Forums.

I believe 2016 is a very exciting year for Qt and I hope you agree!

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

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


Accelerated says:

Could QML Designer become stronger,powerful and bug less?
( ⊙ o ⊙ )

@Accelerated: This is certainly our intention. By merging the separate commercial and open-source Qt Quick Designers we are aiming to make it incrementally better with each release of Qt Creator.

Accelerated says:

Well,lots of developers say that the QML Designer has a lot bugs and disappointed in it.I hope it gets better like WPF Designer.

Thomas Hartmann says:

Please report as many bugs as you can, so we are aware of them (bugreports.qt.io).

Thomas Hartmann says:

What features would you like to see implemented?

Accelerated says:

Well,My focus is stable.

Drew says:

There are a handful of Nokia Qt components not yet in Qt5. I’m thinking specifically of the Organizer class from QtMobility. It let you interact with the system calendar.

Qt 5 has the Calendar class, but that’s not the same thing (it has no interface to the system calendar).

Is the Organizer functionality in the roadmap? It would be useful for an application to be able to set appointments in your calendar.

@Drew: Unfortunately Qt PIM is not under work at the moment for Qt 5.8. You need to write native code to integrate with calendars etc.

Benoit says:

It looks extremely promising, thanks for sharing! The focus on performance and the new Quick controls will make Qt even better. I really hope that the new Quick controls will bring more standards and help developing better UI while keeping the great flexibility we have with Quick items.

I also hope that the quick compiler will have a positive impact on development and detect much more errors on compile time.

Regarding future development, I personally think that an eye should be kept on supporting the new Swift programming language. While C++ is a perfect solution for Qt internals, there are many elements in Swift which makes development more efficient, safer and cleaner. And probably bring much, much more users and customers. I know that the Java binding experience was not positive but there’s clearly something to be done on that side.

Robin Lobel says:

Are you kidding? C++ is universal and support a wide variety of libraries.
Swift is the opposite. Defeats the whole purpose of Qt.

Morten Morten says:

Some Qt and Swift research has begun here: github.com/msorvig/qt-and-swift . The project is open for input.

In general I think enabling usage of Qt from any language (also those with limited scopes) is interesting, and that this does not limit Qt in any way.

Back to Swift again, I remember seeing better C++ interop as a possible roadmap item for a future release. That could be interesting for the Qt use case.

Benoit says:

Thanks for the link! Sounds interesting. I was also thinking of some generated Objective-C/C++ code with specific and/or global rules (class vs struct, nullable, non-nullable, …).

Using Qt in a Swift-based iOS application works very well in my experience but requires of course to create some helper classes in Objective-C/C++. A full integration with the Qt API would be a killer combination!

Vincent says:

Why not integrate GammaRay into Qt Creator 4.0?

Marco Piccolino Marco Piccolino says:


Jean-Michaël Celerier says:


Scorp1us says:


Slartibart says:

There’s just one thing to say: Rad!

QtUser says:

When will be supplied binaries Qt for Visual Studio 2015 compiler?

@QtUser: With Qt 5.6.0.

Daniel says:

If you’re committed to Visual Studio 2015’s compiler, are you going to support the IDE?


@Daniel: Currently the VS Add-In works only with VS2013 and below due to API changes in Visual Studio. Otherwise VS2015 can be used nicely, and there are also pre-built binaries coming with Qt 5.6.0.

Daniel says:

Sorry, Qt does not work ‘nicely’ with VS2015. You cannot create or build a Qt project inside VS2015 without the addin.

You can only use the VS2015 compiler from another IDE like Creator.

YA says:

@Tuukka: Compiler from VS15 != VS15

Therefore Qt is useless with VS15 as long as there is no qt addin for it.

And yes, we all know that there is no qt addin for it. That is why we complain about it. VS is one of the major IDEs used by many customers and it is not supported any more? Wow!

avb says:

Isn’t this what you are looking for?


Or did I got something wrong?

YA says:

@Tuukka: Did you ever tried to create, build and debug a Qt application in Visual Studio 2015? I don’t think so, so explain what the problem is.

The binaries are not the problem, the debugging and editing experience is just a mess. You have to create and maintain all the build rules for moccing the header files on your own, which is just a maintanance hell. Debugging is impossible, because there are no debugging visualizers, so you are just blind when debugging Qt code.

So you must be kidding, if you say that Qt can be nicely used with VS 2015.

@YA: Qt Creator can be used nicely with compiler from VS2015. There is currently no VS Add-In for VS2015 IDE.

YA says:

That has quite a few bugs and I do not want to rely on a third party tool whose author I don’t really know (even I am sure he/she is a trustworthy person) and the source code is not available as open source.

But it shows that it doesn’t seem to be very difficult to port the addin.

Peter Bocan says:

I wonder why do you want to release Charts library so lately? It’s due to some legal stuff or implementation changes?

Scott Brady says:

Qt Charts being released in version 5.7 is not a problem for me. I can wait. What concerns me is that it is only available commercially or as a GPLv3 licence. There will be no LGPLv3 licence offered. This for me is restrictive.

Patrick Hisni Brataas says:

You can download the source and build it yourself now from here: http://code.qt.io/cgit/qt/qtcharts.git

zack says:

Sure you can build the library yourself, but ignore the license or what?

Petref Saraci says:

You can find here some details and Q&As about the licenses options for Qt.


David Grayson says:

Will future versions of Qt still be compilable with the mingw-w64 toolchain?

Kai Koehne Kai Koehne says:

We’ll continue to support mingw-w64 in the foreseeable future. Anyhow, we also have an eye on the progress of Clang on Windows.

David Grayson says:

That’s good news! Thanks for the response, Kai.

Amir says:

It will be useful to improve QtCreator as well specially providing full c11 support for WinRT development with debugging.

Stephen Chu says:

It sounds that the new graphics backend in 5.8 will be for Qt Quick only?

Eskil Abrahamsen Blomfeldt Eskil Abrahamsen Blomfeldt says:

The current focus is on Qt Quick, yes.

Widgets are already graphics API-agnostic, but as of right now, there are no plans to implement any new back-ends. Since Qt Quick is designed from the ground up for high performance on modern graphics hardware, that is where we will benefit the most.

Joakim Dahl says:

Sounds awesome! Looking forward to the future with Qt

Daniel says:

There’s been no mention of QBS recently but plenty of talk about improving CMake integration.

Is QBS still being developed as the successor and replacement for QMake or have you guys decided to pursue CMake instead?

Jean-Michaël Celerier says:

CMake is much more future-proof.

Kai Koehne Kai Koehne says:

Working on excellent CMake support doesn’t mean that either qmake or qbs is dead. IMO we should strive to support all of them, in the best way possible.

Ionut Dediu says:

What about enabling access to the raw camera frame data (RGB or YUV), especially in Android? Currently the examples shipped with the Qt SDK only work with the QML camera component which does not provide low level access to the camera frames..A working simple example to showcase this in Android would be great. I do not think it is currently possible to achieve this

vlada says:

Are you working on a solution for using Linux libraries in Android? There is a problem with library versions, which I described here: https://forum.qt.io/topic/61091/porting-program-to-android

I couldn’t find any solution for this and I do believe the problem is in QtCreator which links to different library then which is added to the final APK.

Pablo Rogina says:

@vlada, I’ve just replied to your post in the forum. It looks like your problem is the way you’re building your native library and not related to Qt or Qt Creator at all.

Jakob says:

When will the C++ Api grant access to “Maps and Navigation”? See http://doc.qt.io/qt-5/location-maps-cpp.html

saito says:

God news! Excellent! Qt chart is very attractive, but,
Where has the start-ups license gone?

Roumed says:

Is there any news about Qt Speech?
The last one was at Qt 5.6 New Features: “Qt Speech (postponed to 5.7)”, and still nothing more.

@Roumed: Unfortunately Qt Speech was not ready at the time of Qt 5.7 feature freeze. You can get the current code from: http://code.qt.io/cgit/qt/qtspeech.git to try it out.

Roumed says:

Am I right, that the main purpose was a TTS engine interface implementation, not STT (Speech To Text)?
Are you planning to add this feature later?

@Roumed: The existing implementation is for Text to Speech. We have been doing research and a bit of implementation also on the speech recognition part using 3rd party recognition engines.

Hossein says:

Seems to be a great roadmap for the future. Thank you guys!

One thing I want to mention is the Qt in Linux distributions. I was hoping that Qt 5.6 LTS would be included in Ubuntu 16.04 LTS, but it seems that it will not.


I think it deseveres a push from you guys!

@Hossein: Qt 5.6.0 was not available in the time window for Ubuntu 16.04 content.

Markus says:

Are there any plans to update the MinGW and GCC versions to a current version? When running the mingw-w64 installer on windows, I get version 5.3.0 – that makes version 4.9.2 which is bundled with Qt look quite old. Or are there any specific reasons not to use the latest MinGW/GCC?

As far as I can see from the release notes, the most significant change would be a big step forward in C++14 support – which would IMHO be loved by many users of Qt!

Kai Koehne Kai Koehne says:

We’re aiming for shipping newer mingw-w64 packages with gcc 5 in Qt 5.8.

Jake says:

[L]GPLv3 – ’tis a sad day for Qt. Looks like 5.6 will be the last truly usable version.

@Jake: If you are unable to use Qt under LGPLv3 license, maybe a commercial license is a good option for you?

archqt says:

what is the problem with this licence ?

Andre Fernandes says:

I would like to see a Qt interface to Haskell, as I do use it a lot more than C++

Juy says:

Qt paid too much attention on technicals, but rarely on its practical applications. You have positioning class, but don’t support google maps. You have embedded B2Qt, but don’t support Sumsang or Qualcomm cpus. You have Android version of Qt, but don’t support google services. So you have everything, but in one half. What we need is a full solution even in one particular application area.

Mihail Naydenov says:

Some of these you mention have legal issues, like the Google services.

Scorp1us says:

The Qt short comings I’d like to see addressed:
– push notifications (iOS/Android/OSX)
– background services (iOS/Android)
– better misc mobile platform integrations (Wake lock, application events)
– Better feature parity between platforms.

zjzengdongyang says:

GCC in the android NDK is now deprecated.Could you change to use clang in android?Or use crystax ndk?
In https://bugreports.qt.io/browse/QTBUG-50724

Sunny Sachanandani says:

Right now each new release of Qt Creator is linked against (and includes) the latest stable Qt version. Will future releases specifically target the LTS version of Qt. Also will it be possible to one day link against the version of Qt that’s provided by a Linux distro instead of including your own.

Mihail Naydenov says:

Sounds great, keep up the good work.
Now, on the OT: Please remove (/extend) the timeout for posting comments here!!!
I check the bog every week or two and the comments are most of the time already closed!
Just right now I was no longer able to express my joy about Vulkan support/Khronso contribution! Thanks.

Commenting closed.

Get started today with Qt Download now