We are thrilled to announce the release of Qt 6.8, packed with support for new desktop, mobile, and embedded platforms, hundreds of improvements, and exciting new features to boost your development experience and meet the needs of demanding applications.
Check out the highlights here:
For this release we have focused on improving and stabilizing existing functionality. With over 500 bug fixes and performance improvements since Qt 6.7, your existing code will run better without changing a single line. On macOS, Qt Quick applications now integrate with the native menu bar, and for a native Windows 11 look they can use the new Fluent style. Resizing Quick windows is snappier on macOS with Qt 6.8, and on Windows the application start-up time has been improved by changing the default font database to DirectWrite.
Several modules that were under technology preview have been completed: Qt Graphs, Qt HttpServer, and Qt GRPC are promoted to be fully supported from this release on. Thanks to the feedback from our users we were able to finish those modules with substantial improvements since their initial introduction as technology previews.
For commercial users, Qt 6.8 is long-term supported, and with this release we are switching from 3 years to 5 years of support and maintenance. In addition, we support the creators of software products with the upcoming Cyber-Resilience Act regulations in the European Union by providing Software Bill of Material (SBOM) documents for Qt libraries in the SPDX v2.3 format, with information needed to improve software security.
Deploy to new Platforms, Architectures, and Devices
By upgrading to Qt 6.8, you can make your existing mobile application available to users running iOS 18 or Android 14.
Developing for Windows on Arm is now fully supported, enabling users to target the new Microsoft CoPilot+ PCs launched this year. Your desktop application can be deployed to macOS 15, and also Linux desktops on Arm. This completes support in Qt for the Arm architecture across all device categories, from embedded to mobile and desktop.
As a completely new category of devices, you can now create applications and user experiences for Apple Vision Pro and Meta Quest 3 XR headsets. For device creators we have added support for Raspberry Pi 5 and NVIDIA AGX Orin, as well as a number of SoCs from our technology partners at NXP, Toradex, and STM. With the StarFive VisionFive 2, Qt 6.8 supports a single-board computer based on the new and increasingly popular RISC-V platform.
Build Smaller and Leaner Qt Applications
With Qt 6.8's Configure Options, developers can fine-tune Qt for performance and efficiency, precisely catering to the specific of their applications. By removing unused features and components from the Qt framework, applications can reduce ROM usage by up to 77%, lower RAM consumption by 32%, and launch significantly faster.
Read our walkthrough of reducing the binary size of the coffee-machine example, and the documentation about building an optimized Qt for more information.
Qt Graphs: Fully Supported for 3D Data Visualization
With Qt 6.8, Qt Graphs is now fully supported, offering developers a powerful toolkit for creating interactive and dynamic 2D and 3D visualizations. Whether you're working on scientific simulations, financial charts, or real-time data analysis, Qt Graphs provides the rendering capabilities and performance optimizations needed to bring your data to life. Qt Graphs 3D now supports transparency in Bars3D, and gives more control over label margins, title positions, and grid line rendering. Qt Graphs 2D can render custom bars using QML components, supports Stacked and StackedPercent bars, can display labels on bars and titles on axis, and has more data mapping APIs.
We have unified the theming API for 2D and 3D graphs, and moved Qt Widgets specific APIs into a separate Qt Graphs Widgets module, so pure Qt Quick applications do not need to link against Qt Widgets anymore. For more details on the changes we made to Qt Graphs while it was under technology preview, see Sami's blog post.
Users wanting to migrate from Qt Charts or Qt DataVisualization can find migration guides in our documentation.
Qt Multimedia: Custom data and audio post-processing
Qt Multimedia has been a cornerstone for building media-rich applications, and in Qt 6.8, we've made it even better. With QVideoFrameInput, QAbstractVideoBuffer, and QAudioBufferInput, applications can send custom media data into a recording session, and with QAudioBufferOutput, decoded audio data can be received for post-processing.
On Linux desktops, QScreenCapture now supports the Wayland compositor, using the ScreenCast service via the XDG Desktop Portal.
Qt Quick: More Effects and Scalable Vector Graphics
Qt Quick continues to be a go-to module for building fast and fluid user interfaces. In Qt 6.8, we've made several performance optimizations to enhance rendering speed, especially for complex scenes. The Qt Quick Effect Maker learned about glow and masked blur, can animate sprites, and bend items into a circle or arc. This means smoother animations and better responsiveness in resource-intensive applications.
A key addition in this release is the Qt Quick Vector Image module, which enables the seamless integration of SVG files as scalable vector graphics within Qt Quick scenes. This is a perfect option for developers looking to create resolution-independent and responsive UI elements, ensuring that your designs look sharp and consistent across different devices and screen sizes. In the Qt Quick Shapes module, the ShapePath element can now take any texture provider item to fill the shape, applying an arbitrary transform.
Read more about the improvements in vector graphics in Qt 6.8 in Eskil's dedicated blog post.
QQuickRenderTarget has gotten new APIs that give developers more control over texture handling, and make it easier to integrate Qt Quick 3D with external engines, frameworks, and APIs.
TableView now allows programmers and end-users to move columns and rows, and Image and BorderImage types can retain the previous image until a newly set image is loaded asynchronously.
Qt Quick Controls: Better integration into the desktop
Qt 6.8 adds an implementation of the Fluent WinUI3 design system as a Qt Quick Controls style. That new style makes application look and feel native on Windows 11, but is implemented using Qt Quick primitives and is available on all platforms.
On macOS, the Quick MenuBar and menus integrate by default with the native menubar of the system. Context menus and other popups can be made into top-level popup windows as well, which is now the default behavior for Qt Quick dialogs on desktop platforms. Applications can use the new popupType property to control this for each popup.
New XR Module: Powering Immersive Experiences
With the growing importance of virtual, augmented, and mixed reality applications, we are excited to introduce a new module in Qt 6.8 dedicated to supporting XR devices. The new Qt Quick 3D Xr module makes it easier for developers to build immersive experiences for virtual reality (VR) and augmented reality (AR) platforms, ensuring Qt remains a top choice for application developers no matter the target device.
The new module implements support for spatial input via hand tracking and controllers, as well as for spatial anchors and locomotion. This allows users to interact with a Qt Quick 3D-built environment when using Apple VisionPro, or an OpenXR device such as the Meta Quest 2 and 3.
For optimal rendering performance in a head-mounted display, we have completed the support for multi-view rendering in the Qt Quick scene graph, in our standard Quick items and materials, and in the Qt Shader Tools build system integration.
Qt Quick 3D: Improved Shadows and Material enhancements
Qt Quick 3D 6.8 renders better shadows by using cascaded shadow maps and percentage-closer filtering soft shadows.
Technical artists can adjust the Fresnel through new properties of PrincipledMaterial, and apply masking based on the vertex color attribute. Custom materials now support the same properties as PrincipledMaterial.
Networking with Qt Network, Qt Network Auth, Qt GRPC, and Qt HttpServer
QNetworkAccessManager can now send HTTP requests over a local socket, and applications can use the QFormDataBuilder for easy creation of multi-part HTTP messages.
In the Qt Network Auth module, we have made many improvements and addressed many issues based on input from users. In addition, the new QOAuthUriSchemeReplyHandler class allows handling of private/custom or https URI scheme redirects, and Proof of Key Code Exchange is supported by the QOAuth2AuthorizationCodeFlow class.
QDnsLookup learned about TLS Association records, and can now send DNS over TLS, and informs the client whether the DNS server has performed any verification on data authenticity.
The Qt GRPC and Qt Protobuf modules are now fully supported and have a stable API, with added support for streaming.
Other Enhancements Across Modules
In addition to the major additions above, we’ve made a series of enhancements across the framework to further streamline development. For a comprehensive list of all features, check our What's New in Qt 6.8 documentation page.
Qt Core
The new QChronoTimer integrates with std::chrono and improves the precision of time-based operations. In hot code paths, QString, QByteArray, and QList can now resize without data initialization.
QHash now supports heterogenous lookups for some Qt types, notably QString and QStringView, and QDirListing provides an iterator-based API for directory entries:
using F = QDirListing::IteratorFlag;
QDirListing dirList(u"/sys"_s, QStringList{u"scaling_cur_freq"_s},
F::FilesOnly | F::Recursive);
for (const auto &dirEntry : dirList) {
QFile f(dirEntry.filePath());
if (f.open(QIODevice::ReadOnly))
qDebug() << f.fileName() << f.readAll().trimmed().toDouble() / 1000 << "MHz";
}
Developers targeting the Android platform can use the QtJniTypes namespace to declare Java types with their JNI signature, and rely on compile-time signature generation when interfacing with JNI via QJniObject. The QJniArray type makes it easy to work with Java arrays from C++ code.
Q_DECLARE_JNI_CLASS(TimeZone, "java/util/TimeZone");
using namespace QtJniTypes;
const QJniArray availableIDs = TimeZone::callStaticMethod<String[]>("getAvailableIDs");
for (const auto &availableID : availableIDs) {
// ~~~
}
And we have continued to add support for the C++20 space-ship operator<=>() to Qt value types, and floating-point geometry types such as QPointF and QMarginsF now support fuzzy comparison and null-checks.
Qt GUI
Applications developed with Qt 6.8 can now explicitly request a color scheme to override the system setting with an explicit Dark or Light appearance:
Applications can also override the context menu trigger to provide consistent application behavior across platforms.
We have made several additions to our color space support, and added more APIs for fine-grained control over the merging and styling strategy of fonts.
The accessibility framework now supports the reporting of attributes, and allows applications to raise announcement events that are picked up by assistive technologies.
Qt Sql
Users of the Qt Sql module can now specify the numerical precision policy, and a QSqlDatabase can change the thread affinity of the database connection. The PostgreSQL and MySQL/MariaDB drivers now correctly handle date and time data when the server is in a different time zone than the client.
Qt Test
Test authors can now make failing or skipped tests throw an exception, making it easier to write tests that use sub-routines. The timeout-macros now accept std::chrono literals, resulting in more readable test code.
Qt WebEngine
The new QWebEngineFrame class adds frame-specific APIs, such as printing or running JavaScript on specific frames. QWebEngineClientHints gives applications more control over the browser identifications, and QWebEnginePermission makes it easy to manage new and existing website permissions.
Qt Widgets
We have made several improvements to our rendering code for high-DPI displays so that widget-based applications look crisp on all screen types.
Tools
Our documentation generator QDoc, which interfaces with Clang, now requires minimum Clang 17. It has moved from the C-based to the C++-based APIs. This improves our ability to implement support for new C++ language features in QDoc. In addition, QDoc has been extended with a range of new commands. Check out the release notes for the specific details.
The QML Language Server now provides semantic syntax highlighting, has improved support for the JavaScript language, can generate snippets for Quick types, and give documentation hints.
Upgrade Today
With these powerful new features and performance improvements, Qt 6.8 continues to empower developers to build responsive, visually engaging, and media-rich applications across a wide range of platforms. I’d like to thank all the contributors who have helped with making Qt 6.8 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. A special Thanks 💚 goes to all of you who have helped making Qt better by reporting bugs, sending us your feedback and contributions, 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!
We can't wait to see how you'll leverage the latest version of Qt to create the next generation of apps. Upgrade to Qt 6.8 today and take your projects to the next level!
Commenting for this post has ended.
Lars knoll said in a webinar Q&A that Qt6 would get a c++ api for Qt Quick Controls...so you could create a Qt Quick Controls UI purely in c++ without using any QML. Is this still on the road map?
For the time being, we are happy that we don't have to worry about C++ binary and source compatibility in Qt Quick Controls, as it allows us to make some necessary improvements to the architecture. So, while it's still an item on the backlog of things for us to research, it's not going to be a priority for the next releases.
Wasn't this available since forever? What exactly is new in 6.8?
While the feature system has been in Qt since the introduction of support for embedded Linux in the Qt 2 days, they have been in practice untested, and any particular combination of features was primarily a matter of luck. So, while the new configure options do indeed sit on top of that old feature system, we are now adding test coverage for the most relevant and impactful combinations to our CI system, but also include target-platform specific optimisations to the build system, as outlined in the blog post at https://www.qt.io/blog/reducing-binary-size-of-qt-applications-with-qt-6.8-part-2-coffee-machine-example
In the highlights video it is mentioned that QtWebEngine and QtPdf will be removed from the LTS support and need to be updated separately if we want to use them with the LTS version of Qt. How can we actually do those updates? Are you providing patches for those updates?
Unfortunately a bug (which is in my case a major thing, because it causes a resource leak) https://bugreports.qt.io/browse/QTBUG-129898 prevents me from upgrading
This bug seems to also impact qt3d, which is awfully slow now
Can you confirm that the patch developed (https://codereview.qt-project.org/c/qt/qtbase/+/597402, not yet merged) fixes the problem?
I built Qt myself using the patch and can confirm that the issue is resolved for my case
Great news. Especially excited about QHTTPServer. A bit sad to learn that it's not possible anymore to just call .listen but now we have to mount it manually on top of TcpServer. WebSocket server which also works on top of TCP server does have expected .listen ability itself so why should user now have to deal with the fact that HTTP is done on top of TCP server and create TCP server manually? This should be an option, not an requirement.
Also docs on QHTTPserver have quite big typos: still stating it's a tehnical preview usage of tcpserver.get which doesn't exist req used while argument is request "text/plain"_ba as single argument which obviously cannot work .bind usage which doesn't exist in the docs
Normally docs are top notch so quite surprised on this one and not sure where to contribute to fix it.
Anyway, keep up the good work!
QHttpServer lives on OSI layer 7, while QTcpServer lives on level 4. Conflating those in a single API call for the sake of saving a line of code makes error handling messy and makes ownership unclear. I think requiring the TCP server to be explicitly created and configured results in more readable, debuggable, and maintainable code.
Thanks for the feedback on documentation, there is definitely room for improvement.
Why would the OSI layer be relevant for the users of the HTTP service? I don't agree that this is about saving a line of code. And how exactly this makes ownership unclear? There is a lot of internal things that HTTP server and TCP server use (or many other Qt modules; even QApplication not expecting QEventLoop to be passed) but ownership is obvious. For me it's unclear which use-cases need HTTP server and then also somehow to manage underlying TCP server so that different ownership makes sense. This just has to be minority who plan to use QHttpServer or people already doing http by std and boost. Websocket is built on top of HTTP protocol but QWebSocketServer doesn't require TCP server or HTTP server to be started first by user so this is not aligned with Qt itself. Not to mention HTTP frameworks in any other modern language these days. Hope I'm not sounding too harsh. I'm just surprised as it was there in the past as well but now I have to hold and pass a separate QTcpServer reference for the sake of implementation which for me jumps from either Qt or other HTTP frameworks usage.
For example, errors when setting up the transport layer (QTcpServer) and errors when setting up the protocol layer (QHttpServer) might have very different reasons, and require different handling and notification mechanisms. Also note that Q(Abstract)HttpServer::bind() works with both a QTcpServer and a QLocalServer, so we would in principle also need two listen() overloads to support both.
Anyway, if you feel that it's terribly inconvenient to have to set the QTcpServer up explicitly, feel free to make a suggestion ticket in JIRA, and a patch that implements what you would like to see.
Awesome. Very nice release day today, first Qt 6.8 and later KDE Plasma 6.2.
Congratulations to the KDE team to the Plasma 6.2 release! 🥳
https://kde.org/announcements/plasma/6/6.2.0/
Thank you! Everything looking good on GNU/Linux openSUSE Tumbleweed, openSUSE Leap 15.5, and Windows 10 with latest updates.
Thank you! 💚
We were told that Qt3D would be either removed or deprecated in 6.8, but there is no mention of this in these notes. Can you provide more information so that we can plan the future (or lack thereof) for our Qt3D based applications?
Hi Mark, https://doc.qt.io/qt-6/whatsnew68.html points out that Qt3D is deprecated, and that our partners at KDAB will continue to maintain it. So, best to reach out to KDAB to see what their plans are for the module.
Thanks Volker, it's good to know that it continues to exist for now. Out of interest, how many Qt features themselves are based on Qt3D internally? Like the 3D graphs, Qt Quick 3D etc... Do they go directly to the RHI back-end? Do they have their own 3D implementation? Or are they Qt3D based?
No other Qt module depends on Qt3D. E.g. Qt Graphs sits on top of Qt Quick and Qt Quick 3D, which in turn sit directly on top of the scene graph and Qt RHI.
Any plans to support custom application window title bar areas?
Also can you share a future roadmap like you've done previously?
6.8 sounds good.
Customizations to non-client areas of windows, and other modern windows behaviours such as translucency effects, is something we have started to investigate. It is naturally a bit complex across platforms and platform versions (Windows 11 provides quite a few new capabilities that we need to take into account, and in the Linux Desktop space it needs some coordination with the respective projects).
I'll nudge someone about the public roadmap. We talked about a few things at the Qt World Summit event last year, but there are definitely a lot of new and interesting things to talk about!
PS: I presented some "Beyond Qt 6.8" thoughts at the KDE Akademy 2024 (as a follow up on what we also discussed at the Qt Contributors Summit a few days before Akademy). The video recording at https://www.youtube.com/watch?v=bovuuPZxWC4&t=17610s is not excellent, but maybe it's useful anyway.
How to get the old Windows fonts behavior ?
You can select the old font engine at the command line using "-platform windows:fontengine=gdi"
For a more permanent solution, this can also be customized in the qt.conf. Similar to how freetype is selected here but with "gdi" instead: https://doc.qt.io/qt-6/qt-conf.html#configuring-arguments-to-the-platform-plugins
If you can share, I'm curious why you need this. Is it for interfacing with native code or did you see any regressions with the new backend?
I've to use old gdi engine via qt.conf. Because my app uses 33MB RAM with new engine, but 11MB with old one.
I've to use the old gdi engine too because it seems the new directwrite engine will no longer use Microsoft YaHei as default font in Simplified Chinese locale Windows. Switching back to gdi works fine again. It seems https://github.com/qt/qtbase/commit/b09fb51e7bb576137f92d4697f9f812f3dcb2b7a addressed this issue while I'm not able to test. Hope such info can be helpful for other people with the same issue.
A sample qt.conf content could be:
[Platforms] WindowsArguments = fontengine=gdiBecause we now have big fonts when migrating from 6.6.3...i suspect this is the problem but maybe not
Once you have more details, we would greatly appreciate a bug report. I don't immediately know of any changes that might have caused that.
Here are the details : https://bugreports.qt.io/browse/QTBUG-129832
Qt Graphs is meant to replace Qt Charts. But as far as I know its nice graphs can not be printed except by screen grabbing resulting in insufficient resolution. That limitation comes from the underlying Qt Quick. Are there any plans to support that, for instance to generate a PDF-report like it is possible with Qt Charts?
Printing is indeed something we plan to investigate, especially in the context of Qt Graphs but also generally for a scene-graph. Rendering a Qt Quick (3D) scene to a QImage with sufficiently high resolution might be one part of the solution, but perhaps a more dedicated rendering solution is needed (in addition).
Hi, I have developed a Qt Widget application but when compiled for Android, I get a problem on UI on the phone I can select QComboBox, QDoubleSpinBox is not editable! ....
Can you help me
This is not a support channel; you can contact your customer support team if you hold a commercial license, or report bugs by providing a reproducer at https://bugreports.qt.io
Generally, note that for touch-friendly UIs we recommend using Qt Quick as the UI framework.
Weird, this blog entry does not appear on the qt.io/blog front page
You mean other than as a featured post in the big (and somewhat dark) big banner at the top? :)
Oh....I went through the page twice, then tried filtering for month "October". Never occurred to me that the dark banner might be what I was looking for....you know
if (Q_UNLIKELY topBannerisWhatYouAreLookingFor)...
The release notes mention this:
Where should I look in order to learn more about this?
Hi Serhii. The safe area margins are automatically incorporated into the layout of Qt Widgets as long as
Qt::WA_ContentsMarginsRespectsSafeAreais set (which it is by default) andQt::WA_LayoutOnEntireRectis not set. For Qt Quick we are working on both an explicit API, as well as taking the margins into account in the built in controls such asApplicationWindow.Thanks! I got it.
what about SafeArea margins for iOS and Android ?
Safe area margins for iOS and Android are already implemented, and exposed for Qt Widgets the same way as described above. The Qt Quick API we're working on will be cross platform, including iOS and Android.
cool :) I was looking for QtQuick API and Android / iOS - never did anything with Qt Widgets ;-)
QtQuick3D Physics Joints constraints pls to Qt6.9
Any chance the OpenSSL issue https://bugreports.qt.io/browse/QTBUG-130976 will be fixed in 6.8.1? That's kinda an upgrade blocker for me
Edit: OK, seems to work for me in v6.8.1