Qt 5

We are continuously working on improving the performance and optimizing the memory consumption of Qt. One focus area for Qt 5.12 has been to reduce the memory consumption of the QML engine and tuning the JavaScript performance. Qt 5.12.3 provides ... [More] further improvements especially for QML engine performance.  This is an update for the earlier Qt 5.12 performance blog post from last November. Measurements have been done with Qt 5.12.3 release, which contains further improvements to Qt Quick and QML performance compared to the Qt 5.12 beta used in the previous post. Qt 5.9 LTS already shows a great improvement of the overall performance compared to the previous long-term supported Qt 5.6 LTS release. These are summarized in a blog post about Performance Improvements with Qt 5.9 LTS and Qt Quick Performance Improvements on 64-bit ARM. With Qt 5.12 LTS we have continued to tune these further and taken a deeper look into the areas of QML engine memory consumption and JavaScript performance. In addition to Qt 5.6 LTS no longer supported, the performance of the Qt 5.12 LTS is a solid reason to upgrade. QML Memory usage Applications use memory for multiple things and to optimize the overall memory usage a good start is typically to look into the graphics assets, leveraging asset conditioning, the Qt Lite feature system to remove unused functionality and other techniques to optimize the memory usage. As it is very difficult for an application developer to affect the memory used by the QML engine itself, we have taken a deep look into how it can be reduced. One important optimization done with Qt 5.12 LTS are to the data structures used in conjunction with compiled QML. The QML engine creates cache files that contain a dump of internal data structures on the fly when loading a .qml or .js file at run-time (named .qmlc and .jsc). If found, these files are mapped into the application process and used directly without requiring a compilation step. We have an option to create those cache files ahead of time while compiling the application. In that case, we don’t have quite the same degree of visibility into the type system as the QML engine has at run-time. This leads to a staged approach where we can’t resolve quite as much as when generating the data structures at run time, requiring us to do some additional work on top of the pre-generated cache files. In Qt 5.12 LTS two changes are done to reduce the memory consumption when using such ahead-of-time generated cache files: Avoid the re-creation of the indexed string table for the in-memory generated compilation unit and instead fall back to the memory mapped string table provided from the cache file. Reduce the size of data structures so that the size of the files as well as their memory consumption is reduced. In addition to the changes described above, we have done also multiple smaller improvements to reduce the memory consumption of the QML engine, while still keeping the performance on a good level (and actually improving quite a bit in some areas). Actual memory usage of a Qt Quick applications depends a lot upon the application itself. In the comparison chart below, we have measured the QML engine related memory consumption for two different applications. We have used the Qt Quick Controls example to represent a Qt Quick application. For the example application we can see that Qt 5.6.3 uses 36.3 MB, Qt 5.9.7 uses 18.5 MB and Qt 5.12.3 uses 13.0 MB RAM (using pre-compiled QML). This means that memory usage with Qt 5.12 is 30% lower than Qt 5.9 and 64% lower than Qt 5.6 with the example application. These savings are available for all users of Qt. For commercial users Qt 5.6 and 5.9 offered a separate tool called Qt Quick Compiler that can be used for pre-compiling QML. Using the Qt Quick Compiler, the memory usage of Qt 5.6 drops to 14.4 MB (60% lower RAM usage than without). So even when using the Qt Quick Compiler with 5.6, upgrading to Qt 5.12 will lead to a very nice 10% improvement in memory usage. As all applications are different it is best to check how big the benefit is for your application. We compared the QML engine memory use of Qt 5.6 and 5.9 using Qt Quick Compiler and Qt 5.12 using the pre-generated QML with a rather complex real-life Qt Quick application. In this measurement Qt 5.9 used 1.1 MB less RAM than Qt 5.6 (both with Qt Quick Compiler), and Qt 5.12 used a whopping 9.8 MB less RAM than Qt 5.6 (with Qt Quick Compiler). Especially for embedded systems with constrained resources or ones that run multiple applications this type of RAM savings in the QML engine, with no changes to the application code, are very beneficial. JavaScript Performance A major difference of Qt 5.12 LTS compared to Qt 5.9 LTS and Qt 5.6 LTS is the completely new compiler architecture of the QML engine introduced with Qt 5.11. The new pipeline has also enabled making some of the memory use optimizations described earlier in this post. With the new pipeline, we get a significant improvement in JavaScript performance, even with the addition of ECMAScript 7 support in Qt 5.12. To compare the JavaScript performance for different Qt versions, we have run the same JavaScript benchmark with Qt 5.6.3, Qt 5.9.7 and Qt 5.12.3. The benchmark is run on 64-bit ARM processors using Linux operating system. To highlight the improvement with Qt 5.9 and 5.12 we have normalized the result of Qt 5.6 to 100. Overall improvement (TotalScore) of Qt 5.9.7 compared to Qt 5.6.3 is 1785% and Qt 5.12.3 compared to Qt 5.6.3 the improvement is 2138%. Compared to Qt 5.6.3, the biggest performance improvement is seen due to supporting JIT on 64-bit ARMv8 architecture used in many modern embedded processors. With Qt 5.6 JIT is not supported on 64-bit ARM. Qt 5.9 and Qt 5.12 both support JIT, so between these the improvements are mainly due to the new compiler architecture. Compared to Qt 5.9.7 the overall JavaScript performance improvement of Qt 5.12.3 is 19%. Overall Qt Quick Performance Because it is so easy to break performance, we regularly run several different kinds of performance tests. These also help in analyzing how the various optimizations work across different platforms and to make sure feature development and error corrections do not have unintended side effects to performance. Some of these results are visible at testsresults.qt.io, for example the QML Bench tests. To compare the effect of Qt versions, we have run the full QML Bench test set with Qt 5.6.3, Qt 5.9.7 and Qt 5.12.3. To improve the comparability of results, we are running Qt Quick Controls 1 tests on Qt 5.6.3, as it does not have Qt Quick Controls 2 functionality. Otherwise the functionality tested by the QML Bench is same between these Qt versions. For these tests, QML Bench was run on an Nvidia Jetson TX1 development board (64-bit ARM processor) running the Nvidia supported Linux for Tegra Ubuntu 16.04. Due to the very large performance improvement in Javascript and Qt Quick Controls, we have presented those separately to make the charts below more readable (JavaScript earlier in this post and Qt Quick Controls in an earlier blog). We have again normalized the Qt 5.6.3 result to be 100 in order to better highlight the improvements with Qt 5.9.7 and Qt 5.12.3. For the overall QML Bench test the performance with Qt 5.9.7 is over double compared Qt 5.6.3 (109% better than Qt 5.6.3), and the performance of Qt 5.12.3 is even slightly higher (113% better than Qt 5.6.3). The improvements in areas other than JavaScript and Qt Quick Controls are smaller, typically between 15 to 25%. Comparing Qt 5.9.7 and Qt 5.12.3 shows overall improvement of 7%. This has improved since the first Qt 5.12 releases as the performance regressions in a few tests have been fixed. Those using Qt 5.12 LTS, should update to Qt 5.12.3 or later in order to get this increase in Qt Quick performance. QML Bench has been developed with typical application use cases in mind, trying to cover as many of those as possible in a comprehensive suite. But as with any benchmark, this still means that the improvements in your application might vary depending on how QML is being used there – so it is always recommended to gather performance data with your own application to see how much its performance improves. Other improvements In this post the focus was in the Qt Quick performance, where we have improved the performance of Qt 5.12 LTS significantly compared to the earlier LTS releases of Qt in three important areas: QML memory usage Overall Qt Quick performance JavaScript performance In addition to these, Qt 5.12 LTS provides many other performance improvements as well. One important improvement in Qt 5.12 LTS is the possibility to use pre-generated distance fields of fonts. Earlier Qt has created the distance fields during the application startup, which can consume a lot of CPU cycles especially for non-latin fonts (that have many glyphs) and complex latin fonts (that have a lot of different shapes). With Qt 5.12 LTS, we release a tool called “Qt Distance Field Generator”, which allows you to pregenerate the distance fields for either a selection of the glyphs in a font or all of them. Other areas where we have been improving performance include, for example, Qt 3D CPU usage and Qt 3D memory consumption (especially beneficial for Qt 3D Studio applications). Qt 5.12 LTS also introduces a completely re-designed TableView, which takes the performance of large tables to completely different level than the old TableView implementation of Qt Quick Controls 1. Of course, Qt 5.12 LTS also benefits from the compressed texture support introduced with Qt 5.10 and improved with Qt 5.11, as well as multiple other improvements done since the previous LTS release of Qt. If you have not yet looked into Qt 5.12 LTS, please take it for a spin. The post Qt Quick Performance Improvements with Qt 5.12 LTS (Updated for Qt 5.12.3) appeared first on Qt Blog. [Less]

At times it was a bit painful juggling writing a book, doing my day job and running around doing the things that life throws. It's done and dusted now, you too can buy my book titled Hands-On Mobile and Embedded Development with Qt 5! It has a nice ... [More] image of glacier ice on the cover, which I thought was appropriate for a technology founded in Norway and then continued in Finland. https://www.packtpub.com/application-development/hands-mobile-and-embedded-development-qt-5 A big thanks to the co-founder of Trolltech, Eirik Chambe-Eng, who was gracious enough to write the forward at the last second. Tons of thanks to all the editors who also worked on this book. One of the things I learned writing this book is that Qt is big. I already knew that, but now it's plainly apparent just how big it has grown. Not only are there major companies developing products with Qt, but it has a lot of different functionality and is not just about desktop widgets. There are a huge number of classes to cover. You can check out the table of contents if you want to see what is covered and included. One area that I did not include is OpenGL ES. This is a huge topic and easily a book on it's own. It's something I would like to know more about, which is why I did not feel qualified to cover it. You need to know OpenGL Shader Language (GLSL), and I did not have the time to discover that to any real depth. I hope that I covered topics that are relevant for mobile, embedded and IoT developers. From QtWidgets, QtQuick, QtSensors (of course) to In-app purchasing and building an embedded system with Qt Company's Boot To Qt and Yocto. I also explore Qt's newest platform - Qt for WebAssembly, which allows you to serve Qt applications from a web server to run in a web browser. Enjoy! [Less]

I recently made a trip to LLVM in Brussels and ACCU in Bristol. It was a busy week. I gave a talk at both conferences on the topic of the future of AST Matchers-based refactoring. As usual, the ‘hallway track’ also proved useful at both conferences ... [More] , leading to round-table discussions at the LLVM conference with other interested contributors and getting to talk to other developers interested in refactoring tooling at ACCU. Presentations The learning curve for AST-Matcher-based refactoring is currently too steep. Most C++ developers who are not already familiar with the internal Clang APIs need to invest a lot in order to learn how to make such bespoke tooling to improve and maintain their codebase. The presentations both include demos of steps I’ve been taking to try to address these problems. The first demo is of clang-query discovery features which aim to reduce the need to infer AST Matcher code by examining the Clang AST itself. I also showed the debugging features I am preparing to upstream to clang-query. Finally – in terms of demo content – I showed a Qt tool which can eliminate some of the additional difficulties and problems of long-developer-iteration-time. The debugging features and the Qt tool were world exclusives at the LLVM conference (and at the ACCU conference because most people didn’t attend both ). I hadn’t shown them to anyone else before, so I was quite happy the demos went well. Videos My 25 minute presentation to the LLVM developers tried to show that these changes can make mechanical refactoring more easily available to C++ developers. The aim was to show the features to the LLVM community to illustrate the issues as I see them get some feedback about whether this is a good direction introduce myself for the sake of further code reviews (and collaborators). As this was my first LLVM conference, I am not already familiar with most of the attendees. My 1.5 hour ACCU presentation is a far-less-rushed presentation of the same tools and a repetition of some of the content at code::dive 2018. In the ACCU presentation, the new demo content starts about 30 minutes in. This talk is the one to watch if you are interested in using mechanical refactoring on your own code. Feedback was very positive from both talks, so I’m happy with that. It's always insightful how powerful visualizations are to help tackle hard problems. https://t.co/fxywk0Uycn — Manuel Klimek (@manuelklimek) April 17, 2019 Great talk! One of my highlights from this year’s #ACCUconf — Alisdair Meredith (@AlisdairMered) April 14, 2019 Great presentations at #EuroLLVM in Brussels. Glad to see Firefox used for demos (here, Stephen Kelly about refactoring using clang API) and in the audience. pic.twitter.com/Nfmbx7fK26 — Sylvestre Ledru (@SylvestreLedru) April 9, 2019 Qt Tooling Earlier this year I refactored the clang AST dump functionality. It was previously implemented in one class, ASTDumper, which had the dual responsibilities of traversing the clang AST and creating a textual representation of it. I separated the textual output from the generic output independent traversal, which introduces the possibility of alternative output formats such as JSON. Of course, given my KDE and Qt contribution history, I would only create a generic tree traversal class in order to implement QAbstractItemModel for it. The demos show all of the features you would expect from a point-and-click refactoring tool including exploring, feature discovery, debugging with in-source feedback, live source updates, experimental refactoring etc. Of course, all of this requires changes to Clang upstream (for example to add the debugging interface) which was the point of my visit to EuroLLVM. Hopefully, once enough of the changes are upstream, I’ll be able to open source the tool. The idea as always is to hopefully have enough functionality in Clang itself that IDEs such as Qt-Creator, KDevelop and Visual Studio would be able to integrate these features using their own GUI APIs, making the simple tool I made obsolete anyway. I only made it for demo purposes. This will take the mechanical refactoring workflow which is currently and turn it into You will still do the same things, but with much faster development iteration to achieve the same result. There is even more that can be done to make the process of mechanical refactoring with clang easier and faster. We discussed some of that at EuroLLVM, and hopefully all the pieces can come together soon. Meanwhile I’ll be upstreaming some of this work, talking at NDC Oslo, and at my local meetup group on this topic. [Less]

New on-site Git training KDAB’s training portfolio now includes a dedicated on-site training class about the version control system Git. The Git training material has been a supplemental chapter in our other on-site training offerings for quite a ... [More] while. Given the recent rise in interest in this chapter we’ve reorganized, updated and extended the course. It now covers the latest changes in Git and most recent Git workflows out there. This one-day training class provides a comprehensive introduction into modern software development with the code version control system Git. Beginning with the basic concepts, all the fundamental topics to manage code bases in Git will be covered. Building on that, it expands into strategies for common workflows in software development life cycles and introduces options for collaboration on large scale or widely distributed projects. Course Contents Initial setup and checkout of Git repositories Managing and committing changes Navigating through Git history Branching and merging Development strategies Collaboration via Gerrit code review and similar systems View more details about the training course, including the full table of contents. Another good reason to learn the basics of Git is that Qt itself is available through Git. A basic knowledge of Git is therefore essential if you want to apply patches back to Qt or try out a not yet released version of Qt. The Git training course is completely platform-agnostic: we have already had several training sessions including people working with either Linux, macOS or Windows. We’re focusing on Git concepts explained by Git command-line usage which is applicable on any operating system. If needed we can also give a short introduction in graphical user interfaces for Git, such as TortoiseGit, Git extensions, git-gui, etc.. This training course has a duration of one day and is currently offered as on-site training only. It is suited for developers who work on software collaboratively or who need to maintain a delivered/deployed version while simultaneously working on new features for the next one. Contact us If you’re interested in a Git training course, please contact us! The post KDAB now offers standalone on-site Git training appeared first on KDAB. [Less]

New on-site Git training KDAB’s training portfolio now includes a dedicated on-site training class about the version control system Git. The Git training material has been a supplemental chapter in our other on-site training offerings for quite a ... [More] while. Given the recent rise in interest in this chapter we’ve reorganized, updated and extended the course. It now covers the latest changes in Git and most recent Git workflows out there. This one-day training class provides a comprehensive introduction into modern software development with the code version control system Git. Beginning with the basic concepts, all the fundamental topics to manage code bases in Git will be covered. Building on that, it expands into strategies for common workflows in software development life cycles and introduces options for collaboration on large scale or widely distributed projects. Course Contents Initial setup and checkout of Git repositories Managing and committing changes Navigating through Git history Branching and merging Development strategies Collaboration via Gerrit code review and similar systems View more details about the training course, including the full table of contents. Another good reason to learn the basics of Git is that Qt itself is available through Git. A basic knowledge of Git is therefore essential if you want to apply patches back to Qt or try out a not yet released version of Qt. The Git training course is completely platform-agnostic: we have already had several training sessions including people working with either Linux, macOS or Windows. We’re focusing on Git concepts explained by Git command-line usage which is applicable on any operating system. If needed we can also give a short introduction in graphical user interfaces for Git, such as TortoiseGit, Git extensions, git-gui, etc.. This training course has a duration of one day and is currently offered as on-site training only. It is suited for developers who work on software collaboratively or who need to maintain a delivered/deployed version while simultaneously working on new features for the next one. Contact us If you’re interested in a Git training course, please contact us! The post KDAB now offers standalone on-site Git training appeared first on KDAB. [Less]

We are happy to announce version 1.13.0 of the Qbs build tool. This is the last version to be released under the auspices of the Qt Company, but certainly not the least. Highlights Transparent pkg-config support Qbs projects can now make use of ... [More] pkg-config modules. Syntax-wise, the same dependency mechanism as for Qbs’ own modules is used. For instance, on a typical Linux machine with an OpenSSL development package installed, the following is enough to let a Qbs project build against it: Depends { name: "openssl" } Internally, this functionality is implemented on top of module providers, a powerful new feature that allows creating Qbs modules on demand. Automatic Qt detection Projects with a Qt dependency now set up the required Qt-specific modules (such as Qt.core) automatically at build time, using either the PATH environment variable or the moduleProviders.Qt.qmakeFilePaths property. It is therefore no longer strictly necessary to create a profile using the setup-qt command. Behind the scenes, this feature is also implemented using module providers. Job Pools The global limit for the number of concurrently running jobs does not make sense for all types of commands. For instance, linkers are typically I/O-bound and take up a lot of memory, so it often makes sense not to parallelize them as much as compilers. Here’s how job-specific limits are set on the command line: $ qbs --job-limits linker:2,compiler:8 These limits can also be provided via preferences and in project files. The details are explained here. What else is new? Language Improvements Rules are no longer required to specify output artifacts. As a result, rules whose main purpose is in their “side effect” will look more natural now, as they don’t need to declare a dummy output file anymore. It is no longer necessary to start each project file with an “import qbs” line. The Application, DynamicLibrary and StaticLibrary items have new properties install and installDir for more convenient installation of target binaries. We introduced Process.atEnd() and FileInfo.canonicalPath(). C/C++ Support GNU linker scripts are now scanned recursively to catch changes to included linker scripts. Thanks to Ola Røer Thorsen for this contribution! The new cpp.linkerVariant property allows to force the use of ld.gold, ld.bfd or lld for linking. Qt Support We introduced the new property Qt.core.enableBigResources for the creation of “big” Qt resources. Static builds now pull in the default set of plugins as specified by Qt, and the user can specify the set of plugins by type. Android Support The AndroidApk item has been deprecated. Instead, a normal Application item can and should be used now. Building Qt apps is properly supported now. Some small changes to Qt’s androiddeployqt tool were necessary to achieve this, so you need at least Qt 5.12. Autotest Support There is an autotest module now, which you can use to specify arguments and working directory per test. Various things We introduced the texttemplate module, a facility similar to qmake’s QMAKE_SUBSTITUTES feature. We added basic support for Google Protocol Buffers (for C++ and Objective-C). Thanks to Ivan Komissarov for this contribution! Try It! The Open Source version is available on the download page, and you can find commercially licensed packages on the Qt Account Portal. Please post issues in our bug tracker. You can also find us on IRC in #qbs on chat.freenode.net, and on the mailing list. The documentation and wiki are also good places to get started. Qbs is also available on a number of packaging systems (Chocolatey, MacPorts, Homebrew) and updated on each release by the Qbs development team. It can also be installed through the native package management system on a number of Linux distributions including but not limited to Debian, Ubuntu, Fedora, and Arch Linux. Qbs 1.13.0 is also included in Qt Creator 4.9.0, which was released earlier this week. So, what now? Preparations for handing over the project to the community are ongoing. Stay tuned for further announcements. The post Qbs 1.13 released appeared first on Qt Blog. [Less]

Supervisory control and data acquisition (SCADA) systems have been around since the 1950s, far longer than most other types of computer applications. Their rock-solid performance has been responsible for the streamlining of any industry that ... [More] needs precise and consistent controls: building automation, energy management, part machining, printing and packaging, robotic assembly, ship building, water treatment, woodworking, and many more. However, this long legacy can also carry a hidden drawback – the user interfaces of many SCADA devices look more appropriate as part of Windows for Workgroups than the modern age. This situation is ripe for change. Now that everyone carries superior user interfaces in their pocket at all times, even the non-designers responsible for running the system expect their SCADA human-machine interface (HMIs) to have a certain level of polish and sophistication. Having implemented attractive SCADA HMIs for our customers, we believe that Qt is the right tool to build the modern SCADA system. Download the whitepaper and read more… The post Modernizing SCADA HMIs appeared first on KDAB. [Less]

Qt 5.9.8 is released today. As a patch release Qt 5.9.8 does not add any new functionality, but provides security fixes and other improvements. Compared to Qt 5.9.7, the new Qt 5.9.8 contains multiple security fixes, updates to some of the 3rd party ... [More] modules and close to 20 bug fixes. In total there are around 130 changes in Qt 5.9.8 compared to Qt 5.9.7. For details of the most important changes, please check the Change files of Qt 5.9.8. Qt 5.9.8 can be installed using the maintenance tool of the online installer. For new installations, please download latest online installer from Qt Account portal or from qt.io Download page. Offline packages are available for commercial users in the Qt Account portal and at the qt.io Download page for open-source users. The post Qt 5.9.8 Released appeared first on Qt Blog. [Less]

Felgo aims to improve your whole development process, from idea to app store. Today you get access to another piece of the puzzle. Introducing: Felgo Cloud Builds Boost your Qt and Felgo development with continuous integration and delivery for Qt and ... [More] Felgo projects. As the only CI/CD exclusively for Felgo/Qt, it enables users to build and distribute apps with minimum effort and maximum speed. Here is a short teaser video, introducing Felgo Cloud Builds:   Felgo Cloud Builds On-Premise Cloud Builds is available as a hosted solution by Felgo, and on-premise. Contact us if you want to host Cloud Builds on your own servers and integrate it into your existing CI/CD systems.   Contact Us for On-Premise Hosting Build your Apps in the Cloud with Felgo Cloud Builds A great development workflow will make your good developers great, and your great developers exceptional. Deploying a new version to the app stores can be an annoying and time-consuming task. You need to make sure all your native tooling for each platform is set up and working as expected. And unfortunately, those tend to just break more often than you would like to. Felgo already eliminates the need for native tooling while developing Qt/QML apps with Felgo Live code reloading. When it comes to store deployment, it was still required. This changes with Felgo Cloud Builds. You connect your source code repository and we build the project for you, for iOS, Android and any other supported platform. Soon you will also be able to build for Windows, Mac, Linux, Embedded & Web (WebAssembly). Contact us if you need any of those platforms immediately. You trigger a new build with a single button click and then you can: Download the created binaries Automatically upload them to your beta channels or the app stores Try out previous versions of your application   Build your project with Felgo Cloud Builds Benefits of Using Cloud Builds There are a number of benefits in using a CI/CD for developing your projects. First of all, the obvious one, time savings: No setup of native frameworks required Cut time to provide new test versions Cut time for publishing new versions Release more frequent updates for your users The whole build and deployment process to both app stores only takes about 5-10 minutes. Apart from that, there are several other advantages that you can benefit from: Easy integration with Git Automatic upload to iOS TestFlight and Google Play testing tracks Deploy to iOS without the need for a Mac Soon you will also be able to select different Felgo and Qt versions to build with Why we built Felgo Cloud Builds for Continuous Integration and Delivery? We built hundreds of projects using Qt on mobile platforms. Looking back at all the time spent on building and uploading binaries for every supported platform, we knew this had to change. With Felgo, we already made a lot of things simpler and faster during development, but manual publishing was still a major time-consuming process. This is why now is the perfect time to use Felgo Cloud Builds. Cross-platform cloud building and publishing. Out of the box. Rapidly. How to build apps with Felgo Cloud Builds Your project is easy to set up. And after done once, there is no need to touch the configuration again, just build! 1. Create a new Project Visit https://felgo.com/cloud-builds and create a new project. First up are the general settings. You will also be able to choose different Qt and Felgo versions for your builds soon. 2. Connect your Git repository In order to fetch your source code for building, you need to provide access to your Git repository. For public repositories, this is the easiest, as you can just provide the HTTPS URL. For private repositories, we recommend to generate a new SSH key pair. Then you can add the public key to your repository, and the private key to Cloud Builds (just as if it was your local development environment). You can use GitHub, GitLab, Bitbucket, and custom private Git repositories. 3. Select target platforms and provide signing details You can decide what platforms you want to build your application for. iOS Apple requires you to have an active App Store Connect account, in order to sign your application. To create a build that can be distributed and installed on your device, you need to provide your Certificate (*.p12 format) and Mobileprovision. Please follow the Apple developer documentation if you are not familiar with how to obtain this information. Android Android is less restrictive when it comes to signing and deployment. You can use the Development Build option to create test builds without providing any further information. Make sure that your Android device allows installation of apps from unknown sources (not via Google Play Store), to install the development build directly on your device. If you want to create a distribution build, signed with your own certificate, you need to provide your Keystore, together with the associated credentials. Please follow the Android developer documentation if you are not familiar with how to obtain this information. 4. Configure app store uploads Felgo Cloud Builds also allows you to upload your builds to the app stores. Then you can release them as test versions or publish updates for your users. iOS For iOS, it is required to provide the credentials of an App Store Connect user account. To guarantee the maximum access control for you, we recommend adding an own user to App Store Connect for Cloud Build access. Android In order to fully configure an app in the Google Play Store, one manual APK upload is required. Before this, the App Identifier is not set within the Play Store, and the automatic uploads of Cloud Builds cannot be matched with the store app. To enable app store uploads on Android, you need to provide the Google Play API JSON file of your Play Store account. 5. Build the project and grab a (quick) coffee Now you are all set and can trigger a new build. This will only take about 5-10 minutes, depending on your configured platforms and if store deployment is enabled as well. You can start a build using the “New Build” button. Then you can define the branch (or leave default) and enable deployment to app stores. 6. Download and Install Binaries Once the build is finished you can download the binaries and test them on your devices. For iOS builds, the recommended procedure is to use automatic store deployment and to install the app using TestFlight. 7. Release Test Versions or Publish Updates If store deployment is enabled, your new builds will appear in the configured stores. You can release them as new test versions or updates for your published apps. Can I use Felgo Cloud Builds? Felgo Cloud Builds is designed to work with any Qt and Felgo project. It is free to start on a fair-use policy, for any Felgo user. Just sign up for a Felgo account and you can start building.   Sign Up and Start Building   If you require advanced options, you will soon be able to customize your builds, with settings like: Select Qt version Select Felgo version Select Android SDK & NDK versions Select Xcode version Integrate custom pre/post build scripts Felgo Cloud Builds can also be hosted on-premise. Contact us if you need early access to any of those features. More Benefits with using Felgo Felgo adds a lot of features on top of Qt, which you can also use with Felgo Cloud Builds. Auto-incrementing version codes for cloud builds Native UI for iOS and Android apps Responsive design Advanced mobile components and native features Custom UI and visual effects Game engine and gaming components Plugins for augmented reality, machine learning, monetization, analytics and many more This might also be Interesting for You V-Play is Now Felgo – New Release & Roadmap QML Tutorial: How to Create Native Cross Platform Apps with Qt and Felgo | Free Udemy Course Make Cross-Platform Mobile Apps with Qt: Felgo Apps for iOS, Android, Desktop & Embedded The post Continuous Integration and Delivery (CI/CD) for Qt and Felgo appeared first on Felgo. [Less]

Qt 5.12.3, the third patch release of Qt 5.12 LTS, is released today. While not adding new features, the Qt 5.12.3 release provides a number of bug fixes, as well as performance and other improvements. Compared to Qt 5.12.2, the new Qt 5.12.3 ... [More] provides almost 200 bug fixes. For details of the most important changes, please check the Change files of Qt 5.12.3. Qt 5.12 LTS will receive many more patch releases throughout the coming years and we recommend all active developed projects to migrate to Qt 5.12 LTS. Qt 5.9 LTS is currently in ‘Strict’ phase and receives only the selected important bug and security fixes, while Qt 5.12 LTS is currently receiving all the bug fixes. Qt 5.6 Support has ended in March 2019, so all active projects still using Qt 5.6 LTS should migrate to a later version of Qt. Qt 5.12.3 is available via the maintenance tool of the online installer. For new installations, please download latest online installer from Qt Account portal or from qt.io Download page. Offline packages are available for commercial users in the Qt Account portal and at the qt.io Download page for open-source users. You can also try out the Commercial evaluation option from the qt.io Download page. The post Qt 5.12.3 Released appeared first on Qt Blog. [Less]