Qt Roadmap for 2016

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!

Blog Topics: