Qt 6.7 is out with lots of large and small improvements for all of us who like to have fun when building modern applications and user experiences.

Several additions are released as technology previews, and we are looking forward to your feedback so that we can get everything ready for the next LTS release!

Check out the highlights here:

Use C++20 with Qt

C++20 is still opt-in and experimental for many compiler toolchains, and for the time being we don't see any reason to require C++20 to build or use Qt. However, we want our users to be able to use the new standard as much as they like in their own code. Some of the changes made between C++17 and C++20 might require adjustments to existing code, and they required adjustments in Qt. For Qt 6.7 we have continued to make adaptations that make Qt feel like a natural part of a modern C++ stack.

One helpful addition to the C++20 language is the three-way comparison operator<=>(), also known as the "spaceship" operator. When implementing this operator, types are required to specify their ordering category. In Qt 6.7, we have added Qt::{strong,weak,partial}_ordering classes as C++17-compatible implementations of the respective std::*_ordering types. For type authors, Qt 6.7 provides helper macros that can be used to implement relational operators. These macros will expand to operator<=>() in C++20 builds, and fall back to all six operators in C++17 builds.

A useful addition to the standard library in C++20 that we wanted to use ourselves, and also make available to Qt users, is std::span. As a non-owning representation of a contiguous sequence of objects, a span is cheap to construct and pass through function calls, and with QSpan we now have a C++17 implementation of that type.

We also continued to add std::chrono support to relevant Qt APIs. Transfer timeouts in Qt Network APIs can now be specified as std::chrono types and literals, such as 5s for 5 seconds.

Qt Graphs with support for 2D and 3D visualizations

In Qt 6.6 we introduced a first technology preview of Qt Graphs as a modern Qt 6 framework for visualizing data on top of a hardware accelerated rendering architecture.

With Qt 6.7, we are adding support for 2D bar, line, and scatter graphs, in addition to the 3D visualizations that have already been available since Qt 6.6. The module integrates with Qt Quick animations and effects, and provides theming, and handler-based interaction APIs.

Qt Graphs is still under active development, and continues to be a technology preview for this release. We have made some substantial improvements to the data API and architecture to reduce the amount of memory allocations, and to integrate consistently with Qt's abstract item model. We expect additional architectural and API improvements before we take it out of technology preview for Qt 6.8 LTS, and are looking forward to hearing about your use cases and wishes so that we can make sure that we can accommodate them in the best possible way.

Connectivity, protocols, and distributed architectures

Developers of distributed systems can now work more efficiently with HTTP and REST APIs with the introduction of QHttpHeaders, QRestAccessManager, and QRestReply as new classes for REST-specific use cases.

Qt gRPC has introduced new classes for client, server, or bi-directional streaming calls, allowing for seamless messaging that get triggered automatically on value changes. The new Interceptor API makes it possible to add callback functions for selected gRPC messages, for instance to implement caching or logging. With Qt Protobuf in Qt 6.7, developers can now serialize Protobuf-messages to and from JSON, and benefit from generator improvements that support optional fields, and preserve the casing of enum values.

These new features make it easier for developers to build robust and scalable applications with Qt. Qt gRPC and Qt Protobuf will graduate from technology preview in the Qt 6.8 release, when the work to complete support for HTTP/2 has been completed.

Vector Graphics

Since its introduction, Qt SVG has supported the static features of the SVG 1.2 Tiny profile. That particular profile has over the last years become less and less relevant, and authoring tools have for a long time not followed any specific profile. For Qt 6.7, we analyzed which static elements from SVG 1.1 and 2.0 are commonly used in SVG assets, and added support for those features that we encountered most frequently: <symbol>, <marker>, <pattern>, <mask>, and the various <filter> elements. With Qt SVG in 6.7, applications can render the majority of SVG files relevant for UI builders.

If full support for SVG 2.0 is required, then the Qt WebEngine module continues to be the right choice.

In addition to importing SVGs as pre-rendered pixmaps into Qt UIs, we are also working on importing vector graphics assets directly into the Qt Quick scene graph. The new (and experimental) svgtoqml tool converts SVG to QML, and we have made improvements in the Qt Quick Shapes module to render in higher quality. The curve renderer introduced as technology preview in Qt 6.6 is now fully supported, and can be enabled using the preferredRendererType property.

Improvements to Fonts and Icons

After introducing support for typographic font features in Qt 6.6, we have followed up with support for variable fonts in Qt 6.7. Variable fonts combine variations of a single type face into a single font file, allowing applications to select any value of "weight" or "cursiveness." Depending on what variable axes the font designer creates, a glyph might be animated or show different layers. Read more about the variable font support and other text improvements in Eskil's blog post.

The API is now stable and consistently uses the new QFont::Tag class for specifying font features and axis names in a type-safe fashion.

The improved support for modern fonts has enabled us to add support for native icon libraries, which are often provided through fonts. The QIcon::fromTheme implementation now maps the XDG icon name to the corresponding symbol in the native icon libraries on Apple, Windows, and Android platforms. For the future we plan to use the new capabilities of our font API to add support for more icon features, such as outlined or filled versions of an icon.

Hybrid applications with native UI elements and rendering

On both desktop and mobile platforms, applications often need to combine UI elements from different technologies and frameworks. Qt uses and integrates tightly with the native technologies on each platform to create basic UI elements such as windows, and it has for a long time been possible to use UI elements from other frameworks within a Qt Widgets application.

With Qt 6.7, we are now adding support for embedding native windows into a Qt Quick scene as well. This allows use of native controls such as AppKit's MapView or a Windows media player inside a Qt Quick UI, with correct positioning and stacking. By layering windows, Qt Quick UI elements can be overlaid on top of the native components as well.

In addition, applications can now add rendering code, using any of the graphics APIs supported by Qt, to a Qt Quick or Qt Widgets application, by using the QRhiQuickItem and QRhiWidget classes, respectively. While such code might often not be fully cross-platform (as Vulkan, OpenGL, Direct3D, or Metal are not equally well supported on all possible target platforms), it makes it possible to integrate 3rd party frameworks that use those technologies, or to write highly optimized rendering code for any specific platform.

Updated Platform support

As with every minor release we have updated the list of supported platforms to include the latest stable versions of relevant operating systems. On desktop and mobile, Qt 6.7 fully supports macOS 14 and iOS 17, Windows 11 23H2, and Android 14. RedHat 9.2, Open Suse 5.15, SUSE Linux Enterprise Server 15 are the latest supported Linux distributions (Ubuntu remains on 22.04). Prebuilt binaries for Windows using the LLVM-based MinGW toolchain are available from the installer, and Windows and Linux on ARM are both available as technology preview.

On embedded, the Boot2Qt reference images support Yocto 4.3 Nanbield. As real-time operating systems, Qt 6.7 now includes a source-only technology preview for VxWorks 7 using SR 24.03 on iMX6 hardware, and pre-built binaries for QNX 7.1 are available from the online installer.

New and improved examples and demos

In addition to improvements in the framework, we have curated the examples and demo applications that ship with Qt, and refreshed the UI and coding style. We also created a few new applications that showcase what is possible when designers and developers work together to combine the UI, visualization, and backend capabilities of Qt.

The Lightning Viewer example uses Qt Location and Qt Quick Controls to visualize simulated lightning data, received via Qt WebSocket. The style for the controls was entirely created in Figma.

The completely recreated StocQt example uses Qt Graphs to visualize stock data based on the NASDAQ-100. The example's UI was created using Qt Design Studio, and if an API key is provided through the settings dialog, then the data is real-time information as received from the Financial Modeling Prep service.

The new OSM Buildings example combines Qt Quick 3D with Qt Positioning and Qt Network to implement a 3D viewer of buildings map data as received from the OpenStreetMap service.

Virtual assistants are becoming increasingly popular in user interfaces, and the new Virtual Assistant example shows how easy it is to bring a 3D model to life through timeline animations.

And last but not least, the new Volumetric rendering example uses the new support for 3D textures in Qt Quick 3D to implement volume ray casting.

Qt for Python

Once new functionality is added to Qt, our Python offering needs to adapt those in order to enable them for our Python users. Besides what's described here, many other changes were made to PySide and Shiboken that will be described in a follow-up post. Stay tuned!

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.7 brings many small improvements to existing classes and tools. Those additions are too numerous for this post, but you can find a comprehensive list of all additions in the documentation of What's New in Qt 6.7.

Thanks

I’d like to thank all the contributors who have helped with making Qt 6.7 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.