Lars Knoll

Qt 5.3 Released

Published Tuesday May 20th, 2014 | by

I’m happy to announce that Qt 5.3 has been released. The main focus for this release was performance, stability and usability. Nevertheless, Qt 5.3 has also gotten a fair amount of new features that help make developers’ lives easier.

Qt 5.2 has been a tremendous success, having been downloaded over 1 million times. With Qt 5.2, we delivered on our promise that Qt is a true cross-platform framework by adding Android and iOS support. Qt 5.3 is building on that foundation, and adding to it.
Read more…


Posted in Qt, QtCreator, Releases, RTOS, WinRT

Qt 5.3 Alpha Available

Published Thursday February 27th, 2014 | by

I’m happy to announce that Qt 5.3 Alpha is available for download. Qt 5.3 is coming out a bit earlier than our regular 6-month release cycle would’ve forecasted, as we have decided to pull forward our release cycle meaning, starting from Qt 5.3, future Qt releases are planned to happen every Spring and Autumn.

The focus for Qt 5.3 is mainly about improving the stability, performance and first-time user experience of the product. A lot of the work over the past months has been focusing on improving the quality of Qt, especially on the mobile platforms and Mac OS X. Having said that, Qt 5.3 will also offer a good amount of new and exciting features, and a new platform: WinRT/Windows Phone!

New features

One of the main new features in Qt 5.3 is an improved integration between Qt Widgets and Qt Quick. The new QQuickWidget class allows  seamless integration of Qt Quick-based user interfaces with a Qt Widget-based application. This should significantly simplify using both technologies together in one application and provides an easy way to migrate Qt Quick into existing Qt Widgets applications.

Qt Network gained support for the SPDY protocol, speeding up of web content download in Qt WebKit and through QNetworkAccessManager. A new Qt WebSockets module got added featuring full support for web socket (RFC 6455).
Read more…


Posted in Qt, Releases

Qt 5.2 Released | The Best Qt Yet

Published Thursday December 12th, 2013 | by

We’re proud to announce that Qt 5.2 is now available. With the release of Qt 5.1 in July, we showcased the Qt for Android and iOS ports and laid down the beginning of some heavy improvements we have now done on Qt’s graphics capabilities. In the last 6 months, we’ve worked very hard to finalize this release and especially these ports.

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 than 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.

Learn More about Getting Started with the New Platforms

In the beginning of 2014, we are coming to meet you in person at a few locations around the world with our Qt Mobile Roadshow. The event is a full-day free developer event on how to get started developing cross-platform mobile applications with Qt. The locations and dates can be found here.

We are also organizing a couple of specific webinars around Qt for Android and iOS where you will get hands-on information on how to get started developing:

  • Qt on iOS, Hands-On – Dec 17th 2013
  • Multiscreen Development with Qt | Business Overview – Jan 9th 2014
  • Qt on Android, Hands-On – Jan 16th 2014

Please find the detailed webinar information registration from

Download & Try

You can download Qt 5.2 from our download page on or try the Qt Enterprise 30-day free trial from Qt Enterprise customers can access the Qt 5.2 release directly from their customer portal. If you are only targeting mobile, you can also download a 30-day free trial of Qt Mobile from


Last but not least, I’d like to thank everybody that has contributed to making Qt 5.2 the best Qt release yet. Many people from the community have worked very hard to make this release happen. I’d especially like to thank KDAB, Bogdan Vatra and the Necessitas project for their significant efforts and contribution to Qt 5.2. Also, I would like to extend a warm thank you to the KDE community that has contributed many interesting and valuable features, and our release team that did a lot of hard work behind the scenes pulling everything together into a releasable package.

We hope you enjoy Qt 5.2 as much as we enjoyed making it. Happy holidays!


Posted in Android, Announcements, cross-platform, desktop, Embedded, iOS, Mobile, Qt, Uncategorized

Qt 5.2 Beta Available

Published Wednesday October 23rd, 2013 | by

I’m happy to announce that Qt 5.2 Beta is now available. Lots of things have happened since Qt 5.1. Apart from new platforms, we have also added a significant amount of new functionality and done large improvements under the hood.

Qt Everywhere

With Qt 5.2 we are introducing the production-ready ports of Qt on Android and iOS. A lot of work has gone into these two platforms and these ports now extend Qt’s multi-platform promise to cover desktop, embedded and mobile platforms with just one framework, Qt.

With full support for Android, iOS and Blackberry 10, Qt 5.2 is a great solution for targeting the mobile markets with one Qt-based mobile application code. This is also a big plus for our existing Qt users. It makes it fast and easy to bring your existing desktop or embedded application to mobile, by simply recompiling it.

Enhanced Internals — More Power and Flexibility

Qt 5.2 introduces a new Scene Graph renderer. This new renderer improves the graphics performance of Qt Quick even further, freeing up more CPU time for the application and using the GPU in a much more efficient way.

The former JavaScript engine, V8, which was used internally by Qt Quick, has been replaced with a completely new, Qt-specific engine. This new engine is now designed from scratch for the use case of QML and Qt Quick. It internally operates directly with Qt data types, avoiding many costly conversions. It has both a JIT and an interpreter which greatly extends the range of platforms and operating systems it can support. The interpreter also allows us to use the engine on iOS and comply with iOS AppStore policies.

New Modules and Nice Goodies

Some of the main new features of Qt 5.2 include:

  • 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.

For a more detailed list of all new features in Qt 5.2 please have a look at the New Features page in the Qt Project wiki.

Qt Creator 3.0

Qt 5.2 will ship together with a new release of Qt Creator, Qt Creator 3.0. The beta for Qt Creator 3.0 has also been released today and is part of the Qt 5.2 beta binary packages. The new Qt Creator will feature improved Android support, experimental iOS support, a cleanup in the Creator plugin APIs and improved support for lldb.

Qt 5.2 Beta now comes with binary installers for Windows, Mac and Linux. You can get Qt 5.2 Beta from the Qt Project download area for open source users, and in the Qt Enterprise Customer Portal for existing Qt Enterprise customers.


Posted in Uncategorized

Qt 5.2 Alpha available

Published Monday September 30th, 2013 | by

Last weekend we started the release cycle for Qt 5.2 by branching our development code base into the stable branch. As a first step in the release cycle, the Alpha release of Qt 5.2 is now available. They are available from the Qt Project download area for the open source version and in your customer portal for Qt Enterprise users. The packages are source only and mainly for people already used to developing with Qt. Unless you feel comfortable compiling Qt on your own, you might want to wait for the beta which will come out within the next few weeks.

Apart from numerous bug fixes, Qt 5.2 offers a whole lot of new functionality. Here’s a short overview over the most important things

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.

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.


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.

There will also be many talks about Qt 5.2 and its new features during the upcoming Qt Developer days in Berlin and San Francisco. So if you want to find out more, come and join us there.

I’d like to invite everybody to give 5.2 a try and report any issues you find back to our bug tracker.


Posted in Uncategorized

Introducing the Qt WebEngine

Published Thursday September 12th, 2013 | by

A lot has happened with Web technologies in general since we introduced the first version of Qt WebKit in 2007. From having a couple of percent market share, the WebKit open source project nowadays has became the most widely used browser engine in the world. While the Qt port of WebKit was pretty much the first non-Apple port of WebKit, many other projects and companies joined the project over the years to follow.

The Chromium project took an especially big role in the project and became over time the biggest contributor to WebKit (followed by Apple and with Qt on the third place). The cooperation between different companies on one open source project was, however, never without difficulties, and this spring Google decided to leave the WebKit project in favor of their own fork of WebKit, Blink.

Since then, Blink, which really is a very integrated part of Chromium, and WebKit have been going separate ways, and the two code bases have been rapidly diverging. Because of this, the Digia Qt R&D WebKit team decided to have a closer look at both Chromium and WebKit to decide how we could offer the best possible Web engine for Qt in the future.

After spending some time researching and looking at both alternatives, we have now come to the conclusion, that we will base our future Web engine on Chromium. The Qt WebEngine. There are many reasons that lead to this decision:

  • Chromium has a cross-platform focus, with the browser being available on all major desktop platforms and Android. The same is no longer true of WebKit, and we would have had to support all the OS’es on our own in that project.
  • There are many things that are available out-of-the box from Chromium, which would require a lot of work for us to support ourselves in WebKit. One example, is the whole platform/OS adaptation that we can simply re-use. Multimedia and new HTML5 features such as WebRTC are working out-of the-box and don’t require any Qt-specific code.
  • As using Chromium simplifies handling the OS integration, this allows us to spend additional time to focus on the upper layers to provide a great and easy-to-use API and a seamless integration into Qt as possible.
  • We are seeing that Chromium is being developed with very strict control on quality. This simplifies our testing efforts and will allow us to provide a more stable and higher quality Web engine.
  • Chromium will allow us to do a better and more performant integration with both widgets and the Qt Quick scene graph than we would be able to do with WebKit

Finally, we are seeing that Chromium is currently by far the most dynamic and fastest moving browser available. Basing our next-generation Web engine on Chromium is a strategic and long-term decision. We strongly believe that the above facts will lead to a much better Web engine for Qt than what we can offer with Qt WebKit right now. We also believe that the combination of the best-in-class browser engine with Qt as a native framework gives an incredibly strong offering especially for the creation of embedded devices that require a Web browser in addition to best-in-class UI performance.

One of the fundamentals of Chromium is that all rendering of Web content happens in a different process for security and stability reasons. This does, however, make it impossible to provide certain aspects of our current Qt WebKit API with Chromium. One notable part is probably the QWebElement API. We will also have to change how QObject embedding is being done, since all communication between the QObject and the web page will have to happen asynchronously.

What does all of this mean for users of Qt WebKit?
First of all, there’s nothing to be afraid of. For many use cases, where Web content is being embedded into applications, Qt WebKit works fine right now, and will continue to do so in the years to come. After the release of Qt 5.2, we will focus most of our new development efforts on the new Qt Web Engine. So, if you want to have all the lastest and greatest HTML5 features available for your application or device, you should consider moving over to Qt WebEngine once we have a release that covers the API features you require.

We will do our best to make moving over from Qt WebKit to the new Qt WebEngine as easy and seamless as possible. For the Qt Quick WebView element, we can most likely provide a close to 100% compatible API. For people using the basic QWebView API, we also have good news. Most of that API is available in an almost source-compatible fashion in the new Qt WebEngine. If you use the QObject bridge or the QWebElement API, we recommend you wait a bit longer with moving, as a replacement API for those will most likely not be part of the first version of Qt WebEngine.

While we no longer will do any feature development in Qt WebKit, the existing version will continue to be available. Digia will continue to support Qt WebKit for Qt Enterprise commercial license holders as defined in the license agreement, and can also offer extended lifetime support.

Work is now ongoing to provide you with a Technology Preview of the new Qt WebEngine as fast as possible. Our goal is to have that available together with the Qt 5.2 release this autumn. The first fully supported release will then, most likely, come as part of Qt 5.3 next spring. For the first version, we are planning to support the new Qt WebEngine module on Windows, Mac OS X, Linux and embedded Linux.

For more information on the Qt WebEngine have a look at the Qt Project wiki. There you can also find more detailed information about how to build the Web engine yourself, how to port existing code and what our future plans for the module are.

While this is a rather large change for Qt, I strongly believe this will give us a much better and more competitive Web platform in the years to come.

The best way to find out what is going on with Qt WebEngine and our future direction is to join us at Qt Developer Days where our lead developers on the project will talk about the latest developments. Make sure to register to Qt Developer Days at


Posted in Qt, WebKit

Qt Contributors Summit 2013 Summary

Published Thursday August 22nd, 2013 | by

It’s now been a little over a month since we had the Qt Contributors Summit in Bilbao, where more then a hundred people from the community met to discuss the future direction of Qt and it’s different modules and subsystems. We also had a bit of vacation time after the summit hence this slightly delayed wrap-up blog post.

As you know, the Qt Contributors Summit was co-located with KDE’s Akademy conference, which really helped having discussions across project boundaries. The first release of KDE frameworks 5 is planned to be using Qt 5.2, so this gave a unique opportunity to look at cooperation and how to bring Qt and the KDE frameworks closer together.

There have been a huge amount of discussions on all kinds of topics at the Qt Contributors Summit ranging from rather low level ones as e.g. how to improve the Qt object model or the networking stack up to rather high level topics such as UI adaptability and Qt Quick Controls. A lot of the session notes can be found from the program page, many others have been posted to the Qt development mailing list and can be found in the archives. Also, a series of blog posts have been posted by community members since the summit. Have a look at Planet Qt for other Qt Contributors Summit 2013 wrap-up blog posts.

All together I’m very happy with the outcome of the summit. A lot of good discussions were started, we found solutions to many problems and I believe it helped everybody who participated to get a better understanding on how we want to move Qt forward.

Last but not least, I would also like to thank the KDE project and all the volunteers helping in Bilbao. The summit wouldn’t have been possible without all their invaluable work.


Posted in Uncategorized

Qt Contributor Summit Approaching

Published Monday July 15th, 2013 | by

There are now only some short days left before this years Qt Contributor summit. This time the event is co-located with KDE’s Akademy conference in Bilbao, Spain.

The final preparations are happening right now, and I’m very much looking forward to two exciting days of discussions and work around Qt. We’ll use the event to hopefully make many decisions on where we’ll be heading over the next year, have an in depth look at the different modules, maybe fix some bugs and implement some new functionality. And most importantly: use the time to get to know each other better and have a good time together!

The event is organized as an Unconference, but a lot of agenda items have already been brought up, and can be found here.

We’ll have a great group of people that are working on and with Qt coming to the event. If you are interested in coming on short notice, there’s still a chance to register.


Posted in Uncategorized

Qt 5.1 Released

Published Wednesday July 3rd, 2013 | by

I’m very happy to announce that Qt 5.1 is now available. It has taken us a little more than 6 months since we released Qt 5.0 end of last year. While we originally planned that Qt 5.1 will mainly focus on bug fixing and stability of Qt 5.0, we have actually achieved a lot more. The release contains a large amount of new functionality in addition to numerous smaller improvements and bug fixes. For more information, please have a look at our Qt 5.1 launch page.

Qt 5.1 comes bundled with a freshly released Qt Creator 2.7.2. They are available through a new online installer, that allows for automatic and seamless upgrades in the future. A new version of the Visual Studio Add-in is also available.

We have added many new modules that largely extend the functionality offered in 5.0. The new Qt Quick Controls and Qt Quick Layouts modules finally offer ‘widgets’ for Qt Quick. They contain a set of fully functional controls and layout items that greatly simplify the creation of Qt Quick based user interfaces.

Qt Sensors that many already know from the Qt Mobility efforts in Qt 4 has now been added to Qt 5.1 supporting Android, Blackberry and iOS. A new Qt Serialport add-on allows controlling serial connections on Linux, Mac and Windows.

Qt for Android & iOS Technology Previews

Qt 5.1 also greatly extends Qt outreach to different platforms and operating systems. First of all, Qt now supports Visual Studio 2012, and offers the option to choose between ANGLE and desktop OpenGL on Windows.

In addition to that our work to bring Qt to mobile operating systems is showing great results. Even though Qt for Android and Qt for iOS are not yet final, and are marked as technology previews in this release, they are already very usable for a large number of use cases.

Qt for Android supports all Qt modules that are part of 5.1 with the exception of Qt Serialport, Qt WebKit and parts of Qt Multimedia. Qt for Android also comes with a great integration into Qt Creator that allows you to do almost all your development until the point where you want to upload the application to Google Play.

Qt for iOS also already supports the same Qt modules as Android does, with the exception of Qt Quick 2. This is due to limitations in iOS that make it impossible to use V8 as the JavaScript engine on this operating system. We will provide full Qt Quick support on iOS with Qt 5.2.

You can install some demo applications that show Qt on iOS and Android from the App Store and Google Play. For Android we have a new Qt Everywhere demo as well as the Qt 5 launch demo available in Google Play. The blog post about Google Play contains more details about publishing Qt applications in Google Play. For iOS, we have Sub Attack, a small Qt based game and Qt Quicksand published in the app store.

As with any release also this one contains a few issues that we know about and probably some more we haven’t yet found. All of these will be collected on the Known Issues page in our wiki.

Finally, I hope that you all will enjoy Qt 5.1. I personally believe that this release is a great milestone for Qt. Qt is now a cross platform toolkit that also spans the major mobile operating systems in addition to the desktop platforms and many embedded OSes.

A lot of hard work has gone into making this release happen, and I’d like to thank everybody who contributed in one way or another to it. Following tradition, here are some pictures of many (but far from all) of the people that helped create Qt 5.1.


Download Qt 5.1

To evaluate the Qt Enterprise commercial version, please go here. You can also download the open source version from here.



Posted in Announcements, News, Qt, Qt Project

Evolution of the QML engine, part 1

Published Monday April 15th, 2013 | by

QML as a technology has become increasingly important for the success of Qt. It allows for the creation of smooth, animated user interfaces, in line with expectations on the market today. There are three main features, that make it so suitable for UI creation. The first one is the declarative syntax, that makes it extremely easy to create these user interfaces and have both developers and UI designers work on the same code base. Secondly, the technology makes the integration of native code relatively easy, allowing to do much of the application logic and heavy lifting in C++. And finally, the choice of Javascript as an integral part of the QML language allows for easy prototyping and opens the technology up to a wider audience.

The engine as it is today is a fantastic basis and fills most of our users needs. However, it also has a couple of shortcomings and problems that will need to get solved in the future. This series of blogs is going to outline our findings and present the solutions that we are planning to implement for them. The goal will be to get to a better, more flexible and easier to maintain QML engine in the future.

So let’s start of with some of the problems we’re facing with the current engine.

  • Several object models
    The current QML engine uses the V8 Javascript engine to execute property bindings. Each QML item has several representations internally. One towards V8 (using the public V8 API), one towards the QML engine, and one to expose it as a QObject to native Qt. The problem here is that this requires the QML engine to keep these different representations in sync, leading to a lot of glue code and rather high memory consumption to hold the different representations.

  • Bindings done through JS closures
    Each binding is represented as a JS function closure towards V8. This requires rewriting the expression as a closure, and then letting V8 parse the rewritten expression once again. Evaluating the binding requires calling a JS function in V8 with quite a bit of overhead to instantiate the proper context for executing the binding. This is rather slow and lead to the development of a small expression interpreter (called V4) inside the QML engine that would evaluate simple expressions. This interpreter is many times faster than evaluating through V8.

  • Data type conversions
    One reason why evaluation of expressions in V8 is slow is the overhead of converting data types from Qt to V8 and vice versa. Accessing a Qt property would for example create a QVariant, that would then need to be converted to a V8::Value. If the variant was a string this involved copying the string data. To soften this, various caching mechanisms were introduced, but those came at the cost of increased memory usage and additional complexity in the code.

  • QML scoping rules
    QML is syntactically a tree of items. Inner items implicitly see properties of outer items leading to a well defined scope chain. Unfortunately this scope chain works differently than traditional Javascript and couldn’t be directly implemented with existing Javascript engines. The only way to do it directly would have been through nesting slow and deprecated with() statements. The current solution involves a very intrusive patch to V8 and still requires all QML properties to be looked up by name.

  • Throwing away QML type info
    QML as a language has type information. Javascript however is completely untyped. This lead to the fact that all type information got thrown away at QML compile time. Retaining the type information would allow us to optimise QML expressions a lot better.

  • iOS and WinRT support
    iOS does not allow making memory both executable and writable, something that existing JS engines require. WinRT doesn’t allow making memory executable at all. This makes it impossible to use V8 on these platforms without writing a full interpreter backend to V8.

  • Working with upstream V8
    As said above, we are currently forced to maintain a rather large and intrusive patch set on top of V8. There is no chance of merging these patches upstream, as V8 fully focuses on the browser use cases.

These different arguments have lead to a research project that was started Roberto Raggi and Aaron Kennedy in Nokia around a year ago, where they explored the feasibility of having a JS engine that is tailored to the use cases QML requires. The project with the codename v4vm was then transferred to Digia, where Simon, Erik and myself took it up and continued with it. It lived as a playground project on for the last couple of months.

Today we integrated this research project into a development branch of Qt Declarative, and we will continue to work on it there from now on.

The new engine contains a fully compliant ECMAScript 5.1 implementation, that runs on all platforms Qt supports. It contains a JIT that currently works on Linux, Mac and iOS. Integration into the current QML engine is currently done through a V8 compatible API layer which we plan to remove in the coming weeks. The engine can run all Qt Quick demos (with some minor glitches).

One of the things to note is that the engine is focused at QML use cases. This implies that we expect QML performance to become a lot better then it is today. Pure JS performance will on the other hand not be quite as good as what you get with V8 as a backend.

Still our current benchmark numbers are very promising also for pure JS code. The V8 benchmark runs currently around three times slower than the JS engine used in Qt 4.8 and Qt Quick 1, and we see a lot of potential for further optimisations.

Details about the new engine and our future plans will come in a followup post. You can find the code in the wip/v4 branch in the qtdeclarative repository. Feel free to play around with it. If you want to join development, feel free to contact us on #qt-v4vm on freenode.


Posted in Qt, Qt Quick

  1. Pages:
  2. 1
  3. 2
  4. 3
  5. 4