Qt 5.7 released

I’m very happy to announce that Qt 5.7 is now available. It’s been only 3 months since we released Qt 5.6, so one might expect a rather small release with Qt 5.7. But apart from the usual bug fixes and performance improvements, we have managed to add a whole bunch of new things to this release.

Updated licensing

Before going into the content and all the cool new features, I should mention the changes to our licensing that have been implemented with Qt 5.7.

Qt has always been available as Free Software, and will continue to be so in the future. Qt is being developed as an open source project, The Qt Company is fully committed to this, and in addition, the agreement with the KDE Free Qt Foundation legally ensures this.

With Qt 5.7, we are slightly adjusting our licensing of the Open Source version to bring it more in line with the philosophy of the Free Software movement. From this version onwards, Qt will not be available under LGPL version 2.1 anymore. Instead, Qt will be licensed under two main licenses: LGPL version 3 (and GPL version 2) for all almost all frameworks and libraries, and GPL version 3 for our tools like e.g. Qt Creator. In addition, we’re open sourcing some formerly closed Qt add-ons and tools under GPL version 3.

Unifying Qt for Application Development

The license change gives us a unique opportunity to unify our Qt for Application Development offering between the Open Source and Commercial versions. Starting with Qt 5.7, both packages come with exactly the same content.

This means that all the parts of Qt for Application Development that previously have been available only to commercial users are now available in the Open Source package as well.

The only exception is the Qt Quick Compiler where we need some more time to finish the required changes to be able to support this feature in the Open Source Edition.

Qt Virtual Keyboard – Now available under GPL!

Qt Charts

C++11

It has been possible to use a C++11 compliant compiler together with Qt (and thus use C++11 in your application) for many releases. But Qt itself didn’t make use of it except for some integration points in our API.

With Qt 5.6 being a long-term release that we will support for three years, we have taken the opportunity with Qt 5.7 to start modernizing our own code base. As one of the core strengths of Qt comes from it being a C++ framework, we want to follow the progress of modern C++ more closely.

Starting with Qt 5.7, we will require a C++11 compliant compiler to build and use Qt. This allows us to use many of the new features in Qt itself, and renew our codebase using features such as constexpr, move semantics, range-for and auto. These efforts are well under way and will continue throughout the next versions.

Apart from adding previously commercial-only modules to the Open Source version, we also have quite a bit of new content in Qt 5.7.

Qt 3D

We want to provide you the tools to create the required WOW-effect to amaze your end users. Modern UIs in many areas require the integration of 3D graphics, or even creating the whole user experience in three dimensions. In past years we’ve been improving our developer offering to make it easier for you to add this dimension into your UIs. With Qt 5.7, we are bringing in the Qt 3D module. This module has been available as a Technology Preview for two releases now, and I’m happy to announce that it has now reached the state where it is becoming a fully supported member of the Qt family!

Qt 3D complements the 3D GUI offering of Qt consisting of integration to OpenGL, Qt Canvas 3D, and Qt Data Visualization modules. Qt 3D provides you with a 3D engine, that comes with both C++ and QML APIs. It makes it a lot easier to embed and handle 3D content within Qt Applications. In general, Qt 3D is much more than just a renderer, it serves as an extensible 3D framework for all kind of simulations. The architecture and most of the development on Qt 3D over the past years has been done by our partner KDAB, a huge thanks goes to them for their work. For a proper introduction, please see the guest blog post from Sean Harmer from KDAB.

Qt Quick Controls 2

Qt 5.7 also comes with a fully supported version of our new Qt Quick Controls, the library of QML-based UI controls. Qt Quick Controls 1 were targeted at the desktop, and came with all the bells and whistles required for desktop applications. This implied an overhead that often made them too slow for usage on embedded devices.

Qt Quick Controls 2 solve these issues. They have been built from the ground up with performance and memory consumption in mind. So while they are fully usable on the desktop, they have slightly more limited functionality and e.g. don’t come with native styling integration. But they are vastly faster, and use a lot less memory than the old controls, making them ideal for many embedded and mobile solutions. Qt Quick Controls 1 are still part of the offering and a suitable API for desktop development. For instance, the Qt Quick Layouts work nicely with both of the control sets.

Architecturally, Qt Quick Controls are based on templates that allow you to create your completely own set of controls ground-up. They also come with a flexible system that allows the rapid creation of custom styles and user experiences. In addition, the existing controls come with three predefined styles:

Microsoft Windows is now a fully supported as a host platform for developing for embedded Linux. While Qt for Device Creation 5.7 does no longer support Windows Embedded, we now have full support for QNX, including pre-built binaries.

Qt Creator 4.0

Qt 5.7 ships with Qt Creator 4.0, more precisely with the new Qt Creator 4.0.2 version. Qt Creator 4.0 is a full development environment for all desktop, mobile and embedded development and now with version 4, we’ve especially emphasized the designer-developer workflow with the integration of Qt Quick Designer visual layout editor and the new Qt Quick Controls 2. Together, they provide a really nice way to rapidly create touch-based UIs for your embedded and mobile applications. Check out the separate video about the workflow from this blog post.

Qt Creator 4.0 also comes with a set of nice new features, such as Clang integration and extended QML profiler, please find the details from the Qt Creator 4.0 blog post. For the updates regarding Qt 4.0.2, please see the change files.

New Technology previews

In addition, Qt 5.7 also adds a couple of new modules as Technology Previews.

The first one is the Qt Wayland Compositor. The module makes it very easy to create your own Wayland Compositor. This is especially useful for embedded devices that require multi process support. The module has existed as unsupported technology for some time, but has had issues in both the API and implementation. With Qt 5.7, we’ve invested a lot of time and effort to clean up implementation and stabilize the API. It now comes with a full QML API and an improved C++ API with a lot of convenience. We also added a convenience API to create Wayland extensions and use them from both QML and C++. You can read more about it from the blog post from Paul.

The next new module is Qt SCXML. It’s a completely new module that makes it very easy to integrate SCXML based state machines into Qt. It builds directly on top of the Qt Statemachine framework and extends it with with both a SCXML to C++ compiler and a runtime that allows loading SCXML based state machines.

Qt Gamepad is another nice small addition. It makes it possible to ingrate gamepad support into both C++ and QML applications. It currently supports Windows, Linux, Android and iOS.

With Qt for Device Creation, we’re also introducing the first preview of Qt-based Over-the-Air (OTA) updates mechanism. For an overview of this crucial IoT-technology, please see the blog post from Gatis.

Finally, Qt 5.7 also includes a technology preview of the new Qt SerialBus module that allows you to use Qt APIs for device bus communications and protocols. It’s a generic API, but with this version it includes implementations for CAN and Modbus.

Go and get it

Finally, I’d like to give my thanks to everybody who has helped create this release. Again, a special thanks goes to KDAB for its tremendous work on Qt 3D.

“If you require a complete development environment that includes compilers and a build environment, you can download Visual Studio 2012 Express, which includes the appropriate components of the Windows SDK.”

Hi Nikita, big thanks to you for all the feedback and contributions you have provided along the way! You have been an extremely valuable early adopter. The Material style would not be as polished without your help. It’s great to see the controls already being used in real world apps.

@Ricardo: Yes, it is likely that servers are quite loaded at the moment (especially in the open-source distribution system). Also it is possible that not all mirrors are yet in sync, although this time we did have quite a lot of time for things to sync before announcing the release.

Please don’t forget to the language bindings for “scripting” languages. Python probably has it easier than Ruby since there are not many C++ people in Ruby investing time into writing/maintaining QT-based projects.

While there are bindings, and these tend to work, the maintainers tend to lag behind.

I am aware that this is a low priority issue for the qt core devs, but for me as a semi-developer, being able to use GUIs in a scripting language is very, very helpful.

Hi Sassan, we’re adding support for native platform menus, menu bars, system tray icons, and standard dialogs in Qt 5.8. The issue you mentioned with Qt Creator has been fixed in Qt 5.7.1. Meanwhile, you can avoid the error highlight by importing QtQuick.Window 2.2 before importing the controls. Sorry for the inconvenience.

@Sassan: You can pull from the dev branch the code that will eventually become Qt 5.8. Using these items that are under development is not recommended, but you can try things out and give feedback. Also note that many of the features are developed in a separate branch(es) and not necessarily merged yet to dev.

I see, thanks for the info. It reminds me the old days back in 2006 when I spent hours and days compiling Qt code base with different options and for different environments. I guess it’s better for me to just wait for 5.8 and then upgrade my QQC to 2. But I saw the features and style of QQC2 and it was fantastic, great job guys.

No, it’s not considered an anti-pattern. Originally, the QML engine wasn’t designed to handle two major versions of the same import at the same time. We’ve spent a lot of effort making it possible to mix and match the two control sets. So it’s quite the opposite, we specifically wanted to enable that use case.

Great, the best thing about Qt is that it just follows intuition, no blocking rules. If something is considered anti-pattern in Qt development, it’s not because core developers are lazy to support it, it’s because it’s just “logically” anti-pattern. I love your architecture and appreciate the effort you put on the project to keep it intuitive. I hope you always have big customers that pay you good so that you can always continue this great project and keep it perfect.

There has been discussions about replacing mingw 32 bit one with mingw 64 bit at some point but nothing agreed yet. We cannot increase amount of pre build binaries so delivering both isn’t an option and that’s why we need to agree correct release for doing that. maybe you could raise a discussion in development ml?

Hi ekke, I would also like to take the opportunity to thank you for the amazing work you have done with the series of blog posts, presentations, and articles! It’s very much appreciated how you have promoted the controls and provided valuable feedback to help us getting the controls in shape and ready for prime time.

Great release! Amazing job, you should be very proud of it. If you still have my skateboard at the office you should put it on the pool table behind you to ramp up the production value. I love the videos introducing new features but somebody please smile because I feel like I’m watching hostage negotiations “Qt uses modern c++… can Simon now go free?”. Blink in morse code if you need Snapple Icetea at the office.

I wish I could upgrade to Qt 5.7, but I can’t (due to Qt WebEngine having replaced Qt WebKit). So… what about those of us who have no choice but to use Qt 5.5.1? Can we ever expect a Qt 5.5.2 version that fixes known issues (e.g. QTBUG-46882)?

Hi. Unfortunately there won’t be Qt 5.5.2 release, sorry. Hoping you could port your code to use QtWebEngine or then you can compile QtWebkit by yourself. QtWebKit sources can be found from git or from http://download.qt.io/community_releases/ (5.6/ or 5.7/ )

GtkStyle is removed, which makes all 5.7 compiled Qt apps look non-native on most linux/unix desktops. This also applies to QtCreator 4.0.2 installed via official Qt-Everywehre-Installer. I know that desktops are not the hot new thing anymore – but a lot of developers are using QtCreator on linux/gtk based desktops.

Quote from [1]
> > > Also, please keep in mind that the GTK+ style will be removed in Qt 5.7,
> >
> > Do you know why that is going to happen?

> Basically GTK+ 2.x is going away, and because the whole styling model changed
> in GTK+ 3.x, the only way of porting QGtkStyle to GTK+ 3 is a complete rewrite
> of it (which nobody volunteered to do).

HI,
I have been cross compiling 5.6 to run on RPi3.
How exactly do I install supported 5.7 now?
Or do I cross compile it too?
Also, I don’t install and run Qt Creator on RPi3 but on my Ubuntu machine, so a Kit should be created for the target?
This might seem like beginner questions but I’d like to stress out I’m using Qt from the ancient forgotten days of Symbian. 😀

Thank you very much for the previously commercial packages. Really, thank you.

Thanks for another update. But I discovered problems with the graphical style of widgets: It seems the default operation system theme won’t be used any longer as default theme for the qt elements. I discovered this by compiling my small application, developed with Qt 5.5 and Creator 3.x!
The main problem here is, that the QFileDialog doesn’t provide the default folder bookmarks from the system any longer, like it doesn’t know they exist. This was the reason for me to go back to Qt 5.5 and Creator 3.x as long as these problems remain.