Qt 6.3 released

I’m happy to announce that Qt 6.3 has been released today. As always, the release is packed with many new features as well as a large amount of bug fixes. 


Let’s start with bug fixes. The quality of Qt and our releases is something we consider extremely important. While a large framework as Qt can never be free of bugs, we are constantly aiming at keeping that number as low as possible. We are putting a lot of effort into fixing bugs reported through our bugtracker, and improving the coverage of Qt with automated tests.

Since the release of Qt 6.2, we fixed a total of 1750 bugs that have been reported by our users. All those bug fixes are part of the Qt 6.3.0 release, leading to a significantly improved quality for Qt 6.3.

We will of course continue to have a strong focus on quality and provide further bug fixes to upcoming patch level releases, both within the Qt 6.3 series as well as our 6.2 LTS releases.

New features

But we haven’t just worked on bug fixes and quality. Qt 6.3 also comes with a decent set of new functionality. A total of 250 user stories and tasks implementing new functionality have been completed for 6.3. Those are of course too many to list individually, and if you want to have all the details, have a look at our new features page and our Release Notes.

Let’s have a look at some of the highlights.

Qt Quick Compilers

The new Qt Quick Compilers are one of the big new features we’re introducing with Qt 6.3. This is something we’ve been working on for quite a while now. Many of the changes we did on the QML side for Qt 6 were laying the foundations for the new compilers, and I’m very happy, that we can now make the compilers available to you as a Technology Preview.

The new QML compilers consist of two tools, the QML Type compiler (qmltc) and the QML Script Compiler (qmlsc). The first one compiles QML types to C++, significantly speeding up instantiation of QML types. The second one compiles functions and bindings to C++ where it makes sense, giving significant performance improvements when evaluating functions and bindings in QML.

It aims to compile functions and bindings in QML into C++ code whenever possible. As QML is a dynamically typed language, this doesn’t make sense if we can’t determine all types at compile time. In that case, the compiler falls back to compiling the methods into byte code similar to the old qmlcachegen.

Using these compilers, we can achieve significant performance improvements for bindings and functions that can be compiled into native code, as shown in the graphs below.

Binding evaluation performance increases substantially, in the examples above bindings can be evaluated between 20 and 35% faster than without the compiler.


For those of you who are interested in all the details, we have published a series of blog posts about the technology. Have a look here for the generic introduction, here for an in-depth view, and finally here for more detailed benchmark results. Note that some parts of the Qt Quick Compiler solution are available only with certain types of commercial licenses.

Qt Quick and Qt Quick Controls


In Qt 6.3, we also added a couple of new Qt Quick Controls. Two of them have been available as standalone components in the marketplace previously. We chose to integrate them into our set of standard Controls to make them available to all our users. TreeView and Calendar are both commonly requested functionality and will also make it more attractive to build desktop applications using Qt Quick.


In addition, we added two new dialogs, FolderDialog and MessageDialog. Those two dialogs will use the system dialogs where available (on desktop and mobile platforms). On other platforms Qt provides those dialogs with a platform dependent theming.

Finally, we have done some significant work to improve the performance of our text components (Text, TextEdit, TextArea, TextInput) in Qt Quick. Previously, passing a very large document to the text controls could use up a rather large amount of memory and lead to slow drawing performance. This has been fixed in Qt 6.3, but ensuring the backend only ever renders the part of the text that is currently visible on the screen.

Qt Quick 3D

Also Qt Quick 3D has seen a couple of new features. Most notable are probably the new support for reflections.

Reflections are implemented using the ReflectionProbe QML element. The probe is positioned in the scene, where it captures the surrounding environment and saves it in a cube map. That map can then be used by other elements to show reflections. Have a look at the blog post about the feature for more details.

The particle system has also gained a couple of new features, find out more in the separate blog post here.

The new ResourceLoader element gives you more control over resource management in Qt Quick 3D and allowing you to pre-load large resources such as meshes or textures and helps avoiding that they get unloaded if they are currently not visible in the scene.


With Qt PDF, Qt 6.3 adds another module that has been missing since we moved to Qt 6. It is available as a Technology Preview in 6.3. It covers the same functionality as Qt PDF in 5.15, and we have some new functionality planned for the module for 6.4.qtpdf

Other improvements

We’ve made a huge number of smaller improvements in Qt Core. A large part of those are adding convenience to our string classes. Additional features are support for ISO639-2 language tags in QLocale, AM/PM specifiers when converting times to strings in QDate, QTime and QLocale, easier conversion between JSON and CBOR, QtFuture::whenAll() and whenAny() methods and many other smaller improvements.

Qt Network can now be queried for the transport medium that is being used and whether the transport is metered.

Qt Positioning now allows you to query the accuracy of the obtained position on Android and iOS. Qt Bluetooth now exposes BTLE service data as part of the device information and now correctly reports the adapter state on Windows.

We’ve also worked on many improvements for Qt Widgets, with a focus on high resolution displays, styles, styling with stylesheets and itemviews.

On the build system side, there are quite a few improvements to our CMake support in Qt 6.3. The most notable one is the new  function qt-generate-deploy-app-script(), that greatly simplifies the generation of a deployment script for the application on different platforms. Other improvements are additions to handle the QML type and script compilers, support for multi-ABI builds on Android and generation of a default launch screen on iOS.


Qt 6.3 is a great step towards the next releases, Qt 6.4 and our next LTS release for the Qt 6 series, Qt 6.5. We have some great plans for those releases, that include amongst other things full support for WebAssembly, a QHttpServer, gRPC support, an FFmpeg based cross-platform backend for Qt Multimedia, Qt Speech, Qt Location, and better native Look&Feel on Windows 11 and iOS support. For more detail you can also have a look at our blogpost about the  Qt 2022 roadmap. 


Finally, I’d like to thank everybody that has helped make Qt 6.3 happen. You can find a full list of all contributors at the end of the release notes, but there are also many others that have helped by reporting bugs or keeping our servers and infrastructure running.

As always, the new release will be available in the Qt installer. You can also get the release from our download page or your Qt Account page.


Blog Topics: