Announcements

Google Labs VoltAir Game Built with Qt

Published Monday July 21st, 2014 | by

As the dog days of summer carry on, we at Digia, Qt are swatting down flies, mosquitoes and bees while we fan ourselves in the unusual summer heat currently striking Scandinavia … in Oslo … at least.

Meanwhile, on a cool note, the Fun Propulsion Labs at Google announced last week that, VoltAir a single and multi-player game built with Qt is available for download via the Google Play Store and as open source software. Coolbeans!

VoltAir was developed to provide an example of a C++ game designed for both Android and Android TV and the folks at Google also tested it on Nexus 5, Nexus 7, Moto X by Motorola, Android TV, and some Samsung devices.

Check Out VoltAir (Courtesy of Google Developers – YouTube)

Read more…

14 Comments


Posted in Android, Announcements, Labs, Qt, Qt Quick

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 http://qt.digia.com/webinars.

Download & Try

You can download Qt 5.2 from our download page on http://qt-project.org or try the Qt Enterprise 30-day free trial from http://qt.digia.com. 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 http://qt.digia.com/Try-Buy/Choose-Plan/.

Thanks!

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!

73 Comments


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

Introducing Qt Mobile

Published Thursday December 12th, 2013 | by

Address the Largest Mobile Markets

I am pleased to announce that together with the release of Qt 5.2, the Qt Mobile edition is now available for you to download and try: http://qt.digia.com/qtmobile.

Qt Mobile is an all-in-one Qt mobile development package designed for cross-platform mobile app creation on Android & iOS.  We have created it for mobile app developers, small companies and app development houses looking to build amazing multi-platform native mobile apps for Android & iOS with a commercial license at an affordable monthly price of $149.

Qt Mobile includes:

  • Complete Qt libraries and Qt Creator Enterprise IDE (includes additional tooling for enhanced application creation)
  • Commercial license so you can easily statically link your app libraries and successfully submit and make sure your app is accepted to stores, specifically, the Apple App Store
  • Digia Standard Mobile Support with our renowned Qt expert support engineers available to help you at no additional cost
  • Qt Cloud Services – data storage, user management and several new features to be added soon
  • Self-service Qt Account area where you can manage your account and services

Qt for All Needs

The great thing about Qt is that it gives you the freedom to choose the offering that best fits your needs. Our #1 goal above all is to spread the use of Qt everywhere and give you the most powerful value-adding development tools needed to create elegant mobile apps with Qt and make sure you target your end users successfully. That is why we have introduced the Qt Mobile self-service and monthly subscription model making it affordable to develop with a commercial license, deploy conveniently and host your Android and iOS app with one Qt package.

We know that our community is vast with varying use cases and needs. That is why Qt is packaged as different offerings for different types of needs: Qt Enterprise, Qt Mobile and Qt Open Source. You are able to choose the offering that makes sense for you and make sure that you get out of Qt what you need to be successful.

Qt Mobile addresses a large mobile app development market looking for an alternative development package to straight up web technologies and other native app development technologies. It opens up the enormous mobile app development market to the wonderful world of cross-platform development with Qt.

Meet Qt at a 2014 RoadShow Near You

We will be kicking off 2014 with the Qt Mobile Roadshow geared at first-time Qt developers looking to get the most of Qt for mobile development. The Qt Mobile Roadshow is a free one-day event where our clever Qt engineers will walk you through Qt for mobile development and explain all the benefits of how to use Qt to target the most popular platforms.

  • January 27th:  Tampere, Finland
  • February 19th, 2014: San Francisco, CA, USA
  • March 11th, 2014: London, UK
  • March 13th, 2014: Berlin, Germany

To learn more and get on the waiting list, please go here: http://qt.digia.com/qt-mobile-roadshow.

Happy Holidays!

If you are a mobile app developer looking to target Android and iOS with one codebase and get your amazingly-crafted Qt-based app swiftly to the leading stores, try Qt Mobile free for 30 days. http://qt.digia.com/Try-Buy/choose-plan . If you sign up now, you’ll get 3 months of Qt Mobile for free!

 

1 Comment


Posted in Android, Announcements, iOS, Mobile, Qt, Uncategorized

Qt Data Visualization Technology Preview and Charts 1.3.1 Release

Published Thursday November 7th, 2013 | by

When we began developing the Charts library we set as one of the goals to create a Charting component that makes it easy to create good looking interactive data centric user interfaces. We have continued with this path and we are now introducing two new releases in this area.

We are releasing a technology preview of Qt Data Visualization library which introduces a new dimension to the way data can be presented. Data Visualization is a totally new implementation built on Qt 5 and OpenGL which has enabled us to take the full advantage of hardware acceleration and Qt Quick 2.

Even though Data Visualization library has some similarities with Charts it does not replace Charts. Development of Charts continues and we have now also released the Charts 1.3.1 release which contains 25 enhancements and performance improvements.

Harnessing the Power of 3D in Data Visualization

Using 3D in data visualization has been around for some time now but it is quite seldom truly utilized. Most common use case is to draw 3D like bar charts in order to increase the visual Look & Feel of the presentation. However in many cases the 3D presentation does not bring any real value and in several cases it actually makes it harder to read the data. Combining User Interaction and real time 3D drawing enables us to create user interfaces that are efficient in UI space consumption.

Main features included in the Technology Preview:

Data Visualization Types

 Multiple data visualization options: 3D Bars, 3D Scatter, and 3D Surface

3D Bars Sliced3D Surface Sliced

2D slice views of the 3D data

3D Bars

Interactive data: rotate, zoom, and highlight data using mouse or touch

Surface with selected Range

Customizable axes for data – control viewable data window with axis ranges

Data Models and easy integration QML

The data that users wish to visualize comes in many formats, all of which cannot obviously be directly supported. Therefore, Qt Data Visualization implements data proxies into which user can feed their data in a known format. For common use cases, Qt Data Visualization offers specialized proxies. One such case is having data in an item model (QAbstractItemModel subclass), which is a common way to store data in Qt applications.  These proxies are simple to use: just give them a pointer to the item model containing the data and the mapping object containing rules how to map the data into format the basic proxy can digest. Mapping objects work with item model roles. Each data item in the model can have different values for different roles. For example, with QItemModelBarDataMapping you can specify which role is used to determine which row the item belongs to, which role does the same for columns, and which role specifies the value of the item. When the proxy resolves the data from the model, it uses these mappings to generate the rows and columns of the bar graph.

In the QML side you can easily create for example an UI that integrates Qt Data Visualization and Qt Quick Controls TableView like this:

    
    ListModel {
        id: dataModel
        ListElement{ year: "2006"; month: "Jan"; income: "5" }
        ListElement{ year: "2006"; month: "Feb"; income: "6" }
        ListElement{ year: "2006"; month: "Mar"; income: "4" }
        ListElement{ year: "2007"; month: "Mar"; income: "4" }
        ...
    }

    BarDataMapping {
        id: valueMapping
        rowRole: "year"
        columnRole: "month"
        valueRole: "income"
    }
    ItemModelBarDataProxy {
        id: modelProxy
        activeMapping: valueMapping
        itemModel: dataModel
    }

    Bars3D {
        id: testGraph
        dataProxy: modelProxy
        ...

    }

    TableView {
        id: tableView
        anchors.top: testGraph.bottom
        width: testGraph.width
        TableViewColumn{ role: "year"  ; title: "Year" }
        TableViewColumn{ role: "month" ; title: "Month" }
        TableViewColumn{ role: "income" ; title: "Income" }
        model: dataModel
    }
}

The Road Ahead

Technology Preview is still work in progress and we are working for example with customizable input handling and scene handling (full control of cameras and lights) and customizable themes. There are also some rough edges we are improving, please see the README file included in the package for detailed information about the known issues.

We will be issuing a quick survey later this year for those who have downloaded the preview version so that the feedback can be used as the basis for the development of the future versions.

Charts 1.3.1 Release

The Charts release is a patch level release and contains 25 enhancements and performance improvements.  For example label handling has been improved so that too long labels are now truncated in pie slices and using HTML  in labels has been improved. We have also improved the support for Qt minimal configuration options which makes it easier to use the Charts in embedded environments.

Full list of changes has been included in the README file included in the release package.

Take it for a Test Drive

The Charts and Data Visualization Tech Preview are available as a source code delivery in the Qt Enterprise Customer Portal and Charts release is also available as an update through the Qt Installer Maintenance Tool.

Both of these add-ons are included in the Qt Enterprise License. Full API Documentation and a set of example applications are also included for enabling a quick start with the add-ons. You can test out the Charts and Data Visualization Technology Preview and the rest of Qt Enterprise by downloading a 30-day free evaluation.

9 Comments


Posted in Announcements, Charts | Tags: ,

Enginio: The Qt Cloud Backend Hits Beta

Published Thursday September 5th, 2013 | by

It is my absolute pleasure to announce that Enginio, our very own Qt cloud backend, has reached Beta status today. We have developed Enginio to make it easy for Qt developers to set up a backend for Qt applications. You can use Qt/C++ or QML and connect your application to the Qt cloud in less than 3 minutes. You don’t have to think about servers, databases, scalability, up-time, user management and many other aspects of the technical and repetitive work surrounding the backend.

Enginio removes the pain-staking efforts of setting up a server backend for your connected Qt app, regardless of software and hardware for desktop, embedded or mobile. With Enginio, the backend creation is completely abstracted, letting you focus on what matters: a perfect application for your users. Any connected and data driven applications require a server-side backend. You can now easily code, create, deploy and maintain a multi-screen user experience, content storing, user management, logging or any other cloud functionality in your Qt application with one framework and one Qt cloud backend. Keep it in the Qt family.

Check out this video made by one of our Qt Enginio developers and find out how easy it is to get started: http://youtu.be/7NheiHdg5Hg

What Does Enginio Beta Mean?
Well, we know how serious you are about applications and software built with Qt, and the last thing we would want to do is to cause any form of trouble for you. We are committed to ensure the same service quality in this Beta as  in a production version from this point on. Enginio is based on years of experience from building robust backends for both enterprise and consumer applications and has been in active customer use since the first technology preview.

Thank you very much for the comments and questions so far. You can contact us and other developers via the Enginio discussion forum on qt-project.org or by email: mailus@engin.io  at any time. We can’t wait to see what projects you will develop with this Beta and coming releases.

Try Enginio now!

13 Comments


Posted in Announcements, Cloud, Enginio, Network

Enginio-Qt goes Alpha

Published Friday July 5th, 2013 | by

Qt 5.1 has just been released and now we are proud to announce the first alpha version of the Qt libraries for Enginio. In the last few months there were massive upgrades on the server side and we have some really sweet performance improvements. Working on the Qt client side library to access Enginio triggered many improvements on both sides. Now, finally, we reached a milestone that we thought is worth sharing. We have an updated version of the client library which makes it easy to use Enginio with a simpler and improved API.

Enginio (the Qt library) is just a regular Qt module, making it easy to develop and deploy. We don’t have binary releases yet since this is the first alpha, but building from source is simple (just run qmake and (n)make or check the documentation).

Compared to the initial design, we radically simplified the API and made use of the powerful Qt JSON module. With a unified approach to all data types, we allow the user to treat all operations the same. This means the code to list all users is the same as listing all objects of a certain type, with just one parameter changed. We also provide a convenient model which allows you to directly use the data from the cloud inside a Qt Item View (for example, QTreeView) or in Qt Quick’s ListView. In addition to the cleanup and improvements made, we have a few new features. Full text search is now available as well as Access Control List management.

Here are some interesting snippets:

In order to query for all objects of type “image” you would do this:

EnginioClient *client = new EnginioClient(parent);
client->setBackendId(QByteArrayLiteral("YOUR_BACKEND_ID"));
client->setBackendSecret(QByteArrayLiteral("YOUR_BACKEND_SECRET"));

QJsonObject queryObject = QJsonDocument::fromJson("{\"objectType\": \"objects.image\"}");
EnginioReply  *reply = client->query(queryObject);
QObject::connect(reply, SIGNAL(finished(EnginioReply*), this, SLOT(replyFinished(EnginioReply*));
...
void MyClass::replyFinished(EnginioReply *reply)
{
    qDebug() << "Data:" << reply.data();
    reply->deleteLater();
}

The equivalent code in QML looks similar, but using JSON is even nicer there:

import Enginio 1.0
Enginio {
    id: client
    backendId: "YOUR_BACKEND_ID"
    backendSecret: "YOUR_BACKEND_SECRET"
    onFinished: console.log("Engino request finished." + reply.data)
    onError: console.log("Enginio error " + reply.errorCode + ": " + reply.errorString)
    Component.onCompleted: query({"objectType": "objects.image"})
}


We can use EnginioModel which then works nicely with the Qt Quick ListView:

import Enginio 1.0
EnginioModel {
    enginio: client
    query: {"objectType": "objects.image" }
}

Get an Enginio account today and try it: http://engin.io or check out the documentation.

The alpha release requires Qt 5.1 (which was just released).

We are looking forward to your feedback! Talk to us on the forums or via email.

 

4 Comments


Posted in Announcements, Cloud, Enginio

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.

Contributors
Berlin
Finland
Oulu
Oslo

89 Comments


Posted in Announcements, News, Qt, Qt Project

Qt 4.8.5 Released

Published Tuesday July 2nd, 2013 | by

Today we have released Qt 4.8.5 bringing close to 400 improvements over the previous release in the Qt 4.8 series, including important security updates and error corrections. As a patch release it does not add new functionality and maintains full compatibility with the Qt 4.8.x releases.

Qt 4.8.5 provides overall close to 400 improvements, for example:

  • 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, see blog post for details on VxWorks improvements

A detailed list of the fixes and improvements in Qt 4.8.5 compared to Qt 4.8.4 can be found here.

Qt 4.8.5 is now tagged in the Qt Project repository. The source packages and stand-alone installers for Qt 4.8.5 are available for download from the Qt Project for open-source users, as well as via the Customer Portal for Qt Enterprise licensees. For Qt Enterprise licensees there is also an online SDK update available for Qt 4.8.5.

The new online installers used in conjunction with Qt 5.1 are equipped to handle also Qt 4.8 content, but some ‘housekeeping’ is needed before it can be included. We are planning to add Qt 4.8.5 to be available through the new Qt Enterprise online installers later, most likely around September.

Qt 4.8 is still actively used, and we are providing patch releases to it also after Qt 4.8.5. Many users have already taken Qt 5 for a spin and with the new Qt 5.1 available soon, we encourage also the others to do so. But there is no panic to jump away from Qt 4.8 immediately. It remains supported and you can take the steps towards Qt 5 according to your own schedule. With high degree of source compatibility, we want to make switching to Qt 5 smooth and straightforward.

 

21 Comments


Posted in Announcements, Qt, Releases, WebKit

Qt 5.0.2 Released

Published Wednesday April 10th, 2013 | by

Today we are releasing Qt 5.0.2 – the second patch release of Qt 5.0 series. I am extremely happy about the interest towards Qt 5 as well as the amount of improvements we have been able to add into the Qt 5.0.2 release. 

Qt 5.0.2 brings over 600 improvements compared to Qt 5.0.1, most of these in order to address the issues Qt users have noted when bringing their applications to Qt 5. As a patch release Qt 5.0.2 does not introduce new functionality, but we have again been able to add some new binary installers, as well as enable some use cases that have been problematic in the earlier Qt 5 releases.

Highlights of Qt 5.0.2 include:

  • 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

For detailed list of changes in Qt 5.0.2, please have a look into the changes file included to each module – or check the most important ones: qtbaseqtdeclarative, qtwebkit and qtmultimedia, as well as Creator 2.7.0 release announcement.

As always, Qt 5.0.2 maintains both forward and backward source compatibility with Qt 5.0. We are continuously ironing out the glitches and improving quality with every new release. If you encounter a problem, please check the known issues page first, where you can find solutions and workarounds for common problems. If you find 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 our Customer Portal if you have a commercial license.

Qt 5.0.2 is now tagged in the Qt Project repository. The source packages and installers for Qt 5.0.2 are available for download at qt-project.org/downloads for open-source users, as well as via the Customer Portal for commercial licensees.

49 Comments


Posted in Announcements, Releases

Qt Project Needs Mirrors for the New Download Service

Published Thursday March 28th, 2013 | by

The Qt Project is currently using a content delivery network based solution for distribution of releases. We have been working to improve distribution of Qt open-source packages and now have the setup available for mirroring. Now we need to get more mirrors before going to production.

The idea is to switch to MirrorBrain based system and away from the current content delivery network based service. The work was started a while ago by Daniel Molkentin and now we have the setup available for mirroring. It is very much similar to what KDE is already using, so for many it is quite familiar. At this point I would like to thank Danimo and others from KDE for all the help provided to enable this.

The system is not yet taken into production use, we need to first have enough mirrors in place. Downloads from the new service work, but the system is not yet up to handle the needed load. Currently we have two mirrors in place, and need more before the new download service can be taken into production use.

The new service is for open-source content only. All the commercial Qt licensees are using a separate system. So it is completely ok for non-profit organizations to become a mirror for Qt Project.

If your organization is willing to become a mirror, please follow the steps in the wiki. Or if you know some organization who already provides mirrors, please ask them to become a mirror for the Qt Project.

We are keenly waiting to get the new download service active as it allows much more flexibility than the current setup. Getting the new system into production is also a prerequisite for providing the new online SDK for the Qt Project.

17 Comments


Posted in Announcements, Community, KDE, Open Governance, Releases

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