Qt 6.6 Released!

Today marks the 6th time we are releasing new functionality in the Qt 6 series, with small and large additions that make both UI and backend development more productive and fun. Several of the new features come as technology previews, and we are looking forward to your feedback so that we can get everything in tip-top shape for the next LTS release!

Let's start with some highlights for user interface developers.

Technology Preview: Responsive Layouts with Qt Quick

User Interfaces written with Qt have always benefitted from the layout system taking care of positioning and sizing the various elements. This results in resizable UIs that look good in all environments. However, until now it took a bit of manual effort to make user interfaces that adapt the layout itself dynamically, e.g. based on to the available screen space or orientation. This might involve hiding some elements and showing others, replacing parts of the layouts, or even completely re-building the layout structure.


With Qt 6.6, we are introducing a new layout element to Qt Quick, the LayoutItemProxy. With this proxy, user interface designers can create and switch between different layouts, typically by binding to geometry properties of the window, and the proxy takes care of automatically placing the user interface elements in the currently active layout structure. Read more about our solution, how it compares to other UI technologies, and how we designed our system, in the blog post about responsive layouts. To give more control over how layouts distribute their content, Qt Quick Layouts learned about uniform cell sizes for row, column, and grid layouts.

Additional new features in the Qt Quick module include support for selection modes in TableView, changing the rootIndex in a TreeView, more control over scroll-deceleration in a flickable, and automatic path simplification.

Technology Preview: Qt Graphs

The Qt Graphs module will combine the functionality of the old OpenGL-based Qt DataVisualization and Qt Charts modules into a single, modern Qt 6 framework. With this first technology preview release of Qt Graphs we are taking the initial step into that direction, focusing on the functionality currently provided by Qt DataVisualization. With Qt Graphs, applications can visualize large quantities of rapidly changing data, using a variety of visualization techniques such as bar, scatter, and surface graphs. The implementation uses Qt 6's rendering hardware interface, and sits on top of Qt Quick 3D. This way, all rendering is hardware accelerated using the native graphics system, and the 3D visualization integrates seamlessly into the scene management and interaction functionality provided by Qt Quick 3D.

Qt Graphs 6.6

The module is under active development, with research focusing on an architecture for effective and consistent data management across all use cases, and a high-performant rendering architecture for charts. Have a look at this prototype from earlier this year to get an idea about what we would like to enable with Qt Graphs:

Window Capturing in Qt Multimedia

With Qt 6.5, we introduced support for screen capturing in Qt Multimedia. With Qt 6.6 we are expanding this feature to allow applications to capture individual windows. The QWindowCapture API and it's QML counterpart provides access to the list of capturable window, so applications that want to implement screen or window sharing can easily provide end-users with a choice of windows. Window capturing support is available with the FFmpeg backend on all desktop platforms, except Wayland-based systems.

QMediaRecorder has in addition been extended with new properties for control over video quality, resolution, and bit rates.

Qt GRPC and Qt Protobuf improvements

Following the introduction of Qt GRPC and Qt Protobuf in Qt 6.5 as technology previews, Qt 6.6 brings significant enhancements to QtGRPC and QtProtobuf. New options like QGrpcChannelOptions and QGrpcCallOptions make channel and call configuration much easier. These options now support a deadline mechanism, limiting the maximum execution time of the call or stream. The new QGrpcMetadata allows users to set client metadata and read metadata returned from the server. In the new release, QtGRPC has integrated QML-type support for the auto-generated QtGRPC client classes.

In QtProtobuf, certain Qt Core and Qt GUI types can now be part of the *.proto schema. Implicitly shared data for QProtobufMessage classes allows efficient access in QML contexts. Support for google.protobuf.Any type has been added. Additionally, the oneof type, similar to a union in protobuf, enhances data modelling flexibility.

Qt WebEngine adding APIs to Access privacy and security settings

Applications that use Qt WebEngine to render web content can now use APIs to access the privacy and security settings. This gives more control about how the Chromium runtime behaves, and allows disabling unwanted capabilities. For example, the QWebEngineUrlScheme::FetchApiAllowed flag can be used to disable or enable the HTML5 Fetch API for custom URL schemes, and the QWebEngineSettings::DisableReadingFromCanvas attribute allows an application to disable reading from the canvas as a protection against finger-printing.

Another useful feature added to Qt WebEngine is support for a new chrome://qt URL, which shows a page with information about the Chromium version used.

Fine-grained rendering control for application developers

A new API in the Font type of Qt Quick allows UI builders to configure specific OpenType font shaping features, and the Qt Quick Shapes module can now use an experimental curve renderer that produces higher quality anti-aliased rendering of curves using a specialized fragment shader.

The Ghostscript tiger's tooth rendered at approximately 20x scale. Left to right: curve renderer, geometry renderer and geometry renderer with multi-sampling.

Qt's Rendering Hardware Interface abstraction provides a common, low-level API for developing code against the platform-native rendering sub-systems, such as OpenGL, Vulkan, Metal, and Direct3D, which now can also use D3D12. For Qt 6.6 we have started to open up and document the RHI APIs, with the same level of compatibility commitment as we have for our QPA APIs: source and binary incompatible changes might happen between minor releases of Qt, but not within a patch release cycle. This makes it possible for application developers to write low-level, cross-platform code that works on all relevant graphics stacks.

Similar work is currently in progress for Qt Quick 3D, where future Qt releases will give application developers fine-grained control over the render pipeline. In Qt 6.6, Qt Quick 3D already learned how to create texture data and mesh geometries procedurally from QML.

Qt TextToSpeech: Generate PCM data and easier text and voice management

Following the initial Qt 6 release of Qt TextToSpeech in Qt 6.4, one of the most frequent request we got was that the framework would be significantly more useful if it could generate PCM data with the generated speech, in addition to playing the speech on the audio device. With Qt 6.6, we have added that functionality to the QTextToSpeech::synthesize C++ API. Call that function with a lambda to receive the PCM data for further processing. Other improvements include better control over the queueing of text segments, query-APIs to find matching voices, and an API to check which capabilities the current engine supports. For more details, see the blog post.

Qt for Python: Support for asyncio and better tooling

(A follow up post will highlight more details on the Qt for Python release)

Python supports asynchronous operations through coroutines, and asyncio is the best-known package for implementing support for the respective keywords and event-loop integrations. Qt 6.6 adds support for asyncio as technology preview, making sure that Qt's processing of events does not collide with the task processing in asyncio.

Qt Creator now finds, adds, and updates existing virtual environments, installs wheels, and allows a new virtual environment for each new Python project.

Users of the Qt Installer will be able to install Qt for Python wheels as part of the regular Qt installation. In addition, commercial Qt for Python wheels will be installable easily with the new qtpip tool. Users that need to install Qt for Python wheels will be able to use qtpip as easily as regular pip to do so.

And last but not least, Qt for Python is now compatible with AArch64, which makes Qt for Python available on 64bit embedded systems.

Updated Platform support

Qt for Android now supports Android 13 and uses AndroidX by default. The Supported SDK level is now at 33, matching the Play Store requirement.

On the desktop, we have been working on Windows and Linux support for ARM architecture. The Qt 6.6 distribution does not include binary packages for those platforms, but you can make your own build of Qt 6.6 for those platforms using the same process as for x86 architecture. With Qt 6.7 we plan to make official ARM packages available for all desktop operating systems.

For Embedded systems, we have upgraded the Yocto support to the latest "Mickledore" release, and we have been working with a range of hardware vendors to provide pre-built Boot2Qt packages for NXP boards, the Renesas R-Car device, and various other platforms. Device creators that maintain their own Qt Board Support Package will benefit from enhancements in the QBSP Test Bench when making sure that Qt tests are all green.

We have continued our work with the Debian project, and established a new Qt 6 maintainer group. Thanks to this collaboration we now have Qt 6 packages available for Debian 11 and Debian 12 from the regular distribution repositories. Commercial Qt 6.6 packages are available from a Debian repository hosted by The Qt Company. Thanks to this work, both Commercial and Open Source users on Debian-based Linux systems can maintain their Qt installation using regular apt-get workflows. This includes embedded boards that are natively using Debian or Ubuntu distributions, such as the Raspberry Pi 4.

The many small things that make a big difference

The above is a list of the larger new features, and like every minor release, Qt 6.6 brings many small improvements to existing classes and tools.

Permission APIs are now available from QML, QWidget got a convenient overload to set the entire focus chain at once, and the Qt containers got assign() overloads to replace the existing payload without any memory allocations. Many Qt APIs that operate on durations now have overloads for std::chrono, so a timer can be started with a 10s literal value. Similarly, many APIs that work with time stamps now have overloads taking a QTimeZone, which can help reduce the amount of costly conversions between UTC and local time, for example when working with file dates.

In the Qt Sql module, the folks from Mimer SQL contributed a plugin for their database backend, and the MySQL/MariaDB driver learned about new connect options.

Custom or platform specific clipboard formats can be implemented again, using the new converter classes for macOS and Windows, and the Qt PDF module provides convenient classes for accessing links, get thumbnails of pages, and select pages.

Developers targeting the WebAssembly platform can enjoy faster development cycles, easier debugging, and better maintenance thanks to the support for dynamic linking and improvements to the QtLoader. We continue to work on hardening the support for dynamic linking so that applications can be deployed into production with shared Qt libraries and plugins as well.

QML source code that has been compiled no longer has to be included with the application binary, and the QML linter supports extensions for custom rules. Work on the QML language server is continuing, and will be a big step to improving the experience for QML developer in Qt Creator, or any other IDE that supports the language server protocol, such as Visual Studio Code.


I’d like to thank all the contributors who have helped with making Qt 6.6 a reality. You can find a full list of all community members that landed a patch to the Qt source code at the end of the release notes. And a special Thanks goes to all of you who have helped making Qt better by reporting bugs, sending us your feedback, or by telling us about your use cases. And last but not least, I'd like to thank everyone involved in getting the release out of the door!

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, and - as mentioned above - through Debian repositories.

Blog Topics: