Qt for Python release: 6.10 is here!

This release primarily focuses on integrating the extensive new features introduced in Qt 6.10, while simultaneously addressing several refinements across both PySide6 and Shiboken6. Key improvements include enhanced support for @QEnum and @QFlag decorated enumerations, which can now be utilized as properties for custom widgets within Qt Designer. Additionally, significant performance optimizations have been implemented for the invocation of overridden Python functions, and various type hinting issues have been resolved. These enhancements, among other updates, contribute to a more robust and efficient development experience.

In case you haven't checked all the changes in Qt for 6.10 check them out. 

Simplified Python bindings from CMake 

With this new release, we are excited to announce a long requested feature, mostly for people creating hybrid applications mixing C++ and Python.

The new Shiboken6Tools CMake package, introduces the shiboken_generator_create_binding function, simplifying the CMake code necessary to generate Python bindings for their C++ libraries.

Previously, integrating Shiboken into your CMake project required manual scripting for getting certain PySide and Shiboken paths, direct manipulation of the Shiboken binary, and careful management of include paths and linker flags leading to lengthy and error-prone CMake code. 

The new Shiboken6Tools CMake package eliminates this complexity. Now, you can simply use a CMake function to configure and generate your bindings, with all dependencies and paths handled automatically. You can get an idea of the usage in the following snippet:

For more information on how to use the new Shiboken6Tools CMake package, check out the documentation and the refactored sample binding example.

Note: You will have to add ${Python_SITELIB}/shiboken6_generator/lib/cmake to the CMAKE_PREFIX_PATH as seen in the SampleBinding example to find the Shiboken6Tools package. You can avoid the manual intervention, by using a modern build backend like scikit-build-core where it would automatically find the Shiboken6Tools package from the site-packages of the Python environment. 

Boosting Shiboken 

Shiboken is both a helper Python module and binding generator at the core of the Qt for Python project by being in charge of the Qt bindings generation to create the PySide module. Here are a few highlights for this release.

• std::optional support

Support for std::optional has been improved, by adding an automatic conversion from T to std::optional<T> in cases where std::optional is specified in the type system.

Template specializations like std::optional<int> can now be specified as primitive types with converter code, removing the hassle of manual intervention via custom snippets.

• Python initialization

Shiboken now generates code to use the new multi-phase python initialization model of Python  (PEP 489) which is the basis for the on-going research of new Python features such as sub-interpreters (PEP684) and free-threaded Python (PEP703). For deployed applications, the previous approach is still available due to missing Nuitka support.

• Shiboken Cross compilation

Shiboken's support for cross compiling has been extended as a by-product of the ongoing iOS-research. Various options have been added to shiboken to be able to specify target platform and compiler to ensure the Clang-based parsing of C++ headers works correctly. Most options can be conveniently set to values of the corresponding CMake variables, for example:

iOS support (in progress) 

Significant initial progress has been achieved in establishing comprehensive PySide6 support for iOS. We have successfully implemented cross-compilation capabilities for iOS, enabling the generation of platform-specific libraries. At present, non-graphical Qt modules, including QtCore and related components, have been enabled and are operating as intended within the iOS environment.

Current development efforts are focused on extending this foundation to incorporate graphical Qt modules and enable full UI rendering capabilities on iOS devices. This ongoing work represents a critical milestone in expanding PySide6's platform coverage, mostly based on the latest achievement of getting Android as a supported platform. This effort will facilitate the development of feature-complete Python-based applications for Apple's mobile ecosystem.

Considering the current development state, this feature is aimed for future releases, but we wanted to community where some of our efforts are going.

A future alongside Qt Bridges 

You might have read the recent posts on Qt Bridges, a new project that is being developed in order to bring Qt to more languages, in a more idiomatic way, from which you might be wondering, how does that related to Qt for Python, so we wanted to explain a few decisions and directions of the project, so you can make the right decision on picking the right solution for your project.

The Python bridge, from the Qt Bridges project, is currently implemented on top of a few components that you might be familiar from PySide and Shiboken, meaning that we are not reinventing the wheel with regards a few technical decisions like data transformation, abstractions, and interaction with QML.

In the future of the Python bridge, the dependencies on Qt for Python will be reduced in order to have a smaller footprint for your applications.

The Python bridge is designed for Python developers that are unaware of Qt, and want to easily connect a Python backend to UIs using Qt Quick. You might think of it as re-thinking the development of PySide applications, but from a Python point of view rather than the usual Qt-based approach.

Both the Python Bridge and Qt for Python are projects that will continue co-existing by having different use cases in mind, and most likely a different user base. We mention this, because most of the Qt for Python team is currently working on this new initiative, so we are very excited to let you know more.

If you are interested in this project, stay tuned for the technical preview that will be available in the following months.

When will Python 3.14 be supported?

As you might have seen, 6.10 supports up to Python 3.13, and does not include the recently released 3.14 version.

The main motivation behind this is the compatibility that we try to keep during the whole lifetime of minor releases, and even though mostly was working with the recent RC, we didn't have enough time to test everything in the final release from two days ago.

We expect to support it Qt 6.11, by addressing all the issue we have recently discovered.

Please note that free-threaded Python is something that is still being researched, and has been very challenging due to the fact that a GIL-less Python requires us to implement our own locking mechanism to work well with the Qt event loop.

Getting Qt for Python

As always, you can get the latest version by running:

pip install pyside6

or if you are a commercial user:

qtpip install pyside6

Let's stay in touch!

We want to keep trying new experimental support, features, and Python module integration. What should we do next? Drop us a message or open a suggestion on JIRA 👍. 

We hope you enjoy the release, and as always, drop by our community platforms and let us know if something is not properly working by opening bug reports.