Qt Changelog

New in version 5.4.1

February 25th, 2015
  • With Qt 5.4.1 we are providing a good set of bug fixes and enhancements – thanks to all the feedback and reports we’ve received.
  • Qt 5.4.1 restores binary compatibility for Qt 5.3.2 (and the Qt 5 series) on Windows. Unfortunately Qt 5.4.0 broke binary compatibility on Windows when using MSVC 2012 or MSVC 2013, which is now fixed in Qt 5.4.1, and thus it maintains backward and forward compatibility with the Qt 5 series (except for Qt 5.4.0). Qt 5.4.1 also fixes many of the known issues of Qt 5.4.0, including building Qt on Linux without dbus (QTBUG-43205). Starting with Qt 5.4.1, QtDBus is enabled for all builds.
  • Other important fixes in Qt 5.4.1 include enabling JIT by default in the Qt Quick Engine (QTBUG-43171), a couple of critical fixes to OpenGL (QTBUG-43178 and QTBUG-43318), and fixes to Mac binaries (QTBUG-42594, QTBUG-43100). Qt 5.4.1 also provides a large number of improvements to WinRT (for example QTBUG-41769, QTBUG-43862, and QTBUG-44196), and adds support for Windows 10 Technical Preview (QTBUG-43413).
  • The device creation reference stacks for embedded Linux and embedded Android have also been updated to use Qt 5.4.1. There are some improvements in functionality, for example better support for compiling projects using embedded Linux toolchains and having add-on modules built into the image included in the generated Qt Creator custom Kit.

New in version 5.4.0 (December 10th, 2014)

  • Renewed Web Story:
  • HTML5 and Web technologies have become more and more important over the last years, and we have spent the last year developing a completely renewed Web offering for Qt. The Qt WebEngine module is the result of a long-term R&D project where we adopted the Chromium Web engine for use within Qt. With Qt 5.4, it is fully supported on the most used desktop and embedded platforms. Qt WebEngine provides you with an easy-to-use API to embed Web content in both Qt Widgets and Qt Quick based applications.
  • The new Qt WebChannel module provides a simple-to-use bridge between QML/C++ and HTML/Javascript. This enables the creation of hybrid applications that use both Qt and Web technologies. Communication between both sides happens by exposing QObjects in the Web context. The module works not only with Qt WebEngine, but also with any other browser engine that has support for Web sockets.
  • As a third component, Qt 5.4 introduces a Technology Preview of a new module called Qt WebView. The Qt WebView module offers a more limited API to embed the web browser that is native to the underlying operating system for use cases where the full Qt WebEngine isn’t needed, or where it can’t be used because of restrictions coming from the underlying OS. In Qt 5.4, the Qt WebView module supports iOS and Android.
  • Together with the Qt WebSockets module introduced in Qt 5.3, Qt now has great support for many of the latest Web technologies and makes interacting with Web content very easy. Qt WebEngine and Qt WebView make it very easy to embed HTML5, Qt WebChannel creates the communication channel between Qt and HTML5 that is required for hybrid applications, and Qt WebSockets allows for an easy communication between Qt and many Web services.
  • Qt 5.4 also still contains the older Qt WebKit module. Qt WebKit is still supported, but as of Qt 5.4 we consider it done, so no new functionality will be added to it. We are also planning to deprecate Qt WebKit in future releases, as the new Qt WebEngine provides what is needed. In most use cases, migrating from Qt WebKit to Qt WebEngine is rather straightforward. If you are starting a new project that requires web capabilities, we advise that you already start using Qt WebEngine.
  • Qt for WinRT | Completing our Cross-Platform Offering:
  • The second big new feature of Qt 5.4 is the completion of our cross-platform story with the full support for Qt on Windows Runtime. Qt for Windows Runtime was already added as a supported Beta to Qt 5.3, and has now reached the state where it is a fully supported part of Qt. With Qt for Windows Runtime, you can create applications for the Windows Store, targeting both Windows Phone 8.1 and above as well as Windows 8.1 and newer.
  • This port completes our cross-platform story and we feel that Qt now supports all currently relevant desktop, embedded and mobile operating systems.
  • Graphics updates:
  • Qt 5.4 brings also a lot of other new features and improvements. One focus are has been around graphics. With Qt 5.4, we now introduce better support for high-resolution displays for our desktop platforms. The support is still considered experimental in Qt 5.4, if you are interested, check out the overview documentation.
  • OpenGL support on Windows has been problematic in a few cases, since there aren’t always good drivers available. To help with this problem, Qt now has the capability to dynamically select the OpenGL implementation that is being used at application start-up time. Qt will now choose between using the native OpenGL driver, the ANGLE’s OpenGL ES 2.0 implementation that translates to DirectX or a pure Software rasterizer.
  • Qt Data Visualization has been updated to version 1.2 including additional features such as volume rendering and texture support for surface graphs and performance improvements. Qt Charts has now been updated to version 2.0 including better Qt 5 modularization, binary packages and minor improvements.
  • Other improvements on the graphics side is the new QOpenGLWidget class that replaces the old QGLWidget class from Qt 4 and allows us to deprecate the old Qt OpenGL module as all relevant functionality can now be found in Qt Gui. QOpenGLContext can now wrap existing native contexts. You can use the new QQuickRenderControl to render Qt Quick scenes into an offscreen buffer. For more details check out this blog post.
  • Finally, Qt 5.4 contains a technology preview of our new Qt Canvas3D module, that implements a WebGL like API for Qt Quick. This module makes it very easy to use Javascript code using WebGL within Qt Quick.

New in version 5.4.0 RC (November 27th, 2014)

  • Mac OS X 10.10 is now used in packaging side
  • Android SDK is updated to 21.02
  • MinGW 4.9.1 is taken in the use
  • ICU is updated to 53-1
  • QtWebEngine is separated as its own installable binary package in the installers component tree

New in version 5.4.0 Beta (October 17th, 2014)

  • Powerful Web Offering with Qt WebEngine:
  • As the importance of HTML5 has grown we want to provide the best support for HTML5 within the Qt technology offering. The Qt WebEngine, a long-term R&D project based on the Chromium web engine has now reached fully supported version on desktop and embedded platforms.
  • Qt WebEngine provides a convenient API for both Qt Widgets and Qt Quick for using the Chromium web engine. Besides plain web viewing purposes Qt WebEngine takes full benefit of the whole Qt graphics stack integration allowing you to mix and overlay native Qt controls with web contents and OpenGL shaders. Of course, the fact that Qt provides a full application framework around the web engine makes Qt WebEngine truly an unparalled web engine API.
  • The new Qt WebChannel module acts as the bridge between QML/C++ and HTML/JavaScript allowing you to expose QObjects into the web context.
  • For platforms that do not allow distribution of Qt WebEngine as well as use cases where a full-blown web engine is not needed Qt 5.4 will introduce a technology preview of a new module called Qt WebView. It supports embedding the native web engines of the underlying operating system into Qt, and is currently available for Android and iOS. Because of this, Qt WebView also gives a convenient light-weight solution for simple web document integration. Qt WebView will be available with Qt 5.4 final as a separate add-on.
  • Qt 5.4 also contains Qt WebKit. It is still supported, but as of Qt 5.4 we consider it done, so no new functionality will be added to it. We are also planning to deprecate Qt WebKit in future releases, as the new Qt WebEngine provides what is needed. In most use cases, migrating from Qt WebKit to Qt WebEngine is rather straightforward.
  • Complete Support for Windows Runtime – Use Qt for Windows Store Apps:
  • The Windows Runtime port of Qt saw its first supported beta release with Qt 5.3. With all the feedback we have improved the port a lot and implemented most of the missing APIs. With Qt 5.4 WinRT is now fully supported as a primary deployment platform.
  • Qt 5.4 provides support for most of the Qt functionality on WinRT, including for example Qt Quick and Qt Quick Controls, Qt Quick Compiler, Multimedia, Positioning, Network (also SSL/TLS), Core and GUI. With Qt for WinRT port you are now able to target Windows Store Apps: Windows Phone 8.1 and above and Windows tablets with the Modern UI and publish your applications in the Windows Store.
  • New License Terms – Introducing LGPLv3:
  • As announced earlier, the open-source version for Qt 5.4 is also made available under the LGPLv3 license. The new licensing option allows us at The Qt Company to introduce more value-add components for the whole Qt ecosystem without making compromises on the business side.
  • Through this dual-licensing model, with Qt 5.4 timeframe we are introducing technology previews for the light-weight cross-platform WebView and the 3D Canvas. Similarly the new Qt WebEngine and Android style are available only through a commercial Qt license and under GPL and LGPLv3 for the open-source users.
  • To find out the best licensing option for you, please see the new licensing page and the downloads page.
  • HighDPI Support, Dynamic GL and Other Improvements for Windows Users:
  • In addition to WinRT, Qt 5.4 brings many other improvements to Windows users. Qt 5.4 brings support for High DPI displays. A typical 4K monitor may have 3840×2160 pixels, a logical resolution of 192 DPI, whereas older monitors have around 1920×1080 pixels at 96 DPI. Qt maintains the font point size on a 4K monitor, resulting the text being drawn as indented for a 96 DPI layout. With Qt 5.4 we have especially worked for enabling the HighDPI support for Windows – in addition to improving it in other platforms such as Mac and X11.
  • HighDPI support is still considered experimental in Qt 5.4, and needs to be enabled via an environment variable. If you are interested in the HighDPI support, check out the overview documentation.
  • Qt 5.4 brings capability to dynamically select during the application startup whether to use ANGLE or OpenGL on Windows. It is possible to use either opengl32.dll or ANGLE’s OpenGL ES 2.0 implementation in Qt applications without the need for two separate builds of the binaries. This significantly simplifies the task of creating Qt Quick applications for Windows PCs. Dynamic GL switching is not yet enabled in the prebuilt Qt 5.4 Beta binaries. In addition to these, there is a large number of smaller improvements and bug fixes for the Windows port in Qt 5.4.
  • Other Graphics Improvements:
  • There are quite many important graphics improvements in Qt 5.4 in addition to improved HighDPI support and dynamic GL switching on Windows. One of the most important ones is QOpenGLWidget, the modern replacement for the old QGLWidget class from Qt 4. QOpenGLWidget is a new widget for showing OpenGL rendered content, which can be used like any other QWidget. This also allows us to deprecate old Qt OpenGL module, as everything it does and more is now provided by the other modules.
  • Qt 5.4 also brings new QQuickRenderControl API, which allows efficient rendering of Qt Quick 2 scenes into framebuffer objects. The contents can then be used in arbitrary ways in Qt-based or 3rd party OpenGL renderers. With Qt 5.4 you can also adopt and wrap existing OpenGL contexts in QOpenGLContext. This improves the ability to embed Qt content for use in other rendering engines. In addition to other new graphics APIs Qt 5.4 brings convenient QOpenGLWindow and QRasterWindow classes as well as introduces support for 10-bit per color channel images.
  • QOpenGLContext is now able to adopt existing native contexts (EGL, GLX, …). This allows interoperability between Qt and other frameworks, such as game engines. Read more from this blog post.
  • Bluetooth Low Energy:
  • Qt 5.4 provides a technology preview implementation of Bluetooth Low Energy, which allows communication to a lot of smart sensors and gadgets such as wearables. It is initially supported for BlueZ 4 and 5 on Linux only – support for platforms such as iOS and Android will be added in upcoming Qt versions. With Qt 5.4 we implement the BTLE central role as per Bluetooth spec 4.0, i.e. at the moment you can only create the client for BTLE.
  • If you are interested in BTLE, please check the Qt Bluetooth LE Overview. We are very much interested in receiving feedback from users to be able to move beyond tech preview state.
  • Faster Startup, Smaller Deployment Packages and Native Style for Android:
  • We have worked actively to improve support for Qt on Android and there are many important new Android specific items in Qt 5.4. There is now support for QML import scanner, which helps in optimizing the package size for deployment. With the pre-generated assets cache that improves application start-up time introduced in Qt 5.3 and the Qt Quick Compiler available in the commercial editions, it is possible to start Qt for Android applications in a breeze.
  • On the user interface side we have extended the styling capabilities of Qt Quick and added support to Android style, which enables native look for Widgets and the Qt Quick Controls on Android. In previous versions of Qt it was possible to style Widgets to look native on Android only if one used Ministro. Now both the Widgets and Qt Quick Controls, i.e. buttons, sliders, progress bars and other controls and widgets you use in your application, will look native on Android by default.
  • iOS Improvements:
  • Support for iOS is improved with Qt 5.4 which contains many important fixes for iOS 8 and Xcode 6. In addition to smaller improvements and bug fixes there are also some new features such as a touch-based text selection model. Instead of the previous desktop like approach (press-and-drag), you can now do press-and-hold to select text. Qt will give you selection handles that can be dragged and a popup text edit menu, like with native apps. The edit menu can also be customized from Qt Quick controls.
  • Work has also been started to improve usage of native menus in general. In addition to the edit menu mentioned above, Qt 5.4 now uses a native pickerview menu for many of the Qt Quick Controls that have a menu attached. A lot of work has also gone into improving and stabilizing code that deals with window, screen and orientation geometry, and virtual keyboard management.
  • Support for Mac OS X 10.10, Code Signing and other Mac Improvements:
  • Our Mac users get greatly improved support for new Mac OS X 10.10 Yosemite with Qt 5.4. We have worked hard to improve and fix styling and other issues with Mac OS X 10.10 for Qt 5.4. Applications created with earlier Qt versions work on the upcoming Mac OS X 10.10, but there may be some issues in styling depending on your application. In addition to OS X 10.10 support we have fixed many customer reported Mac bugs in Qt 5.4 Beta – and we continue to provide more fixes still before the final is out.
  • One very important improvement in Qt 5.4 is support to new code signing style required by OS X 10.10 (and 10.9.5) for applications published in the Mac AppStore. These are still partially work in progress, but the initial support is included already to the Qt 5.4 beta release and polished for the Qt 5.4.0 final release.
  • Wacom tablets, Wayland, Updated Qt Creator and Other Items:
  • Support for Wacom tablets has been improved and unified across platforms in Qt 5.4 with the help and support by KDE/Krita developers. QTabletEvent now has information about which stylus buttons are pressed, rotation and tangentialPressure have consistent ranges across platforms and proximity events include the type of stylus or other tool in use. With these changes there is one less obstacle to upgrade to Qt 5.
  • Qt 5.4 now includes the Qt Wayland module. This enables you to run Qt applications on Weston, the reference compositor for Wayland. Weston and Wayland support is still in its early stages, and does not yet provide a full featured desktop environment that you get with Windows, Cocoa and xcb. However, Weston and Wayland already provide a light-weight windowing system that might be desirable to use in the embedded space. Qt Wayland module is delivered as source code only. We will continue our focus on improving our support for Wayland in Qt especially for device creation.

New in version 5.3.2 (September 16th, 2014)

  • In addition to improvements and fixes to Qt functionality it also packs Qt Creator 3.2.1 along with nice additions and patches to Qt Quick Compiler, Qt Quick Enterprise Controls and Qt Purchasing.
  • Also, with Qt 5.3.2 we are extremely proud of rolling out the new licensing tiers, now including the much-desired Indie Mobile tier. See the blog post about all the new announcements, and visit the new Qt download page for your copy of Qt 5.3.2!
  • With Qt 5.3.2 we are providing nice set of bug fixes and enhancements thanks to all the feedback and reports we’ve received! Qt 5.3.2 maintains backward and forward compatibility, both source and binary, with Qt 5.3.0 and the latest, 5.3.1, which was released this June. The list of changes can be found from the change files for each module.
  • The packages of Qt 5.3.2 also include new Qt Creator patch release, Qt Creator 3.2.1.
  • We are also releasing nice updates to a bunch of add-on modules for commercial Qt licensees, all installable through your Qt online installer. The new and exciting Qt Quick Compiler gets its first update and we are adding the long-awaited Tumbler control to Qt Quick Enterprise Controls! Here’s the overview of updates to Add-On modules:
  • Qt Quick Compiler 1.1:
  • The Qt Quick Compiler, which was introduced with Qt 5.3.1, allows you to compile your otherwise-dynamically-loaded QML files into native code reducing load-time, preventing reverse engineering and enhancing performance on non-JITting platforms. In this release we have fixed important bugs and added initial support for projects built with CMake.
  • Qt Quick Enterprise Controls 1.2:
  • Finally, the Tumbler is here! The Tumbler control is well-known in mobile user interfaces and much used in all kinds of touch-based devices. Now you no longer need to fiddle around manually with PathView & friends (as fun as it is, though!), but you can just take the Tumbler control and customize it into your needs!
  • Qt Purchasing 1.0.1:
  • The Purchasing module that gives you a convenient cross-platform in-app purchasing API is also getting a patch to improve functionality on iOS.

New in version 5.4.0 Alpha (September 9th, 2014)

  • WinRT fully supported:
  • With Qt 5.4 we will have full support for Qt for WinRT. Based on the feedback and experience we have gotten from Qt 5.3 the WinRT port has been polished and improved. For Windows Phone deployments, we have set Windows Phone 8.1 as the minimum supported version, allowing us to remove the dependency on the previously-used D3D compiler service and greatly simplify deployment to the device. Most Qt modules are now supported on WinRT, so with Qt 5.4 it is easy to bring your Qt applications to Windows Phone, Windows tablets and PCs with the Modern UI, as well as publish in the Windows Store.
  • Graphics improvements:
  • With QQuickWidget introduced in Qt 5.3 it became possible to easily show Qt Quick content inside a Qt widgets based application. Qt 5.4 introduces QOpenGLWidget, the modern replacement for the old QGLWidget class from Qt 4. QOpenGLWidget is a new widget for showing OpenGL rendered content, which can be used like any other QWidget. This also allows us to deprecate old Qt OpenGL module, as everything it does and more is now provided by other modules.
  • Qt 5.4 also brings new QQuickRenderControl API, which allows efficient rendering of Qt Quick 2 scenes into framebuffer objects. The contents can then be used in arbitrary ways in Qt-based or 3rd party OpenGL renderers. With Qt 5.4 you can also adopt and wrap existing OpenGL contexts in QOpenGLContext. This improves the ability to embed Qt content for use in other rendering engines. In addition to other new graphics APIs Qt 5.4 brings convenient QOpenGLWindow and QRasterWindow classes as well as introduces support for 10-bit per color channel images.
  • On Windows it is now possible to dynamically select during the application startup whether to use ANGLE or OpenGL. It is possible to use either opengl32.dll or ANGLE’s OpenGL ES 2.0 implementation in Qt applications without the need for two separate builds of the binaries.
  • Android Style for Qt Quick Controls:
  • We have extended the styling capabilities of Qt Quick and added support to Android style, which enables native look for Widgets and the Qt Quick Controls on Android. In previous versions of Qt it was possible to style Widgets to look native on Android only if one used Ministro. Now both the Widgets and Qt Quick Controls, i.e. buttons, sliders, progress bars and other controls and widgets you use in your application, will look native on Android by default.
  • Qt Bluetooth and BluetoothLE:
  • Qt Bluetooth now supports Bluez5. There is also a technology preview implementation of Bluetooth Low Energy available.
  • New Qt WebEngine and Qt WebChannel:
  • The biggest new item Qt 5.4 brings is the new Qt WebEngine, integrating the comprehensive web capabilities of Chromium 37 into Qt. The integration with Qt focuses on an API that is easy to use, yet extensible. We have worked hard with the new Qt WebEngine ensuring seamless graphics integration, to allow rendering of Chromium’s textures directly into the OpenGL scene graph of Qt Quick. Earlier this year we have already released Qt WebEngine with Qt Enterprise Embedded, with Qt 5.4 we are now adding support for the desktop platforms Linux, Mac OS X and Windows.
  • In addition to Qt WebEngine, Qt 5.4 introduces new Qt WebChannel module for integration of QML/C++ and HTML/JavaScript. Qt WebChannel can be used to expose QObject functionality to Javascript in Qt WebKit or Qt WebEngine.
  • Qt 5.4 also contains Qt WebKit. It is still supported, but as of Qt 5.4 we consider it done, so no new functionality will be added to it. We are also planning to deprecate Qt WebKit in future releases, as the new Qt WebEngine provides what is needed.

New in version 5.3.1 (June 25th, 2014)

  • Performance optimizations for Qt Quick Engine’s JIT compiler code generation and important bug fixes, especially on ARM (QTBUG-39289)
  • QAbstractProxyModel::sibling to now works in the same manner as with Qt4
  • Many small fixes to Qt Quick Controls, for example to TableView, TabView, ComboBox and Calendar
  • QQuickWidget now works properly also with ANGLE (QTBUG-39699)
  • Qt Quick animations now work also with static builds (QTBUG-37341)
  • Fix for a regression of QPushButton with QMenu (QTBUG-38550)
  • Fix for a regression on Mac for passing click event to underlaying widget (QTBUG-39322)
  • Initial support for Mac OS X 10.10, more improvements will land on upcoming Qt releases
  • Positioning backend now available also for Windows Phone
  • Accessibility now works on Android also below API level 18 (QTBUG-39508)
  • Fix flashing white screen at startup/shutdown on Android (QTBUG-38960)

New in version 5.3.0 (May 20th, 2014)

  • Focus on stability and usability
  • Support for new platforms
  • Tooling Improvements
  • Purchasing API
  • Compiled Qt Quick
  • QQuickWidget
  • Websockets and cloud

New in version 5.2.1 (February 6th, 2014)

  • It provides many improvements over Qt 5.2.0 as well as packages Qt Creator 3.0.1. As a patch release, it does not add new features and remains binary compatible with Qt 5.2.0.
  • Qt 5.2 introduced new iOS and Android ports, as well as a hefty amount of other new functionality. Based on the feedback received from the Qt Enterprise and Qt Mobile customers as well as the whole Qt community, Qt 5.2.1 is providing many improvements.
  • The most notable improvements in Qt 5.2.1 are numerous JavaScript and QML specific performance optimisations in the new Qt Quick Engine, as well as fixes in the iOS and Android ports. With Qt 5.2.1 we use iOS 7.0 SDK for building the Qt for iOS binaries and can now leverage the latest functionality. The binaries are still compatible with older iOS versions, so applications work on all supported iOS versions. We have also made the “Getting Started” documentation for Android and iOS and examples easier to use as well as fine tuned many other items.

New in version 5.2.0 (December 12th, 2013)

  • Qt on Mobile Is Here with Great Opportunities:
  • I am proud to say that Qt 5.2 fully brings Qt into the mobile space as a true player in the app development market supporting Android, iOS, BlackBerry, Sailfish/Jolla and Ubuntu Mobile. With this, Qt is the native cross-platform development framework with the broadest support of operating systems in the mobile space, complementing our even wider support of operating systems for desktop and embedded development. Qt 5.2 makes it very easy to take your existing desktop or embedded applications and bring it to mobile phones or tablets.
  • To show our commitment to being fully cross-platform also on mobile, we have an additional small christmas present for you. I am excited to announce that we now also have a Technology Preview of Qt for WinRT available. The preview is based on our development branch, and thus contains already a few of the new features to be found in Qt 5.3.
  • Qt on Android and iOS:
  • Most of the Qt APIs are supported with Qt 5.2 both on Android and iOS. Since these are new platforms there are, however, some exceptions. Qt WebKit is not yet supported on Android, and can’t be brought to iOS due to App Store policies. But we are working on bringing an easy way to embed web content via Qt APIs to these mobile platforms in the future. In the meantime, we recommend the use of native web elements. Qt Bluetooth and Qt NFC are also not yet supported and will get implemented in a subsequent release.
  • All of our other APIs (including Qt Quick, Qt Sensors and Qt Multimedia) are fully supported on these platforms, allowing the development of a very wide class of applications with Qt APIs only. If something is not yet supported with the Qt APIs you can also always fall back to using some of the platform’s native APIs, where needed. For Android, we provide a convenience API for using the Java Native Interface (JNI) through the new Android Extras module. For more details, you can read the blog post about Implementing In-app purchasing on Android.
  • Developing Qt applications on mobile can be done fully within the Qt Creator IDE for Android, BlackBerry and Sailfish. On iOS, the Qt Creator support is still experimental.
  • With Qt 5.2, we are also introducing our Qt Mobile edition , which we announced in October at Qt Developer Days Berlin. Qt Mobile edition is a specially tailored package for mobile app developers that will help you target the fragmented mobile markets with one technology.
  • Besides new mobile platforms we’ve also continued working hard on the existing platforms. More then 1500 bugs have been fixed since the release of Qt 5.1.1. The desktop platforms have received a lot of focus with multiple improvements all around the libraries and by bringing in platform-specific support through new modules.
  • Great Improvements for the Desktop:
  • Qt on desktop operating systems is the heart of Qt and has served as a stepping stone for the immense breadth of our operating system support throughout the years. That said a lot of improvements have happened with Qt 5.2 that are mainly targeting the desktop operating systems.
  • We’ve further improved the Qt Quick Controls for the desktop and made it easier to integrate Qt Quick into traditional QWidget-based applications
  • A lot of enhancements and bug fixes went into the Qt Widgets module
  • We added a new QKeySequenceEdit QWidget class making it easier to deal with user configurable key bindings
  • Accessibility is now fully supported on all desktop platforms (and Android)
  • Qt Windows Extras module: Integrate with native code on Windows
  • Qt Mac Extras module: Integrate with native code on Mac OS X
  • Improved time zone and locale support with QTimeZone and QCollator
  • Bluetooth is supported for Linux with Qt Bluetooth module
  • Many fixes to improve support for OS X Mavericks
  • All of these changes together make Qt 5.2 an excellent basis for your desktop application.
  • Revamped Qt QML and Qt Quick:
  • A huge amount of things have also changed under the hood. The Qt QML module has gotten a brand new engine, removing our dependency on the V8 JavaScript engine. The new engine is built from the ground up for Qt and with QML as the main use case in mind. It supports an interpreted mode, and can thus run on CPU architectures where JIT would not be available or platforms such as iOS where JIT’ing is not allowed by App Store policies. In earlier Qt versions, the integration with the V8 JavaScript engine was difficult and led to performance issues when crossing the boundary between the Qt and JS code bases. This problem has now been resolved by the new engine, which directly uses Qt data types and can quickly interact with all Qt code.
  • As a net result of these changes, you should see some performance improvements for most QML use cases. However, as Qt 5.2 is only laying down the foundation, performance when executing lots of program logic in JavaScript will be slower than with Qt 5.1. Qt 5.2.1 will bring quite some additional speed improvements and we have great plans for the engine in Qt 5.3.
  • A lot has also happened on the Qt Quick side of things. The renderer for the Scene Graph has been completely rewritten delivering much improved rendering performance for applications and freeing up more CPU time for the application itself. In addition, every QQuickView now renders in a thread of its own, ensuring that multiple scenes don’t block each other.
  • Qt Quick has also gotten support for a new animation type called Animator, which allows you to run many animations fully on the rendering thread. These animations cannot be blocked even if the main thread would be heavily loaded doing some extensive calculations.
  • Qt Creator 3.0 and Other Goodies:
  • Qt 5.2 ships together with the new Qt Creator 3.0. The new Qt Creator improves support on mobile platforms and improved stability of it’s plugin APIs. This will create a foundation for 3rd party plugin extensions for Qt Creator, something we’re looking forward to expanding more in the future.
  • A couple of new modules and APIs also made it into Qt 5.2. Most notable are probably the support for positioning with the Qt Positioning module, Bluetooth support for Linux and BlackBerry with the Qt Bluetooth module, NFC support on BlackBerry, support for time zones and Unicode collation and the new Windows, Mac and Android Extras modules.
  • Qt WebKit has also received a major update now being based on a WebKit version from this summer. This includes many new features such CSS Blending, Geolocation, Web Notifications and a threaded garbage collector.
  • Qt in Action:
  • We’ve deployed a couple of Qt Quick applications to the mobile marketplaces for you to try out. The “Quick Forecast” is a weather application using a web API and implemented completely with Qt Quick Controls. You can get it for Android from Google Play and for iOS from the App Store.

New in version 5.2.0 RC1 (November 29th, 2013)

  • It has been a busy month since we released Qt 5.2 Beta and we have fixed a large number of issues thanks to your feedback. Generally speaking, feedback on the Beta has been positive and we believe the Release Candidate will be even better, of course. In addition to changes in Qt 5.2, there is also Release Candidate of Qt Creator 3.0 included with the packages released today.

New in version 5.2.0 Beta 1 (October 23rd, 2013)

  • Qt Bluetooth: supported on Linux with Bluez 4.x and Blackberry
  • Qt NFC: supported on Blackberry
  • Qt Positioning: supported on all platforms using NMEA data, and using GeoClue on Linux
  • Qt Windows Extras: Integrate with native code on Windows
  • Qt Mac Extras: Integrate with native code on Mac OS X
  • Qt Android Extras: Integrate with native code on Android
  • Improved time zone and locale support with QTimeZone and QCollator
  • Enhancements to multiple Qt Widgets and a new one, the QKeySequenceEdit class
  • Animations for QML that can not be blocked by high loads on the main thread
  • Some new features and mobile specific controls for Qt Quick Controls
  • Accessibility is now fully supported on all desktop platforms and basic support on Android.

New in version 5.2.0 Alpha 1 (September 30th, 2013)

  • Android and iOS support:
  • Qt 5.2 is the first Qt release to fully support development of Qt applications for Android and iOS. A lot of work has gone into supporting these two platforms, and now make Qt a great solution for development of mobile applications.
  • With the exception of WebKit, all essential modules are supported in both Android and iOS. This includes all of Qt Core, Qt Network, Qt Gui, Qt Widgets, Qt Qml, Qt Quick and Qt Multimedia. From the Qt add-ons Qt Sensors, Qt Graphical Effects, Qt Script and Qt SVG are supported. On Android a special Qt Android Extras module is also supported.
  • New modules:
  • With Qt 5.2, we are also adding support for a couple of new add-on modules.
  • Qt Bluetooth is supported on Linux with Bluez 4.x and Blackberry
  • Qt NFC is supported on Blackberry
  • Qt Positioning is supported on all platforms using NMEA data, and using GeoClue on Linux
  • Qt Windows Extras Integrate with native code on Windows
  • Qt Mac Extras Integrate with native code on Mac OS X
  • Qt Android Extras Integrate with native code on Android
  • The last three add-ons contain platform specific additions, and complement the Qt X11 Extras module introduced with Qt 5.1.
  • Qt base modules:
  • Qt Core got some new functionality, most notably the new QTimezone and QCollator classes. QTimezone is integrated with QDatetime and now allows proper handling of timezones. QCollator allows for locale specific sorting of strings, a long outstanding feature in Qt. Qt Network has received some improvements in its SSL handling. Qt Widgets has gotten lots of smaller improvements and a new QKeySequenceEdit class. Our Accessibility support has been greatly improved, with support for Mac OS X, basic support on Android and a set of public APIs that allow implementing accessibility support for custom widgets.
  • Qt Qml and Qt Quick:
  • The QML engine has undergone some intensive work over the last 9 months, and the first results can be seen in Qt 5.2. Qt Qml is now using its own built-in Javascript engine and does not depend on V8 anymore. As such the QtJSBackend shared library has disappeared.
  • We are now using our own built-in engine instead of V8 for many reasons. One of the immediately visible benefits is that we are actually able to support Qt Quick 2 on iOS. In addition, the size of our Qml stack has decreased by around 5 MB and there’s one shared library less that needs to get deployed. Finally, it makes the whole stack a lot more maintainable and will thus allow us to improve the module at a faster pace in the future.
  • While the new engine is somewhat slower then V8 when it comes to pure Javascript performance, it allows us to optimise for the common use cases in QML and Qt Quick a lot better. Quite a lot of optimisation work is still ongoing now during the release cycle, and we expect to have comparable Javascript performance to Qt Script with 5.2.0. For QML bindings, we will see improvements for most use cases.
  • In addition, Qt Qml now supports File selectors to make it easier to customize your QML code depending on operating system and other variables.
  • Significant improvements also made it into Qt Quick. First and foremost, the module got a new scene graph renderer, that significantly reduces both CPU and GPU load for many use cases. The new Animator QML type offers animations that fully run on the rendering thread and won’t block or stutter even if your main thread has some long running calculations to perform.
  • The Qt Quick Controls have a couple of new Controls and features to offer. Switches and Busy Indicators got added, Table view now supports movable columns and extended selections. In addition, deployment has been greatly simplified.
  • Qt Creator:
  • Last but not least, we are planning to ship Qt 5.2 together with a new release of Qt Creator, Qt Creator 3.0. The new Creator will feature an improved Android support, initial iOS support, extensions for multiple screens, a cleanup in the Creator plugin APIs and initial support for lldb.
  • Timeline:
  • As you can see, Qt 5.2 will contain a lot of great new features and especially the support for mobile operating systems is a huge step forward for us. With the Alpha out, we are now in working hard towards providing a Beta as soon as possible. The Beta will again include binary packages. After the Beta work will go on towards the Release Candidate and Qt 5.2.0 final, which we hope to release by the end of November.

New in version 5.1.1 (August 28th, 2013)

  • t provides many improvements over Qt 5.1.0 as well as packages Qt Creator 2.8.1 to the installers. As a patch release, it does not add new features and remains binary compatible with Qt 5.1.0.
  • It has been 8 weeks since we released Qt 5.1.0 and we have received a lot of good feedback on the improvements it provides. Many of you have already taken the Qt Quick Controls for a spin or tried out the mobile ports for Android and iOS. Based on the feedback received from the Qt Enterprise customers as well as the whole Qt community, Qt 5.1.1 is providing improvements over Qt 5.1.0 throughout different Qt modules. We are also including Qt Creator 2.8.1 for easy installation via offline and online installers.
  • For a detailed list of changes in Qt 5.1.1, please have a look at the change files included in each module – or check the most important ones: qtbase, qtdeclarative, qtquickcontrols and qtmultimedia, as well as the Qt Creator 2.8.1 release announcement, and the page listing known issues for Qt 5.1.1.
  • As always, Qt 5.1.1 maintains both forward and backward source and binary compatibility with Qt 5.1.0. We are continuously ironing out the glitches and improving the quality with every new release. If you encounter a previously unknown bug in Qt 5, please help us to improve the product in future releases by reporting it to bugreports.qt-project.org, or contact us via Qt Enterprise Customer Portal.

New in version 4.8.5 (July 3rd, 2013)

  • 35 fixes to Qt Core module
  • 65 fixes to Qt Gui module
  • 21 Mac OS X specific fixes
  • 15 Windows specific fixes
  • 8 Linux/X11 specific fixes
  • Webkit upgrade to 2.2.4 (minor improvements)
  • Change all shmget calls to user-only memory (security)
  • Several important fixes for the VxWorks port in the Qt Enterprise version

New in version 5.1.0 RC (June 18th, 2013)

  • Online installers available for Mac, Windows and Linux hosts
  • Windows 32bit as well as 32bit and 64 bit Linux host support for Android
  • MinGW toolchain updated to version 4.8.0
  • 32bit VS2012 installer available, and all VS2012 packages built with the SP2 update
  • Perl dependency removed for building Qt (still remains as requirement for building WebKit)

New in version 5.1.0 Beta (May 14th, 2013)

  • Qt Quick Controls module providing a set of reusable UI components especially for desktop applications created with Qt Quick
  • Qt Quick Layouts module bringing an easier, more intuitive, way to manage scalable UIs by ensuring that items are consistently arranged, and that the UI as a whole remains usable across different screen sizes.
  • Qt Serial Port module providing a cross-platform interface for using hardware and virtual serial ports in Qt applications
  • Possibility to use Qt Quick and Widgets together in the same application window
  • Qt Creator 2.7.1 bundled into the package, providing, for example, Qt Quick Designer for rapid prototyping, as well as improved C++11 code editing
  • Support for static Qt builds making it possible to address those use cases that cannot use dynamic linking
  • Introducing Qt Sensors as an officially supported module

New in version 5.0.2 (April 10th, 2013)

  • New binary installers for VS2012 with ANGLE and for VS2010 with OpenGL (for those who do not wish to use ANGLE)
  • Creator 2.7.0 included in the release package (Qt 5.0.1 was shipped with Creator 2.6.2)
  • Possibility to easily skip modules in configure when building Qt yourself
  • Static linking now works correctly for the Qt libraries
  • Overall more than 600 improvements in 17 different modules of Qt

New in version 5.1.0 Alpha (April 9th, 2013)

  • A lot has happened since the Qt 5.0 release in December, and I am truly impressed by the amount of new things that we managed to get done for this alpha release. Let’s have a short look at the most important new features.
  • Android & iOS:
  • To start with, we have added preliminary support for Android and iOS to Qt 5.1. This release is fully usable on both platforms and you can begin to develop for both OSs immediately. All of qtbase (Qt Core, Gui, Network etc.) is implemented. Qt Quick works very nicely on Android and most sensors are supported. There are, however, certain limitations. Some parts of Multimedia are not fully implemented and Qt Quick is not yet working on iOS. Tooling is also still a work in progress, and not everything can be done from within Qt Creator yet, but many things are already working nicely and smoothly. As announced last year, full Android and iOS support will come with Qt 5.2, but Qt 5.1 provides a solid base for developers to create full applications for these two platforms.
  • Introduction of Qt Quick Controls:
  • Then, we finally have cross-platform controls for Qt Quick. The modules ((QtQuick Controls (formerly known as Desktop Components)and Qt Quick Layouts) offer ready- available controls and layouts you can use to build your user interface, starting from buttons, layouts, over menu and toolbars to dialogs and high-level navigational controls. Of course, they have the look and feel of native widgets of the underlying platforms. They are currently implemented for the desktop operating systems, support for touch-based platforms will get added for Qt 5.2.
  • Add-ons:
  • A couple of new modules got added as well. First of all, we brought back Qt Sensors as an add-on. The module is currently supported on Android, iOS, BlackBerry and Mer (Sailfish). A module for controlling serial ports (Qt SerialPort) has also been added, and we have an X11 specific add-on (Qt X11Extras).
  • Finally, we have added many other smaller features to the existing modules. For more details, please have a look at the Qt 5.1 feature list.

New in version 5.0.1 (January 31st, 2013)

  • With over 400 improvements compared to Qt 5.0.0 the Qt 5.0.1 is a great next step for the Qt 5 series. As a patch release it does not introduce new functionality, just error corrections and improvements. In addition to these, it also adds MinGW 4.7 pre-build binary installer, which has been highly requested. MinGW is the first but not the last new pre-build binary installer which we are going to bring along on later Qt 5.0.x releases.
  • As always, Qt 5.0.1 maintains both forward and backward source compatibility with Qt 5.0.0. However, to fix a bug we detected after the Qt 5.0.0 release, this release has a limited binary compatibility break related to multimedia functionality (please see details from here). We therefore recommend all users to recompile their applications that provided QtMultimedia plugins or dealt with them directly. This is an exceptional case: binary compatibility will be kept for further releases.

New in version 5.0.0 (December 19th, 2012)

  • improved graphics quality
  • quality performance on constrained hardware
  • cross-platform portability
  • support for C++11
  • HTML5 support with QtWebKit 2
  • a vastly improved QML engine with new APIs
  • ease of use and compatibility with Qt 4 versions

New in version 5.0 Beta 2 (November 13th, 2012)

  • A lot of work has happened since the Beta 1 towards bringing Qt 5 closer to a final release. One of the biggest differences is that this Qt 5.0 release includes not only the Qt libraries, but also the tools. Qt Creator 2.6 based on Qt 5.0 is now bundled together with Qt 5.0 to make it a full complete release. It also helps us in testing and verifying the quality of Qt 5.
  • This release will only support Qt 5.0, but we will later examine whether and how we can add Qt 4.x support to it.
  • In addition, it shows that Qt 5 is a good and mature release with a very high degree of compatibility with Qt 4.x. Qt Creator can currently be built both against Qt 4.8 and 5.0 from a single code base. This proves that Qt 5.0 is almost fully source-compatible with Qt 4.8.

New in version 5.0 Beta (September 3rd, 2012)

  • Qt Quick 2:
  • Qt Quick is now an Essential module [qt-project.org] containing the OpenGL based Scenegraph and all the usual items
  • New support for OpenGL based shader effects and particles
  • QML and JavaScript support have moved to their own Essential module [qt-project.org]
  • Qt Quick as in Qt 4.x is available in a fully compatible Qt Quick 1 add-on module
  • Qt Qml:
  • New module containing the QML engine and support for Javascript.
  • Performance improvements and some enhancements to the language
  • Source compatible — note though that when writing QML items in C++ some changes are needed to adjust to the new scene graph
  • Uses the V8 JavaScript engine behind the scenes with improved performance
  • New classes QJSEngine and QJSValue
  • Qt WebKit:
  • The WebKit module in the beta provides the same API as in Qt 4.x, but comes with performance improvements and new web-facing features.
  • In the release following the beta we plan to rename the WebKit module into Qt WebKit Widgets, providing the same C++ API as in Qt 4.
  • In addition we will introduce a new QML component that is based on the WebKit2 technology.
  • Qt Core:
  • QStandardPaths class giving standard locations for files
  • JSON parser and speed optimized binary format for JSON
  • MIME type recognition
  • New compile-time check of signal/slot connection syntax
  • New Perl-compatible regular expression engine
  • Many data structures have been rewritten and optimized for better performance
  • C+11 support where it makes sense (but Qt continues to compile and work with C+98 compilers)
  • Qt Gui:
  • Support for top-level surfaces through the QWindow class
  • Built-in OpenGL support
  • Qt Network:
  • Support for DNS lookups.
  • QHttp and QFtp classes removed (they are available stand-alone)
  • Qt Widgets:
  • All former QWidget based classes in Qt Gui have been separated out into the new Qt Widgets library
  • Ported over to the new Qt Platform Abstraction architecture
  • Works as in Qt 4.x.
  • Qt 3D:
  • This is now is an add-on module to Qt 5
  • Qt Location:
  • Maps and geolocation-related classes, formerly part of Qt Mobility, an add-on to Qt 5

New in version 4.6.2 (February 15th, 2010)

  • Fix a bug where QPixmap::serialNumber was not set on a transformed pixmap in Qt/X11.
  • Fixed a crash when an input method tries to create a widget after the application is destroyed.
  • [QTBUG-6952] Fixed a problem using NoButtons in spinbox with QGtkStyle.
  • [QTBUG-7504] Fixed missing focus rect on check- and radiobutton with some GTK+ themes.
  • [QTBUG-6522] Fixed missing menu separator in some GTK+ themes.

New in version 4.6 Beta (October 14th, 2009)

  • Support for Symbian:
  • Qt 4.6 is the first release to include support for the Symbian platform, with integration into the S60 framework. The port to Symbian and S60 provides all functionality required to develop rich end-user applications for devices running S60 3.1 and later.
  • Animation Framework:
  • The animation framework helps build highly animated, high-performance GUIs without the hassle of managing complex structures, timers, and easing curves, not to mention the large state graphs that all animated GUIs tend to be full of.
  • The framework makes it easy to animate QObjects, including QWidgets, by allowing Qt properties to be animated. It also allows creating custom animations and interpolation functions. Graphics views are not left out; one can animate QGraphicsWidgets and new QGraphicsObjects which inherit from QGraphicsItem (and thereby enable properties).
  • Animations are controlled using easing curves and can be grouped together. This enables animations of arbitrary complexity.
  • The API is easy to grasp with functions such as start(), stop(), pause(), and currentTime().
  • The animation framework also plugs into the new Qt Statemachine by allowing an animation to be played when transitions are triggered. The state machine framework is introduced in 4.6 and is described below.
  • See The Animation Framework documentation for more information.
  • State Machine Framework:
  • The state machine framework provides a robust state chart implementation based on Harel statecharts and SCXML. Qt's API lets you construct such state graphs and execute them. The key benefits of a state machine are: simplify complex application semantics; Use of states to reduce code bloat; Use states to improve maintainability; Makes event-driven programming robust and more reusable.
  • It is especially the last item here that makes using a state machine worthwhile. A key characteristic of event-driven systems (such as Qt applications) is that behavior often depends not only on the last or current event, but also the events that preceded it. With statecharts, this information is easy to express.
  • The framework fits neatly into Qt by allowing transitions to trigger on signals and QEvents. By inserting animations into the state machine, it is also easier to use the framework for animating GUIs, for instance.
  • See The State Machine Framework documentation for more infromation.
  • Multi-Touch and Gestures:
  • Support for multi-touch input enables users to interact with many parts of a user interface at the same time, and provides the basis for gestures. Additional infrastructure for gesture recognition allows a sequence of touch inputs to be combined to create gestures that can be used to activate features and trigger actions in an application.
  • This new functionality brings a number of benefits: Allows users to interact with applications in more natural ways; Simplifies finger-based interaction with UI components; Combines support for common basic gestures and multi-touch gestures in a single general framework; Enables extensibility by design.
  • See the QTouchEvent class documentation for more information on multi-touch input and QGestureEvent for gestures.
  • DOM access API:
  • Web pages and XML both have very complex document object models. The W3C selector API provides a very simple way to access and manipulate such structures. This API makes it intuitive to access DOM, helps reuse CSS selector knowledge, and gives little maintenance or footprint overhead.
  • See the QWebElement class documentation for more information.
  • Performance Optimizations:
  • As always, Qt continuously strive to optimize its performance. For this release, we have: Rewritten the QGraphicsView rendering algorithm; Made QPixmapCache support efficient Key datastructure; Reduced overhead in QNetworkAccessManager; Added the QContiguousCache class, which provides efficient caching of contiguous data; Added support for hardware-accelerated rendering through OpenVG; Removed Win9x support.
  • Graphics Effects:
  • Effects can be used to alter the appearance of UI elements such as QGraphicsItems and QWidgets. A range of standard effects such as blurring, colorizing or blooming is provided, and it is possible to implement custom effects.
  • See the QGraphicsEffect class documentation for more information.
  • XML Schema Validation:
  • The QtXmlPatterns module can now be used to validate schemas, either through C++ APIs in the Qt application, or using the xmlpatternsvalidator command line utility. The implementation of XML Schema Validation supports the specification version 1.0 in large parts.
  • See the XML Processing and QXmlSchema class documentation for more information.
  • Qt3D enablers:
  • As more of Qt, and more of the applications built on Qt go 3D, API's should be provided to simplify this. Mainly, the new API aims to make it more easy to create 3D applications with OpenGL. It will also unify the Qt OpenGL codebase, and enable cross-platform 3D codebase.
  • The main features of the Qt3D enablers are currently: Math primitives for matrix multiplication, vectors, quaternions (client-side), and API for vertex and fragment shaders, GLSL/ES. Future research will, among other things include stencils, scissors, vertex buffers and arrays, texture manipulation, and geometry shaders.
  • Multimedia Services:
  • Qt 4.6 comes with new classes for handling audio. These classes provide low-level access to the system's audio system. By specifying the audio format (QAudioFormat) and supplying audio data through a QIODevice, you get direct access to the functionality of the sound device. The API also comes with functions to query audio devices for which audio formats they support.
  • See the QtMultimedia Module documentation for more information.

New in version 4.4.3 (September 29th, 2008)

  • This release serves only to rebrand Qt.
  • The copyright has been transferred to Nokia Corporation.
  • The icons and other graphics have been updated to reflect the rebranding.
  • No bug fixes or optimizations have been made.

New in version 4.4.2 (September 18th, 2008)

  • The WebKit browser engine was integrated.
  • The KDE Phonon multimedia framework is now used.
  • The QtConcurrent framework for writing multi-threaded programs without using low-level threading primitives was added.
  • The XQuery XML standard is now supported.
  • Many other enhancements were made, and many bugs were fixed.