Qt 6.10 Released, with Flexbox in QML

October 07, 2025 by Volker Hilsheimer | Comments

Qt 6.10 is now available, with new features and improvements for application developers and device creators!

Highlights for UI builders include a new flex-box layout system for Qt Quick, and support for more vector animations in SVG and Lottie format. And we have listened to your feedback and made it easier to exchange data between C++ code and a Qt Quick UI developed in QML. Such data can then be used with the new SearchField control, or with a new FilledSurface graph from the Qt Graphs module.

If you prefer to maintain your existing codebase, upgrading to Qt 6.10 ensures your application automatically aligns with high-contrast system settings on both desktop and mobile platforms. This and other improvements in our accessibility implementation directly benefits users reliant on assistive technologies, improving usability and inclusivity without requiring any additional development effort.

In addition to these highlights, new APIs across the Qt modules bring increased flexibility and productivity for both QML and C++ developers, and for users of Qt Widgets and Qt Quick.

Check out the highlights here:

Accessibility Improvements

High contrast mode has become a key feature across major operating systems for improving visual clarity and usability. With the release of Qt 6.10, we’re aligning our built-in styles with platform-specific contrast settings. This makes your applications visually consistent with the rest of the user experience, and more accessible to a wider user base. In addition, you’ll have it easier to comply with various accessibility regulations.

Read Oliver's blog post for more information about the support for high-contrast mode in our different built-in styles.

We have also reviewed and refined how Qt widgets and Quick controls present themselves to assistive technology clients like screen readers, and have improved the integration into the underlying platform, in particular for the WebAssembly platform. Many of those changes will also find their way into upcoming patch releases of LTS branches, so make sure you stay up-to-date.

Build UIs Easier

Qt Quick keeps evolving and embracing new technologies to support faster development and iterations. With Qt 6.10 we bring new ways to make your UI more responsive, look more modern, and reduce custom code with a new Quick Control.

Flexbox Layout

Qt has for a long time provided a variety of layout types, which automatically arrange user interface components within a user interface. Qt's layouts are particularly well-suited for creating responsive and resizable interfaces, which is great when building user interfaces that have to run on a variety of platforms, with different screen sizes and aspect ratios. It also makes it possible to build a single user interface that can get translated to languages with varying text lengths, or where users might prefer different font sizes.

With Qt 6.10, a new FlexboxLayout type joins the existing layout types in Qt Quick. Qt's FlexboxLayout provides functionality familiar from CSS's Flexible Box Layout, while integrating tightly with the concepts familiar from Qt Quick's layout mechanism, such as attached properties to configure the behavior of individual items in the layout.

The FlexboxLayout is a technology preview for now, and we are looking forward to your feedback to our implementation and API design. We designed the type to make it particularly quick and easy to create responsive user interfaces, while keeping it performant at runtime.

Animated Vector Graphics

Over the last couple of releases, we have steadily improved support for vector graphics, both in the Qt Quick scene graph and the Qt Quick Shapes module, and in Qt's ability to handle SVG images. In Qt 6.8, we introduced the VectorImage element and the svgtoqml tool, both of which make it trivial to feed vector graphics content directly into the Qt Quick scene graph.

With Qt 6.10, we are adding support for animated vector graphics, for images in either SVG or Lottie formats. The support for Lottie files has generally improved, and the Qt Lottie module will now support a much larger range of modern Lottie files. With direct support of Lottie in the VectorImage type, you can now render Lottie files as scalable and hardware-accelerated vector graphics.

For more details, read Eskil's blog.

New Quick Control: SearchField

The new SearchField control is a specialized input field designed to use for search functionality. Like all Qt Quick controls, it is a implemented for the various built-in styles, and provides a native look and feel on all major platforms.

SearchField { id: colorSearch suggestionModel: colorFilter anchors.horizontalCenter: parent.horizontalCenter }

The SearchField shows relevant data from model in a popup, filtered by the text typed into the input field. The model data can be provided by any of the existing mechanisms for getting data into QML, but we have added a number of improvements for exchanging data between backend code in C++, and Qt Quick UIs code written in QML.

Integrate Data into your UI Easier

Integrating C++ data models into QML and Qt Quick UIs has long been a powerful yet sometimes complex part of building Qt applications. Qt offers several mechanisms — like singleton objects, QAbstractItemModel, context properties, and QObject-based bindings — to bridge the gap between backend logic and frontend presentation. However, building a complete and performant two-way integration can involve a fair bit of boilerplate code.

Based on your feedback, we’ve been working to streamline this process and make it more intuitive. Here are some highlights of the recent improvements that make connecting C++ and QML smoother, more efficient, and more developer-friendly.

QRangeModel

One of the new classes in Qt 6.10 is QRangeModel, a lightweight and versatile QAbstractItemModel implementation designed to expose C++ ranges—such as std::vector, std::array, or any iterable container—directly to item views in Widgets, and to QML and Qt Quick views. Whether the data consists of simple values like integers, or more complex types like Q_GADGETs or std::tuples, QRangeModel automatically generates appropriate roles and makes the data accessible in delegates without requiring boilerplate model code. For example, a std::vector<int> can be wrapped in a QRangeModel and used in a Qt Widgets UI like this:

std::vector<int> values = {1, 2, 3, 4, 5}; auto model = new QRangeModel(values); QListView *listView = new QListView; listView->setModel(model);

When used with gadgets, QRangeModel automatically exposes each property as a named role, allowing QML delegates to bind to them using required properties. For example, consider a gadget representing a labeled value:

struct LabeledValue { Q_GADGET Q_PROPERTY(int value MEMBER value) Q_PROPERTY(QString label MEMBER label) public: int value; QString label; };

You can create a model from a std::vector like this:

std::vector<LabeledValue> data = { {1, "One"}, {2, "Two"}, {3, "Three"} }; auto labeledValues = new QRangeModel(data);

And in QML, you can use required properties in the delegate to bind to the model roles in a type-safe way:

ListView { model: modelProvider.labeledValues delegate: Item { required property int value required property string label width: ListView.view.width height: 40 Text { anchors.centerIn: parent text: label + " (" + value + ")" } } }

This pattern eliminates the need for manual role handling or context properties, and works seamlessly with compiled QML. This makes it easy way to bridge modern C++ with QML, without any boilerplate implementation of QAbstractItemModel.

For all the details about QRangeModel, read my blog post and the API reference documentation.

Write changes back to the model with delegateModelAccess

So far, in order to write the model from a delegate, you had to either require the model object and write through that, or use context properties rather than required ones.

ListView { delegate: TextInput { required property QtObject model text: model.label onEditingFinished: model.label = text } }

While this works, it does not compose well with the recommendation to use required properties in order to transfer model data to delegates. In Qt 6.10 you can write through required properties into the model if you set the view's new delegateModelAccess property to DelegateModel.ReadWrite.

ListView { delegateModelAccess: DelegateModel.ReadWrite delegate: TextInput { required property string label text: label onEditingFinished: label = text } }

This works with all views provided by Qt: Instantiator, Repeater, ListView, GridView, TableView, TreeView, MapItemView, and Repeater3D.

Two-way Bindings with Synchronizer

Two-way or multi-sync bindings have often been requested. In Qt 6.10, the Synchronizer element was introduced. With a Synchronizer, you can make sure that multiple properties hold the same value as far as possible, while still not breaking bindings in either of them. Before Synchronizer you generally had to have a binding and a signal handler to synchronize a control to a model value, and this only worked for controls implemented in C++.

delegate: Row { id: delegate required property int value required property string label SpinBox { value: delegate.value // Extra signal, only for input onValueModified: delegate.value = value } Text { text: delegate.label } }

With Synchronizer, you only need one element to perform the synchronization, it works for any number of properties to be synchronized, and the targets can be implemented in C++ or QML.

delegate: Row { id: delegate required property int value required property string label SpinBox { Synchronizer on value { property alias source: delegate.value } } Text { text: delegate.label } }

Synchronizer is in Tech Preview for now. You can find it in the Qt.labs.synchronizer module.

QML TreeModel

Making tree data available to Qt Quick UIs has so far required the implementation of a QAbstractItemModel. With QRangeModel it is now easier to expose tree data structures from C++ to Qt Quick UIs without implementing the entire model from scratch, but implementing such a data structure in C++ is still a bit of work. For many use cases, smaller data sets, and UI prototyping, it is sufficient to declare the tree data structure directly in QML.

With the new TreeModel QML type in Qt 6.10 it is easy to declare a tree data structure directly as a QML document inline in Qt, with arrays and dictionary syntax familiar from JSON, and key-value pairs for the item data.

import QtQuick import QtQuick.Controls import Qt.labs.qmlmodels ApplicationWindow { visible: true width: 500 height: 500 TreeView { id: treeView anchors.fill: parent selectionModel: ItemSelectionModel {} model: TreeModel { id: treeModel TableModelColumn { display: "checked" } TableModelColumn { display: "size" } TableModelColumn { display: "type" } TableModelColumn { display: "name" } TableModelColumn { display: "lastModified" } rows: [{ checked: false, size: "—", type: "folder", name: "Documents", lastModified: "2025-07-01", rows: [{ checked: true, size: "24 KB", type: "file", name: "Resume.pdf", lastModified: "2025-06-20", }, { checked: false, size: "2 MB", type: "folder", name: "Reports", lastModified: "2025-06-10", rows: [{ checked: true, size: "850 KB", type: "file", name: "Q2_Report.docx", lastModified: "2025-06-15", }, { checked: false, size: "1.2 MB", type: "file", name: "Q3_Plan.xlsx", lastModified: "2025-06-18", }] }] }, { checked: false, size: "—", type: "folder", name: "Pictures", lastModified: "2025-05-30", rows: [{ checked: true, size: "3.5 MB", type: "file", name: "Vacation.jpg", lastModified: "2025-05-15", }, { checked: false, size: "2.1 MB", type: "file", name: "Family.png", lastModified: "2025-05-20", }] } ] } delegate: TreeViewDelegate {} } }

SortFilterProxyModel

With all these ways to get and update data into QML and the Qt Quick UIs, one missing piece was to sort and filter this data directly from within QML. On the C++ side, QSortFilterProxyModel has been around since the early days of the model/view framework. With Qt 6.10 we are bringing much of that sorting and filtering goodness to QML, with a declarative and bindings-friendly API.

ListModel { id: colorModel ListElement { color: "blue" } ListElement { color: "green" } ListElement { color: "red" } ListElement { color: "yellow" } ListElement { color: "orange" } ListElement { color: "purple" } } SortFilterProxyModel { id: colorFilter model: colorModel sorters: [ RoleSorter { roleName: "color" } ] filters: [ FunctionFilter { component CustomData: QtObject { property string color } property var regExp: new RegExp(colorSearch.text, "i") onRegExpChanged: invalidate() function filter(data: CustomData): bool { return regExp.test(data.color); } } ] }

Read more about the QML SortFilterProxyModel in Santhosh's blog post.

Keep Your Product Modern

Operating systems evolve, and users expect that they can run their favorite software on an updated device and latest versions of their systems software.

Improvements for Android Developers

Qt 6.10 includes a number of enhancements that make targeting the Android platform more developer-friendly, adds support for latest Android versions, and makes it easier to create a good first impressions for your app.

Android 15 & 16 Support

With Qt 6.10 we official support Android 15 and 16. This includes updates to the build system and support for 16K pages, allowing you to to target the most up-to-date Android devices. The support ensures that Qt applications remain stable and performant across the evolving Android ecosystem.

Qt Jenny 1.0

Qt Jenny 1.0 is a new tool that simplifies the integration of Android Java APIs into Qt applications. It acts as a code generator for JNI glue code, allowing developers to automatically generate Qt C++ APIs from annotated Java classes. Qt Jenny consists of a compiler and an annotation processor, enabling access to Android native services like BatteryManager, PowerManager, and AudioManager from Qt code. The generated code utilizes QJniObject, and also supports notifications, which are quite complex to implement via JNI. Qt Jenny is available via Maven Central, and examples are included in Qt Creator and online documentation to help developers get started quickly.

Improved Splash Screen Handling

Since Android 12 introduced a default splash screen API, Qt apps had to take care of not ending up with double splashs — first Android’s, then Qt’s. With Qt 6.10 we provide examples and guidance for creating a smooth transition from the Android to the Qt splash screen. This involves using a dedicated SplashActivity, customizing themes for translucency, and launching the Qt activity only after Android is ready. The result is a more polished and consistent startup experience, especially for cross-platform applications.

macOS & iOS 26

Qt 6.10 is the first minor release of Qt since macOS 26 "Tahoe" left beta just a few weeks ago. For the last few months since the announcement in June we have been working on making sure that Qt applications look good on the latest versions of macOS and iOS.

The new Liquid Glass design system, and changes to the underlying rendering architecture on macOS, provided us with a few challenges, and we're happy to list macOS 26 as a fully supported platform in Qt. Many improvements will find their way into upcoming patch releases of LTS branches as well, and macOS 26 will also be supported by the releases of Qt 6.8 and Qt 6.5.

Qt WebView with WebView2 Support on Windows

On Windows, Qt 6.10 adds a WebView2 based implementation to the Qt WebView module. Qt's WebView module makes it easy to embed UI elements built using web technologies into the native Qt application, using the native browser engine rather than the Chromium based Qt WebEngine. With the WebView2 plugin, Qt WebView can now use Microsoft Edge as the rendering engine, making it possible to deploy such applications to Windows without shipping Qt WebEngine.

Better Audio with Qt Multimedia

On Linux systems, PipeWire is a modern Multimedia framework and provides improved performance and latency, better control and handling of content processing and hardware, and support for containerized applications. Qt Multimedia now provides a backend for this system. In addition, we implemented audio pitch compensation, giving end users better audio when playing accelerated or slowed-down tracks.

Embedded Target Hardware Update

Device creators will find that Boot to Qt now supports Yocto 5.2 "Walnascar", and that we have added hardware adaptations for a range of Ezurio Nitrogen boards.

All the Other Goodness

With Qt Quick 3D in you can now easily bake lightmaps for higher quality rendering at high performance, and make particle effects run in reverse to create the effect of rain or snow colliding with your models. Qt Graphs adds a filled surface type, better support for multiple axis and customizable z-ordering in 2D, and rendering of a slice of a 3D graphs into a printable image. Qt Widgets makes it easier to implement custom delegates and to control drag'n'drop support in item views, and the size constraints of layouts can now be configured individually. Qt 6.10's virtual keyboard includes Latvian keyboard layout, and Qt Core has a number of improvements for working with locales, XML documents, and continuation chains.

You can find a complete list of new APIs and features in our documentation.

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

Upgrade Today

As always, the new release is available through the Qt installer. You can also get the release from our download site or your Qt Account page.

---

Blog Topics: