Category: Software Development

What’s new in Qt 6.10? A developer’s overview

Thorsten Geppert Leave a comment

Qt 6.10 is one of those releases that doesn’t radically change how you build Qt applications, but smooths out many edges that mattered in day‑to‑day work: accessibility, layouting, vector animations, data integration between C++ and QML, and developer ergonomics around models and bindings.

Here is a structured overview of the key changes in Qt 6.10, based on the official release information.

Accessibility: High‑contrast and assistive tech

Qt 6.10 makes a noticeable push on accessibility:

  • High‑contrast mode across platforms:
  • Built‑in styles now better respect system‑level high‑contrast settings on major platforms.
  • The goal is for Qt applications to visually align with the rest of the OS environment while improving readability.
  • As an application developer, you get better contrast behavior essentially “for free” when users enable high‑contrast mode at the OS level.
  • Improved integration with assistive technologies:
  • Qt Widgets and Qt Quick Controls have been refined to present themselves more cleanly to assistive technology clients such as screen readers.
  • The WebAssembly platform in particular benefits from better accessibility integration.
  • Many of these changes are also being back‑ported to LTS branches via patch releases.

In short: Qt 6.10 helps you get closer to accessibility requirements without forcing you to add platform‑specific hacks everywhere.

Qt Quick: FlexboxLayout and modern UI building blocks

Qt Quick continues to evolve as the main UI technology. Qt 6.10 introduces several notable features.

FlexboxLayout (Tech Preview)

  • New FlexboxLayout type for Qt Quick, inspired by CSS Flexbox.
  • Benefits:
  • More natural behavior on screens with varying sizes and aspect ratios.
  • Less custom layout code for responsive UIs.
  • Familiar mental model for developers coming from web/CSS.
  • Integration:
  • Integrates with the existing Qt Quick layout system (attached properties etc.).
  • Currently a technology preview, so the API may still change before the next LTS release.

Animated vector graphics (SVG & Lottie)

Qt 6.10 builds on the vector/SVG improvements introduced in earlier 6.x releases:

  • VectorImage (introduced in 6.8) is extended:
  • Supports animated vector graphics in
    • SVG format, and
    • Lottie format.
  • Qt Lottie module:
  • Improved support for modern Lottie files.
  • Lottie assets can now be rendered as scalable, hardware‑accelerated vector graphics directly in the Qt Quick scene graph.

For designers and UI developers, this makes it much easier to bring rich motion design from tools like Figma/After Effects (via Lottie) into Qt applications.

New Quick Control: SearchField

  • Specialized control for search input.
  • Provides:
  • Native look and feel on all major platforms, like other Qt Quick Controls.
  • A built‑in suggestion popup driven by a model (e.g., QAbstractItemModel or QML models).
  • Works particularly well with the new data/model helpers described below.

Making C++ ↔ QML data integration easier

Bridging C++ backend logic and QML/Qt Quick UIs has always been powerful but sometimes verbose. Qt 6.10 adds several features to reduce boilerplate.

QRangeModel: use C++ ranges directly as models

  • QRangeModel is a lightweight QAbstractItemModel implementation designed to expose C++ ranges (e.g. std::vector, std::array, or other iterable containers) as models.
  • Capabilities:
  • Handles both simple values (ints, strings, …) and more complex types (GADGETs, std::tuple, etc.).
  • Automatically defines roles for the data it exposes.
  • Works with both Qt Widgets views and QML/Qt Quick views.

In many common cases, this removes the need to implement custom QAbstractItemModel subclasses just to show a C++ container in a view.

delegateModelAccess: writing back to the model is less awkward

Previously, writing from a delegate back into the model often required:

  • Directly accessing the model object in the delegate, or
  • Using context properties and custom signal/slot code.

In Qt 6.10, views can set delegateModelAccess: DelegateModel.ReadWrite, which allows required properties in delegates to write back into the model directly. This fits nicely with the recommended pattern of using required properties for model data and reduces glue code in larger QML UIs.

Synchronizer: two‑way and multi‑way bindings

  • New Synchronizer element (Tech Preview, in the Qt.labs.synchronizer module).
  • Purpose:
  • Keep multiple properties in sync as far as possible, without breaking their individual bindings.
  • Works with properties implemented in C++ or QML.
  • Practical impact:
  • Common patterns like “control ↔ model value” can be expressed declaratively without extra signal handlers.

QML TreeModel

  • New TreeModel QML type for declaring tree data structures directly in QML.
  • Targeted at:
  • Prototyping,
  • small datasets,
  • and situations where a full C++ tree model layer would be overkill.

Taken together, these features make the boundary between C++ backends and QML frontends more comfortable to work with.

Qt Graphs: new FilledSurface graph and more

Qt Graphs continues to evolve in Qt 6.10:

  • New graph types and refinements:
  • One notable addition is the “FilledSurface” graph type, useful for visualizing filled surfaces.
  • Better integration with Qt Quick and the new layout/vector features.

If you are already using Qt Graphs, it is worth checking the module‑specific release notes for details.

Other improvements and platform updates

As always, Qt 6.10 comes with a wider set of refinements:

  • Platform integration:
  • Official support aligns with current versions of major desktop, mobile, and embedded platforms (see the release note and wiki for specifics).
  • Bug fixes and polish:
  • Numerous bug fixes across modules (Widgets, Quick, Network, etc.).
  • The detailed release notes for 6.10.0–6.10.2 list the low‑level changes.

Conclusion

Qt 6.10 is not a disruptive release, but it addresses many things that matter in real projects:

  • Accessibility (high‑contrast mode, assistive technology integration) gets first‑class treatment.
  • Qt Quick gains modern layout and UI capabilities with FlexboxLayout, animated vector graphics, and the SearchField control.
  • C++↔QML integration becomes less verbose and more declarative, thanks to QRangeModel, delegateModelAccess, Synchronizer, and TreeModel.

If you are already on Qt 6.x, Qt 6.10 is especially interesting if:

  • accessibility and regulatory compliance are relevant,
  • you want richer, animated UIs using vector/Lottie graphics,
  • or your current C++↔QML integration feels heavy on glue code.

References

  • Qt Blog: Qt 6.10 Released! – https://www.qt.io/blog/qt-6.10-released
  • Qt Wiki: Qt 6.10 Release – https://wiki.qt.io/Qt_6.10_Release
  • Qt Documentation: New Features in Qt 6.10 – https://doc.qt.io/qt-6.10/whatsnew610.html