Qt Releases

The Qt Framework consists of various modules and tools released under a common version number. In the following, we explain Qt's versioning scheme and the related compatibility promises. Finally, we present the typical release schedules, and introduce the long-term support (LTS) releases and support periods provided.

Versioning

Qt uses semantic versioning. Each release is identified by a major, minor, and patch number, separated by a dot. For instance, Qt 6.9.0.

Major releases increment the major version number, resetting minor and patch numbers to zero. Major releases feature a rework of some of Qt's functionality, module structure, and Application Programming Interfaces (APIs).

Minor releases increment the minor version number, resetting the patch version number to zero. Minor versions contain new functionality, as well as various fixes and improvements.

Patch releases increment just the patch version number. Patch releases consist of bug fixes (including fixes for possible security issues), documentation fixes, and performance improvements.

When not relevant, the patch version number is often left out. That is, when the documentation refers to Qt 6.6, the documentation applies to Qt 6.6.0, Qt 6.6.1, Qt 6.6.2, and so on.

Compatibility promises

Usually, you start developing your applications against a specific Qt version. As time passes, new Qt versions get released, and you need to update your Qt version—be it because you want to benefit from bugs fixed or features introduced in more recent versions, or because the old Qt version is not supported anymore. To aid you with this, Qt makes the following compatibility guarantees.

Source compatibility

To be source compatible means that you can compile your application unmodified against two different Qt versions. For each release, Qt aims to keep source compatibility with previous releases of the same major version. That is, an application developed against Qt 6.0.0 should still compile when built with any other Qt 6 release (though maybe with warnings due to API being deprecated).

Note that modules or APIs marked as Technical Preview, under development, or subject to change, as well as pre-releases, are excluded from this promise.

There are situations where adding new functionality or fixing issues still requires changes that might break source compatibility in minor releases. QUIP-6 lists some of these.

Binary compatibility

To be binary compatible means that you can run your dynamically compiled application against two different Qt versions. Qt aims to keep backwards binary compatibility with previous Qt releases of the same major version. That is, an application compiled against Qt 6.0.0 should still run with any other Qt 6 release, but not necessarily the other way around.

There is no universal C++ standard for Application Binary Interfaces (ABIs), so this promise only applies when using the same toolchain (compiler) and system environment for both versions. It is also valid only for dynamic builds of Qt, excludes pre-releases and modules or API marked as Technical Preview, and requires both Qt versions to be built with the same configuration.

Release schedules

Major releases of Qt happen rarely—Qt 4.0.0 was released in 2005, Qt 5.0.0 in 2012, and Qt 6.0.0 in 2020.

Minor releases of Qt happen twice a year.

For each minor release, we typically provide two or three patch releases– until the next minor release of Qt is out. Exceptions are security issues that might warrant a new patch-level release even later and Long-Term Support releases.

Long-Term Support releases

For selected Qt minor versions, The Qt Company provides additional patch-level releases for an extended period. Such additional releases are called Long-Term Support (LTS) releases, and the minor Qt version is said to be an LTS version. While the initial patch releases of such an LTS version are also available to open-source users, immediate access to LTS releases is limited to commercial customers of The Qt Company, under the commercial license.

Typically, every third minor Qt version gets additional LTS releases. The bug fixes and security updates provided in such releases, as well as the longer support period, make LTS versions a good choice for developing bigger applications.

Note that, for LTS releases, the Qt WebEngine module is treated differently: Due to parts of it being only available under LGPL, the Qt WebEngine code remains available under its default licenses.

Commercial support

The Qt Company provides commercial support for Qt. Under standard support conditions, each minor version of Qt is supported for one year, starting from the date of the minor release. For Qt LTS versions before 6.8.0, the support is extended to three years, starting from the original minor release (Qt x.y.0 release). Starting with version 6.8.0, the LTS versions are supported for five years. Even longer support can be negotiated individually.

Supported versions

Extended Support

Once the standard support is expired, the Extended Support (ES) is available for these versions: