Mobile Card Games: How to Make the Most of User Retention & Loyalty

According to statistics released by the Flurry team, developers of mobile card games may be sitting on gold mines.

Card games can be extremely lucrative. They have the highest retention rates of any game genre right now. And they’re also played at a higher frequency than any other mobile game genre.

So how do you get in on this action? With our open-source card game example of course! We’ve released our own card game and seen the results for ourselves. The cool thing is; we’ve made the full source code of this card game example available in V-Play!

You can use this open-source card game as the basis for your own game once you download V-Play. It’s completely free to use and you can change it in any way you like. You can even charge people money to play it!

Don’t like card games? Then you’ll be happy to hear that weather apps can be just as good. And we’ve got an open-source weather app example for that too. Read on to find out how you can enjoy the high retention and use-frequency rates of these two app and game genres.

The User Loyalty Matrix

Below is the user loyalty matrix for the top mobile app and game genres on iOS devices.

iOS App Loyalty with circle

User Loyalty Matrix via Flurry

This matrix give us three vital pieces of information about each app or game genre. Besides “Frequency of Use-Per-Week” and “Retention Over 30 Days”, the matrix is also split into 4 quadrants. Each quadrant represents what type of use each app or game genre receives.

Below, you can see a further breakdown of user loyalty according to game sub-category.
Sub-Category Loyalty with rectangle

Gaming Sub-Category User Loyalty Chart via Flurry

As you can see for yourself, card games outperform every competitor when it comes to both retention and use-frequency. In fact, the use-frequency of card games is almost double that of arcade games. And when it comes to retention, card games blow away every genre besides Casino & Dice.
With such dedicated players, it’s easy to see why card games are the most lucrative game genre. Fortunately, V-Play includes a ready-made card game template for you to get in on the action right now!
Before that, let’s take a quick look at the 4 quadrants of app and game use. This will let you see how your current or expected app and game projects should work out.

The Different Forms of App & Game Usage

Daily Interaction from a Loyal User Base

Quadrant I includes apps & games that have high retention rates and almost daily use. Weather apps fall into this quadrant. This is because users like to check weather apps daily for upcoming forecasts. Unless a forecast is terribly wrong, they’re unlikely to change their weather app. You can see more about our weather app template here.

Card games fall into this category as well. This is because card games are social games that people play with their friends. People want to play a game they know with people they know. This means they often return to the same card game for long periods of time.

High Interaction after Installation but Poor User Loyalty

Quadrant II includes apps & games that people use a lot after a first installation, but then see a decrease in loyalty over time. Apps & games in this quadrant lack an everyday use or the social features.

In this category you will find productivity apps, word games, sports games and puzzles.


Installed, Used and Discarded – No User Loyalty

Quadrant III includes apps that have high churn and infrequent use. People install these apps for a certain purpose and then delete them later on. Travel apps fall into this category on both platforms.

An example of this quadrant are city guide apps that people download before trips to new places. Once they return home and the app has no purpose, it gets deleted.

Low Interaction Levels but Loyal User Base

Quadrant IV includes apps that have low frequency of use, but a loyal user base. These apps include reader apps for magazines and newspapers. While a user may not check them everyday, they’re unlikely to switch the newspaper they read.

This leads to loyal users over years with regular, but not everyday use.

Make a Card Game with Our Open-Source Example

So you’re ready to get in on the gold rush? Read on to find out how you can launch your own highly lucrative card game today.

One Card! – Mobile Card Game Example

One Card! is a 4-player card game you can play against real opponents or as a single player. The game was first released to showcase V-Play’s Multiplayer component, and it’s proven to be a big success in it’s own right. With little-to-no marketing, the game has gained over 200,000 players. Since its release, we’ve noticed strong user retention and high frequency metrics within the game, exactly as Flurry described.

The secret behind these strong metrics is the V-Play Multiplayer component. This component adds a wide range of features to the game, which make it perfect for retaining users.

V-Play Multiplayer adds leaderboards for high scores, a social system for adding friends, in-game chat, a messaging service and an intelligent matchmaking service for creating or joining games.

It’s the combination of social features like in-game chat and the friend system with advanced matchmaking options that keep players coming back.The social features keep players interested because it’s an easy way for them to play with their friends. And the advanced matchmaking features mean that even when their friends aren’t around, they’ll still have real players to play against.

In fact, the matchmaking features of the V-Play Multiplayer component allow players to join a game at any time. Players can create a game and invite their friends to join in via Push Notification. And they in turn can join games that they’ve been invited to – even when the game has already begun. V-Play Multiplayer supports this late-join feature and it is one of the success drivers in the Once Card game.

One Card! Also features global leaderboards and friend leaderboards so players can keep track of their achievements and progress in the game. These features can be added to any V-Play game in just a few minutes thanks to the V-Play Game Network component.

You can watch a short trailer for the game and its multiplayer features here:

You can access and change this open-source game example in any way you like, once you download V-Play.

V-Play is a free cross-platform development tool that has been ranked above Unity, Corona and many more for ease-of-use, time-savings and customer satisfaction. Sign-up is free and includes access to our entire range of open-source app and game examples. We have example apps and games for side-scrollers, platformers, map apps, messaging apps and more. You can see all the app & game examples in our online documentation!

Once you download the SDK, there are a few different ways to access the card game example. First, you can select it from the examples view in Qt Creator. You can also find it in the V-Play Sample Launcher or you can launch it from your installation directory. You can learn how to do that here!

Download Free One Card! Source Code

Enter the highly lucrative mobile card game genre today and start building your loyal user base now!

Of course, if you want to try One Card! before you download V-Play, you can find it in the App Store and Google Play.

Tell Your Friends!

Don’t keep this secret to yourself, tell your friends. You can like this article on Facebook using the button on the left. For more articles like this, sign-up for V-Play and you’ll get it in your inbox when it is released. It has information on a range of topics from user acquisition to free tools for making pixel art, plus news on all the latest V-Play updates and features.

Hope you liked the article, make sure to check back soon for more informative posts on mobile app and game development!

More Posts Like This

16 Sites Featuring Free Game Graphics for Game Developers

game graphics

How to Quickly Make a Flappy Bird Game

Flappy Bird

How to Make a Game like Super Mario Maker with Our New Platformer Level Editor

super mario level editor blog

Release 2.9.0: V-Play Multiplayer Launch


The post Mobile Card Games: How to Make the Most of User Retention & Loyalty appeared first on V-Play Engine.

Qt Together with Telechips

We are happy to announce the new collaboration between The Qt Company and Telechips. Telechips ( is a leading fabless semiconductor company in Asia focusing on automotive and consumer electronics industries, where Qt has been used as a core component for a wide variety of innovative products.

Cooperation between The Qt Company and the SoC company based in South Korea brings great synergy. Working together, we are able to provide users and customers with an impressive toolset which features Telechips hardware with the latest Qt libraries and Qt Creator integration. This enables customers to begin software development and deliver immediate results. This provides cost-efficiencies that set a solid foundation and prove the value of Qt in each multiple industries. This is the first step for making a great partnership.


Figure 1. Deployment on Telechips TCC8971 from Qt Creator

The board was connected to the laptop via USB interface and the target of deployment was set to the custom device in Qt Creator – as you can see in the above picture. The Qt application was cross-compiled and deployed from Qt Creator in the same manner as the supported platforms of Boot to Qt (

Telechips already provides a nice Linux distribution based on Yocto for their devices. So we were able to build up Qt demo launcher and Qt Creator integration was provided out-of-the-box. Now we can build a system image with the latest Qt version and deploy a Qt application from Qt Creator to a device directly with just a few clicks. It means it would be perfectly possible to keep on using up-to-date Qt libraries on the hardware and evaluate other offerings such as Qt Automotive Suite (

Currently you need to build the image by yourself with our support, but we expect it will be possible to deliver complete build recipes in the near future. Please stay tuned for update about upcoming steps with Telechips.

For further details, please contact South Korea office of The Qt Company.

The post Qt Together with Telechips appeared first on Qt Blog.

Movin' on...

A year has gone by since I started work with Canonical. As it turns out, I must be on my way. Where to? Not real sure at this moment, there seems plenty of companies using Qt & QML these days. \0/

But saying that, I am open to suggestions. LinkedIn
Plenty of IoT and devices using sensors around. Heck, even Moto Z phone has some great uses for sensor gestures similar to what I wrote for QtSensors while I was at Nokia.

But a lack of companies that allow freelance or remote work. The last few years I have worked remotely doing work for Jolla and Canonical. Both fantastic companies to work for, which really have it together for working remotely.

I am still surprised that only a handful of companies regularly allow remote work. I do not miss the stuffy non window opening offices and the long daily commute, which sometimes means riding a motorcycle through hail! (I do not suggest this for anyone)

Of course, I am still maintainer for QtSensors, QtSystemInfo for the Qt Project, and Sensor Framework for Mer, and always dreaming up new ways to use sensors. Still keeping tabs on QtNetwork bearer classes.

Although I had to send back the Canonical devices, I still have Ubuntu on my Nexus 4. I still have my Jolla phones and tablet.

That said, I still have this blog here, and besides spending my time looking for a new programming gig, I am (always) preparing to release a new album.
and always willing to work with anyone needing music/audio/soundtrack work.

Qt Everywhere at CES 2017

Experience the latest development in connected devices & powerful cross-platform applications in our meeting suite and CES, the world’s leading consumer electronics event in dazzling Las Vegas show front. Come see our demos, visit the industry leaders showing Qt, and book a meeting with the Qt executives to discuss your product strategy.

Interact with innovative demonstrations at the Westgate Meeting suite #2010:

  • Future Multiscreen UI – Qt Automotive Suite
    Research different UI concepts in vehicle instrument clusters and IVI systems to integrate different Qt technologies relevant especially to the automotive industry.
  •  IVI & Application Store Implementation – Qt Automotive Suite
    Streamline reference UI designs for IVI systems including multiple IVI applications and application store development.
  • Boot-time Optimization
    Boot up your project in 1.2 seconds with Qt and Toradex Apalis i.MX6 Computer on Modules
  • Qt on Android Wear
    Easily Kickstart Qt for wearables with Qt 5.7
  • Qt Lite Project for IoT
    Faster, smaller and more impressive Qt than ever made for IoT system development.

Visit the industry leaders on the show floor:

  • LG – WebOS TV platform devices and Vehicle Component (VC) built with Qt, LVCC North Hall Upper level meeting rooms
  • Formlabs – Advanced connected 3D printers built with Qt, Tech West, Sans Expo Center, Booth #43215
  • Delphi – IVI system based on Qt 5.5 built with Qt, LVCC North Plaza
  • HARMAN – Automated UI Development Suite built with Qt, Hard Rock Hotel, 4th floor private meeting rooms, and GENIVI Showcase on Thursday, January 5 at the Bellagio
  • BlackBerry QNX – Qt-based system using QNX Platform for Infotainment, LVCC North Hall #7029
  • AGL – In-Vehicle Infotainment (IVI) system, GENIVI Showcase on Thursday January 5 at the Bellagio

Schedule a visit to meet with Qt executives at the Westgate, Suite #2010, from January 5-8, 2017 at CES.


The post Qt Everywhere at CES 2017 appeared first on Qt Blog.

Cutelyst 1.2.0 released

Cutelyst the C++/Qt web framework has a new release.

  • Test coverage got some additions to avoid breaks in future.
  • Responses without content-length (chunked or close) are now handled properly.
  • StatusMessage plugin got new methods easier to use and has the first deprecated API too.
  • Engine class now has a struct with the request subclass should create, benchmarks showed this as a micro optimization but I've heard function with many arguments (as it was before) are bad on ARM so I guess this is the first optimization for ARM :)
  • Chained dispatcher finally got a performance improvement, I didn't benchmark it but it should be much faster now.
  • Increased the usage of lambdas when the called function was small/simple, for some reason they reduce the library size so I guess it's a good thing...
  • Sql helper classes can now use QThread::objectName() which has the worker thread id as it's name so writing thread safe code is easier.
  • WSGI got static-map and static-map2 options both work the same way as in uWSGI allowing you to serve static files without the need of uWSGI or a webserver.
  • WSGI got both auto-reload and touch-reload implemented, which help a lot on the development process.
  • Request::addressString() was added to make it easier to get the string representation of the client IP also removing the IPv6 prefix if IPv4 conversion succeeds.
  • Grantlee::View now exposes the Grantlee::Engine pointer so one can add filters to it (usefull for i18n)
  • Context got a locale() method to help dealing with translations
  • Cutelyst::Core got ~25k smaller
  • Some other small bug fixes and optimizations....

For 1.3.0 I hope WSGI module can deal with FastCGI and/or uwsgi protocols, as well as helper methods to deal with i18n. But a CMlyst release might come first :)


Summary of 2016

So, 2016 has been a great year to me. Interesting in many aspects, but most has turned out to be for the better. I’ve gotten to know a bunch of awesome new people, I spoken about open source, Qt and Linux in Europe and USA, I’ve helped hosting an open source conference in Gothenburg, I’ve learned so much more professionally and as a person, and I’ve really enjoyed myself the whole time.

2016 was the year that…

  • … myself and Jürgen where Qt Champions for our work with the qmlbook. It feels really great getting recognition for this work. I really want to take QML Book further – during 2016 both myself and Jürgen have been too busy to do a good job improving and extending the text.
  • … I had to opportunity to visit the Americas (Oregon and California) for the first time in my life. Felt really nice having been on another continent. Now it is only Africa and Australia left on the list :-)

  • … I picked up running and has run every week throughout the year, averaging almost 10km per week. This is the first year since we built out house and had kids (so 11 or 12 years) that I’ve maintained a training regime over a full year.
  • foss-gbg went from a small user group of 15-30 people meeting every month to something much larger. On May 26 the first foss-north took place. This is something some friends of mine and myself have discussed for years and when we finally dared to try it was a great success. We filled the venue with 110 guests and ten speakers and had a great day in the sunshine. In the events after foss-north, the local group, foss-gbg has attracted 40-60 people per meeting, so double the crowd.

  • Pelagicore, the start-up I joined in 2010 when we were only 6 employees, was acquired by Luxoft. We had grown to 50+ employees in the mean time and put Qt, Linux and open source on the automotive map. It has been a great journey and I feel that we being a part of something bigger lets us reach even further, so I’m really excited about this.

2017 will be the year that…

  • … I make more time for writing – on qmlbook, this blog and more.
  • … I improve my running and increase my average distance per run as well as distance per week.
  • foss-north will take place again. This time with double the audience and dual tracks for parts of the day. I will share more information as it develops. This time, the date to aim for is April 26. In the mean time, foss-gbg will have fewer, but larger, meetings.
  • … Qt, Linux and open source becomes the natural choice in automotive. I will do my best to help this turn out true!

Even as 2016 has been really good, I hope that 2017 will be even greater. I’m really looking forward to learning!

Qt 5.8.0 Release Candidate Available

Qt 5.8.0 Release Candidate is now available!

The target is to release the official Qt 5.8.0 release during January 2017 so please try the RC now. All feedback is welcome! Please report new bugs to You can also send e-mail to Qt Project mailing lists or contact us via IRC.

More information about the upcoming Qt 5.8.0 release can be found on the  Qt 5.8.0 new features page, Qt 5.8 Beta blog post and from Qt Documentation snapshots.

You can update Qt 5.8.0 RC in your existing online installation by using the maintenance tool. You can also download new installers (online or offline) from the Qt Account (for commercial users) or from

The post Qt 5.8.0 Release Candidate Available appeared first on Qt Blog.

KDAB adds five new trainings in 2017

We’re adding an exciting raft of new trainings to our schedule for 2017 and some new locations, including San Francisco, Seoul and Beijing.

Throughout the year you will be able to sign up for top class, always-up-to-date, original-authored trainings, presented by fully qualified KDAB trainers, all engineers actively involved in delivering KDAB’s high quality projects. Here’s what others are saying about our trainings.

As well as the latest updates in Qt, C++, OpenGL, Debugging and Profiling, CMake and all the topics you expect from us, we also offer the following brand new trainings from KDAB experts:

  • Qt Automotive Suite
  • Qt for Automotive Development
  • Introduction to C++
  • Qt 3D
  • User-Centred Development and Usability

Sign up now!

The post KDAB adds five new trainings in 2017 appeared first on KDAB.

Qt Automotive Suite video

KDAB’s experience with using Qt in the motor industry has shown us that a specifically tailored automotive Qt solution would be very valuable. So, with our partners The Qt Company and Pelagicore we created the Qt Automotive Suite, a comprehensive solution with a licensing model specifically designed for the automotive industry.

Read a more in-depth view of the Qt Automotive Suite…

The post Qt Automotive Suite video appeared first on KDAB.

How to Make Cross-Platform Mobile Apps with Qt – V-Play Apps

2016 was a big year for V-Play Apps. After its initial release in August 2015, the V-Play Apps SDK has been improved tremendously. We’ve added a lot of features to the tool this year and made even more open-source example apps available to V-Play developers. To celebrate this, we’ve produced a short video to help you find out what V-Play Apps is all about!

Check it out to find out why V-Play Apps should be your first choice when it comes to cross-platform development!

What is V-Play Apps?

Build Your App with QML & JavaScript

V-Play Apps is a tool for creating cross-platform apps using QML and JavaScript. QML is a rapid development language that’s easy to learn, and perfect for making feature rich, animated UIs. JavaScript is used to control your app’s logic.

Create Truly Cross-Platform Mobile Applications

Mobile apps created with V-Play Apps have a single code base. You can use the same source code to deploy your app to Android, iOS and other platforms. And because all V-Play Apps feature responsive-design as standard, your apps will have a native look and feel on all platforms.


Develop for Free or Upgrade for Advanced Features & Support

You can develop and release your mobile app with V-Play Apps for free. For advanced support, training and features, you can sign up for V-Play Indie on a monthly or yearly basis. For an all-inclusive package and early access to new V-Play features, you can evaluate V-Play Enterprise.


See our pricing page or get in touch for all the options. We’re happy to help!

How Does V-Play Apps Work?

V-Play & Qt

V-Play Apps is based on Qt, the framework behind popular applications such as Skype, VLC Player and Autodesk Maya. There are over 1 million active Qt developers in the world today, with more on the way.

You can develop your V-Play Apps using the Qt Creator IDE. This free IDE is included when you download V-Play and features code completion, debugging and profiling and an integrated UI Designer.

Qt development with V-Play presents mobile app developers with a whole new world of possibilities. V-Play Apps comes with ready-made Qt components for sensors, advanced connectivity options, multimedia and HTML5 content, shader effects, and much more.

Emulate Different Mobile Platforms As You Develop

V-Play Apps allows you to emulate different platforms while developing on your desktop. With our platform emulation feature, you can see what your app will look like on an iPhone 4 or a Nexus tablet instantly. Visual components automatically change their style, depending on your target platform.

Get Responsive Design On All Devices

You can also switch between different resolutions during development builds to see how your app or game will appear on different devices. This makes testing much easier as you don’t need to deploy your app or game to real devices to see what it will look like on an iPhone or a Nexus tablet.

With built in support for responsive design, you can achieve pixel perfect layouts on any device, including tablets or embedded systems. V-Play Apps even works on in-vehicle computers, in-flight entertainment systems, smart home devices and more.

Enjoy Native Look & Feel On All Platforms

V-Play Apps run fully native on devices without using any wrapper or hybrid methods. Our auto-adjusting UI elements can change from being a navigation drawer on Android device to being a tab on your iPhone. This means your users can enjoy a native look & feel while using your app.

Access to Camera, Sensors, File System and many more native device features also work as intended.

What Are the Benefits of V-Play Apps?

Ease of Use, Time Savings & Customer Satisfaction

The main benefits of V-Play Apps are its ease of use and time savings. In fact, V-Play has been ranked higher than Xamarin, PhoneGap, Unity, Corona and others as the easiest-to-use cross-platform tool with the most time-savings and most satisfied customers..

It’s the component-based approach that makes V-Play so easy to learn and implement. In some cases, mobile apps created with V-Play had 10x less code than apps created with other frameworks. These code reductions mean less bugs to fix and more time to concentrate on testing and improving your app before release.

It also means you can go from developing an app in weeks and months to making a complete app in just a few days.

And if you ever need some extra help or have a feature request, you can get in touch with our highly-rated support team. Drop us a line at if you have any questions!

V-Play Plugins

If you want to include advertising, analytic tools or other services in your app, you can save even more time by choosing from our wide range of V-Play Plugins. You can monetize your app with native in-app purchases and multiple ad networks with rewarded videos, interstitials or banner ads.

You can use the Google Analytics plugins to gain insights on user behaviour within your app. Or you can send push notifications or add social features to engage your users with ease. It will take you less than 10 minutes to integrate these plugins, using only 10 lines of code, which then works cross-platform.


Here’s a quick example of how you can add the OneSignal plugin to your V-Play App and send a simple push notification:

import QtQuick 2.0
import QtQuick.Controls 2.0
import VPlayPlugins 2.0

ApplicationWindow {

  OneSignal {
    appId: ""
    onNotificationReceived: {
      console.debug("Received push: ", message)

To see an example of how easy it is to add V-Play Plugins to your V-Play App, check out our quick guide here.

Extendable Code

If you have existing native code or if you want to use a 3rd party SDK, you can extend V-Play Apps with C++, Java or Objective C code without any limits.

What Else Should I Know About V-Play Apps?

Open Source App Examples

V-Play Apps comes with a selection of open-source app examples. These app examples can be used as the basis for your own app and can be changed in any way you like.

For example, you can adapt a Twitter Viewer app created with V-Play, in just 700 lines of code. It connects with the Twitter REST API and includes advanced animations and native navigation on all platforms – you can use this open-source code for free in your own app!

The easiest way to view these app examples is with the V-Play Sample Launcher. This standalone application offers access to all of V-Play’s app examples. You can download it for free here!

You can also access these app examples directly from the SDK. Navigate to <Path to your V-PlaySDK>/Examples/V-Play>in your V-Play installation. Just open the .pro files with Qt Creator and you can run the demos on your development PC or deploy them to your mobile devices.

V-Play Apps Showcase App

You can get a quick overview of the power of V-Play Apps by downloading our Qt 5 Showcases app from the App Store or Google Play.

google_play_badge-1  itunes_download_link

This Qt 5 Showcases App contains multiple application samples developed with V-Play Apps. It shows developers and designers how V-Play Apps is used to create mobile apps with native user experience (UX) and fluid UI animations.

Download V-Play Apps for Free

Get your free V-Play Apps download now and start making your cross-platform mobile app!

Download V-Play Apps Now!

If you’re completely new to Qt and mobile development, you can take a look at our Getting Started guide for help!

More Posts like This

20 Free & Secure Alternatives to the Parse Push Service


The 13 Best Qt, QML & V-Play Tutorials and Resources for Beginners

tutorials capture

21 Tips That Will Improve Your User Acquisition Strategy

User Acquisition

7 Useful Tips That Will Improve Your App Store Optimization

User Acquisition

The post How to Make Cross-Platform Mobile Apps with Qt – V-Play Apps appeared first on V-Play Engine.

Qt Champions for 2016

Qt Champions

It is the time of the year when we take a look back and see who have been the Qt Champions this year.

First I would like to point out that all the people nominated are all incredible!

Let’s take a quick look at all the nominees:

  • JKSH – a long time Qt developer, who shows up almost everywhere where you look. And I do mean everywhere, take any Qt online service we have and he can be found there. Maybe not the first person you run into, but always there helping people with Qt.
  • kshegunov – a newer face in the Qt Community, but has already made an impact. Has contributions into Qt during his first year as a community active. You can also find him in the C++ Gurus section of the Qt Forums answering and sometimes asking hard questions.
  • Ekke – with a strong background in BlackBerry development, Ekke has moved to full time to the Qt community recently. He has a running blog post series on Qt for mobile development and he made the event applications for both QtCon and Qt World Summit this year. As a long time developer he has provided the developers of Qt Quick Controls 2 with a lot of feedback and ideas.
  • BenLau – another long time Qt developer. He has done a lot with Qt, and got some mentions from the developers of QML too. You can find Ben in many places, also the QtMob slack group, where Qt mobile developers gather nowadays. Take a peek at Bens github page to see a nice green wall.
  • mrjj – is a familiar name to anyone on the Qt Forum. Among the top three active contributors on the Qt Forum and especially this year he has been incredibly helpful and active.
  • VoidRealms – 155 Qt videos on YouTube and counting. And 155 code examples to go with those 155 videos. Also a bunch of projects and other code examples in Qt and multiple other languages too. He has been working with Qt for a long time and still releases videos at a steady pace.

As a short reminder, Qt Champions  are people who go the extra mile for the Qt community. They help out newcomers and make the community a welcoming and friendly place for everyone. The categories for Qt Champion nominations go as follows:

  • Community Builder – helping the Qt community
  • Ambassador – making Qt known
  • Content Creator – creating and sharing original Qt content
  • Maverick – significant and surprising contributions
  • Rookie of the Year – best first contribution to the Qt codebase

In light of the sheer skill and persistence of all the nominees, I find it hard to do anything else than award all the nominees the title of Qt Champion 2016.

The categories for our new Qt Champions go as follows:

  • Community Builder: JKSH and mrjj
  • Ambassador: Ekke
  • Content Creator: VoidRealms
  • Maverick: Benlau
  • Rookie of the Year: kshegunov

Please join me in congratulating the new Qt Champions!

The post Qt Champions for 2016 appeared first on Qt Blog.

Embedded Devices with Qt and the INTEGRITY RTOS

by Rolland Dudemaine, Green Hills Software (Qt Blog)

The Green Hills INTEGRITY Real-Time Operating System (RTOS) is widely used in safety- and security-critical systems. Work has been ongoing for already some time to get Qt 5 running on INTEGRITY, and now we are delighted to show a proof-of-concept port of Qt 5.7 on top of INTEGRITY.

Qt 4.8 support has been available for a long time on the INTEGRITY RTOS. We are now pleased to announce that a proof-of-concept port of Qt 5.7 to INTEGRITY has been completed by Green Hills engineers. During the work, we tested the port on all major embedded HW platforms, including ones that have OpenGL ES support available. Work continues together with The Qt Company and the Qt ecosystem and thanks to this initial prototype, the upcoming Qt 5.9 is expected to contain INTEGRITY support.

In the automotive space where both Qt and the INTEGRITY RTOS are already present, this allows for additional synergies where Qt can be used in conjunction with INTEGRITY on both infotainment systems as well as instrument clusters. Especially in automotive instrument clusters as well as in other safety critical systems the certified RTOS is a vital building block.

In the prototype Qt integration we built all the basic libraries one expects: Core, Network, Gui, Svg, XmlPatterns, ImageFormats, Widgets. Applications can also take advantage of the more modern part of the framework, including Qt Quick 2, Qt Quick Controls 2, and Qt 3D.

The following video presents a Qt cluster running on the proof-of-concept port of Qt 5.7 on INTEGRITY 11.4.4 on NXP i.MX6.

The proof-of-concept port has been so far been used on NXP i.MX6, Intel Apollo Lake, TI Sitara and Jacinto 6. Other platforms like Renesas R-Car H3 are expected to come very soon too. We are also strongly cooperating with partners from the Qt ecosystem who can help customers get to production faster with the integrated solution.

The post Embedded Devices with Qt and the INTEGRITY RTOS appeared first on Qt Blog.

Eliminate Technical Risks in Your Software Project

The Qt framework contains very powerful libraries that help to create great products that provide modern user experiences. At the same time, Qt is versatile and can be used across multiple purposes which offers many options and increases flexibility – but these can also be puzzling if one is not familiar with Qt.

Meeting your time-to-market targets on-time is essential and a key component in defining your success. One of the most important things in a software project is to eliminate risks, especially technical risks in this case, that can hinder reaching the product requirements and jeopardize the project schedule.

Nowadays, customer expectations are based on usability experiences from modern smartphones and tablets, where ease-of-use and smooth operations are fundamental. At the same time, bill of material (BOM) is playing its part of this equation meaning that the most efficient chipsets are rarely used but you need to maximise benefits of the software framework.

Meeting Your Performance Targets

The most common request to The Qt Company Services is to help with the performance. Typically, we in the Qt Consulting team receive that type of request when the feature complete milestone has already passed, and the customer has invested a lot of money into development. Unfortunately, quite often we see that there have been mistakes made early on in the project with the architecture solution for example. This can happen if Qt is not used efficiently which can hinder the achievement of your product requirements or specifications causing expensive refactoring.

We are happy to help with advising customers on planning and designing the product. We provide the best value for our customers in an architecture workshop which gives guidance and points you into the right direction from Day One.

Some customers building with proof of concept (POC), and this can be challenging if there is a gap in Qt know-how. Our experts can build customer use cases for different platforms typically within a week or two, and we have a wide range of ready-made demos in different HW which provide good benchmarking for the customer to make the right decisions.

For more information on Qt Consulting Services, please contact

The post Eliminate Technical Risks in Your Software Project appeared first on Qt Blog.

Cutelyst 1.1.2 released

Cutelyst the C++/Qt Web Framework just got a new release.

Yesterday I was going to do the 1.1.0 release, after running tests, and being happy with current state I wrote this blog post, but before I publish I went to CMS (CMlyst) to paste the same post, and I got hit by a bug I had on 1.0.0, which at time I thought it was a bug in CMlyst, so decided to investigate and found a few other bugs with our WSGI not properly changing the current directory and not replacing the + sign with an ' ' space when parsing formdata, which was the main bug. So did the fixes tagged as 1.1.1 and today found that automatically setting Content-Length wasn't working when the View rendered nothing.

Cutelyst Core and Plugins API/ABI are stable but Cutelyst-WSGI had to have changes, I forgot to expose the needed API for it to actually be useful outside Cutelyst so this isn't a problem (nobody would be able to use it anyway). So API stability got extended to all components now.

Thanks to a KDAB video about perf I finally managed to use it and was able to detect two slow code paths in Cutelyst-WSGI.

The first and that was causing 7% overhead was due QTcpSocket emitting readyRead() signal and in the HttpParser code I was calling sender() to get the socket, turns out the sender() method implementation is not as simple as I thought it was and there is a QMutexLocker which maybe caused some thread to wait on it (not sure really), so now for each QTcpSocket there is an HttpParser class, this uses a little more memory but the code got faster. Hopefully in Qt6 the signal can have a readyRead(QIODevice *) signature.

The second was that I end up using QByteArrayMatcher to match \r\n to get request headers, perl was showing it was causing 1.2% overhead, doing some benchmarks I replaced it by a code that was faster. Using a single thread on my Intel I5 I can process 85k req/s, so things got indeed a little faster.

It got a contribution from a new developer on View::Email, which made me do a new simplemail-qt release (1.3.0), the code there still needs love regarding performance but I didn't manage to find time to improve it yet.

This new release has some new features:

  • EPoll event loop was added to Linux builds, this is supposedly to be faster than default GLib but I couldn't measure the difference properly, this is optional and requires CUTELYST_EVENT_LOOP_EPOLL=1 environment to be set.
  • ViewEmail got methods to set/get authentication method and connection type
  • WSGI: can now set TCP_NODELAY, TCP KEEPALIVE, SO_SNDBUF and SO_RCVBUF on command line, these use the same name as in uwsgi
  • Documentation was improved a bit and can be generated now with make docs, which doesn't require me to changing Cutelyst version manually anymore

And also some important bug fixes:

  • Lazy evaluation of Request methods was broken on 1.0.0
  • WSGI: Fixed loading configs and parsing command line option

Download and have fun!

Qt 5.7.1 Released

Qt 5.7.1 has been released today. It contains all the latest bug fixes and improvements, including everything from Qt 5.6.2 patch release as well as additional improvements and functionality not available in the Qt 5.6 branch.

The brand new Qt Creator 4.2.0 is also included in the Qt 5.7.1 offline installer packages as well as the online installer.

For details of the new functionality, please check the Change files of Qt 5.7.1 and Qt Creator 4.2.0 release blog post.

If you are using the online installer, Qt 5.7.1 and Qt Creator 4.2.0 can be updated using the maintenance tool. Offline packages are available for commercial users in the Qt Account portal and at the Download page for open-source users.

The post Qt 5.7.1 Released appeared first on Qt Blog.

Qt Creator 4.2 released

We are pleased to announce the release of Qt Creator 4.2

Qt SCXML Editor

Flat Dark Theme - Qt Creator 4.1
Qt SCXML is a new module in Qt that allows you to create state machines from State Chart XML and embed them into Qt C++ and Qt Quick applications (Overview). It was released as Technical Preview in Qt 5.7 and will be released fully supported with Qt 5.8.
Qt Creator 4.2 now supplements the Qt SCXML module by offering a graphical editor for SCXML (experimental). It features editing states and sub-states, transitions, events, and all kinds of properties. The editor is experimental and the plugin is not loaded by default. Turn it on in Help > About Plugins (Qt Creator > About Plugins on macOS) to try it.

Projects Mode

We reworked how you select the project and its diverse settings in Projects mode. Instead of nested tabs, you now select the project from a dropdown. The settings form a tree that shows all available kits and other categories, making for a much cleaner UI. Enabling use of a kit for a project is now easily done by clicking the entry in the tree. Please provide feedback on any remaining issues through our bug tracker.

Qt Quick Designer

State mapping via when condition - Qt Creator 4.2
Qt Quick Designer has received many smaller features in this release. In the connections editor, there is a new section for managing the imports and property definitions that are necessary for using C++ backend objects (documentation). Also, support for padding (Qt Quick 2.6) was added, and you can now edit the when condition of states, and the diverse font properties of text items.

CMake support

Several fixes and improvements were implemented, like: Improvement of performance when opening CMake projects, and support for predefined options for properties. In addition, Tobias contributed the server-mode to CMake in preparation for a much more complete CMake support in the next Qt Creator release.

QML Profiler

When profiling your QML code you now have the option to show memory usage and allocations as flame graphs as well. You can now position orientation lines.

Other Additions and Improvements

We added Tools > Diff > Diff Current File and Diff Open Files for showing a local diff of the modifications of files in Qt Creator with respect to their versions on disk.
There were many more changes, which are described in more detail in our change log.

Get Qt Creator 4.2

Head over to the Qt Account Portal or to the download page, get and install Qt Creator 4.2. As usual, the bug tracker will accept bug reports. You also find us on IRC on #qt-creator on, and on the Qt Creator mailing list.

The post Qt Creator 4.2 released appeared first on Qt Blog.

sensorfw & Qt is not just UI framework! or Without sensors, there's no IoT

Like it says on the Intel IoT developer site, "Without sensors, there's no IoT".

Because I am the maintainer of QtSensors, I like to inquire about  people's use of sensors and if they use QtSensors. Over the years, I have heard quite often something like, 'Qt is thought of as a UI framework'. *sigh*
But Qt is more than just a UI framework and it's use is not dependent on widgets or declarative wizardry. It is used in quite a few middleware components without UI elements. One of those middleware frameworks is Sensor Framework.

Sensor framework is a daemon that uses a plugin system written using Qt for reading various sensors such as accelerometer or light sensors. It was originally developed by Nokia for Harmattan and ran on the N9. It was also used in MeeGo and later included in the Mer Project and on Jolla phones and the ill fated tablet. So it has been released onto a few commercial products.

We looked at it when I was working at Nokia on the project that I still cannot name, but we had decided we would come up with our own solution. Looking back, this was the wrong decision, we should have taken the already proven sensor framework and ran with that. Why? Because it existed and works.

I started maintaining it when I was a privateer (contractor) developer for Jolla. No one else had touched it for some time so I grabbed the few not yet merged bug fixes and added support for libhybris/android libhardware adaptors.

Sensor Framework has support for multiple clients with down sampling for different data rates. It uses dbus for control lines (to start and stop, etc) but sends data through a socket. It also has a working backend in QtSensors.

I noticed that Ubuntu's Unity does nothing to respond when I put this into "tablet mode". I have to manually open the virtual keyboard among other things.

So I thought I could use sensorfw on my Dell 2 in 1. It's one of those converged laptop/tablet devices. It has a few sensors - accelerometer, gyroscope, magnetometer, and lid sensors. One problem... sensorfw does not support lid sensors, or a few other sensors that are around today in IoT (which I will add a bit later). Lid "sensor" might be a bit of a misnomer, as they could be switches but I'd like to think it is more like a hal effect sensor that uses magnets. In any case there are event nodes to use.

First one I chose is to add the lid sensor - to detect when this machine is put into tablet mode, so the UI can better deal with it.

I also noticed that this kernel has support for iio sensor interface for the accel and gyro. Sensorfw only supports sysfs, evdev and hybris interfaces, so I also wanted to add support for that.

I worked on adding iio support first. Well... really just wrote a sensor adaptor plugin. My plugin supports accelerometer, gyroscope and magnetometer, which this device seems to have. I will expand this to support other sensors later, as well as clean it up a bit.

Thanks to QtSensors sensor framework backend, I can make a UI app change with the orientation and lid changes. Better yet, I can create a game that uses accelerometer data like a marble maze game. Or I can upload the data to one of those Node.js data visualization web apps.

And since sensor framework is opensource, others can as well.

20 Free & Secure Alternatives to the Parse Push Service

Since Facebook announced the end of Parse, we’ve been looking at the best alternatives for sending push notifications.
Push notifications are an essential tool for engaging and retaining users. Developers can use them to send their users reminders, let them know about recent updates or ask for reviews and feedback. Using a reliable service for push notifications helps if you want your app or game to have active users.
Until now, Parse has been one of the best suppliers of this service. Unfortunately, it ends, in it’s current form, after January 2017. It’s becoming an open-source project and won’t offer all the same services as it used to.
Since this news broke in January 2016, a number of alternatives to Parse have grown in popularity. We’ll take a look at what these services have to offer and how they compare to the original Parse Push notification service!

Plus, find out how to integrate a push notifcation service into your V-Play App or Game with a simple code snippet!

Requirements – Alternatives to Parse

We had four main requirements in mind when looking into Parse alternatives:


Free Usage Plan

The new service should provide a free usage plan so developers can try it out for themselves and see how to get started. Signing up for a service without the ability to test their push notification features in a real world scenario is a serious roadblock for most developers.

Similar Feature Set

The new plugin should provide the same feature set we already offer with our Parse plugin. We still want the ability to send push notifications on a transactional basis to single devices, all devices of a user, or a group of users. This is an essential feature that must be supported. The concept of channels, used within the Parse plugin, is an optimal design pattern that we want in any potential replacement.

Easy Migration

We were looking for a scenario where transitioning from one push provider to another would only take a few seconds. The best case would see you as a Parse Plugin user making only one change to your code, simply changing your item’s name to see the new service properly set up.

Cross-Platform Performance

Like Parse, a new plugin should handle the platform-specific differences between iOS and Android transparently, both in the app or game code, and from the back end side.


Ideally, sending pushes from your server shouldn’t get out of control when sending different requests for iOS and Android, and dealing with sockets or customized payloads. We wanted to stick with a simple HTTP request, sending a JSON body, and the rest being handled by the push plugin when possible.

We also kept in mind that we’d probably want to have the option of supporting push notifications on new platforms in the future. So services that already provided push notification support for Windows Phone 10, Ubuntu Phone or desktop notifications earned extra points.

Available Services for Sending Push Notifications

Based on these requirements, we had a closer look at alternatives to the Parse Push service. We’ve ranked the services too, with the best Parse alternatives for V-Play developers getting extra points. These were the services that made it onto our final shortlist:

Google Cloud Messaging (GCM)

Google Cloud Messaging (GCM) soon became our favourite for a feature-complete Parse substitution for V-Play developers. Google provides an abstracted push service for both iOS and Android, using Push only is free, and Google’s topics can be created from your app without any additional server-side code.

Furthermore, as Parse is already using GCM service as a foundation for sending pushes, push performance is identical to using Parse.


As we started implementing GCM, we also had another look at alternatives for the V-Play Game Network. We wanted to find a way of sending and receiving push notifications for game invites, user chats or friend requests. Based on this simple feature set, we had a look into OneSignal.

OneSignal supports a wide range of platforms, including iOS and Android and also supports a similar feature to Parse channels, called tags. You can set a collection of tags on a device and target your push notifications based on those tags. This looked promising!

OneSignal also provides server-side localization of push notifications, maintaining the different device languages in their own database and allowing you to update your push texts without releasing a new app update. You can send a localized push notification for three languages from your back end, just like this curl request demo:

curl --include \
--request POST \
--header "Content-Type: application/json" \
--header "Authorization: Basic <API-Key>" \
--data-binary '{
"app_id": "<App-ID>",
"contents": {
"en": "New friend request",
"de": "Neue Freundschaftsanfrage",
"es": "Solicitud de nuevo amigo",
"fr": "Demande d’ajout"
}' \

Depending on the device language, only the set language will be sent to the device and shown in the push.

Tags can be aggregated and it’s also possible to use different operators. So if you tag your users with a region identifier and their current user level in your RPG game, you can send a push to users who are currently checked in at middle-earth and have a level greater than 10, with a tag combination of:


{"key": "region", "relation": "=", "value": "middle-earth"},

{"key": "level", "relation": ">","value": "10"}



OneSignal service is free for all push notifications and provides a lot of features. These are covered in our documentation.


While there are many great services out there, a lot of them missed our basic requirements for app and game push notifications. Some of the services lack a free plan for transactional push notifications, although they are reasonably priced for their rich feature set, such as Batch.

Unfortunately, Batch doesn’t provide a concept like channels for transactional pushes. It’s only possible to assign a single value for identifying users across devices. They have a great feature set though so we will be keeping an eye on any developments regarding the Batch service.

Urban Airship

Urban Airship does a great job at handling marketing and campaigns. They automatically segment users based on events triggered from within your app, something it has in common with Batch.

parse_alternatives_Urban Airship
These features are quite nice for advanced use cases, but they’re not suitable as a replacement for Parse. Their initial set up for a new push service is much harder than the current method. Also transactional pushes with Urban Airship aren’t that feature-rich, as is the case with others.

Amazon SNS

Amazon SNS looked great when we first considered it. There’s a free plan, transactional push notifications and Amazon provides a similar concept to Parse’s channels, called topics. Unfortunately, it’s not possible to create new topics on-the-fly. You have to create topics from your server-side code first, making things a lot more complicated for your back end.

For example, sending pushes to all devices of a user, identified by a userId, is easy with Parse:

Parse {

channels: [ "userId" ]


When trying to do this with Amazon SNS, you first have to explicitly create this channel/topic (“userId”) from the back end. It’s not possible to create topics on-the-fly.

And there’s another restriction on Amazon SNS: You can only create up to 10.000 topics per app. While this might seem like more than enough, if you create a sports news app that sends out push notifications for a range of sports, it’s not possible for all your users to get a unique channel. Instead, you would have to manage tokens and users in your own database back end.

Note: Amazon released an even newer push notifcation service just as this article was being written. You can check out Amazon Pinpoint here.

Firebase (FCM)

Firebase was acquired by Google in 2014 but it was only this year that they started to support push notifications. It also added advertising through AdMob integration and analytics for mobile developers.

These sound like cool new features, but Google basically just added GCM as a push back end and AdMob for advertising and renamed them “Firebase”. As we currently support both features with our GCM and AdMob plugins , Firebase isn’t ranked as highly as you might expect. We are however looking into other features of Firebase and will keep you updated on this one!


Accengage offers a range of Push services for mobile developers, from CRM connections to Push Geomarketing.

You can try it for yourself with their free demo but it will cost you to use their full services. The main advantage of this service is the ability to segment users in a number of ways. You can segment your users based on a range of behaviors and target them for better engagement. The lack of a full free service is the only thing stopping it from being ranked higher.


This service is dedicated specifically to sending push notifications and is priced depending on how many active users you have. Their free tier allows you to engage with up to 100 monthly active users.

Anyone looking for advanced push notification features as standard should take a look at Catapush. They offer guaranteed delivery, delivery statistics and 2Way communication through push.


While QuickBlox isn’t an all-in-one service, it does offer separate SDKs for sending push notifications with iOS and Android. And their free plan lets you send 20 notifications per second, as long as you have less than 20,000 users.

We can’t attest for how easy it is to send these notifications or what customizable options are available. But their free plan definitely offers value for developers working within a restricted budget.


Boxcar calls itself the “Universal Push Notification Platform” and is another service worth checking out for those with a smaller  budget. It offers cross-platform support for iOS and Android and let’s free users send 200 Pushes Per Minute.

On top of that, the team at reckon they have the fastest Push notification network on the market.

Parse – Open Source

For a couple of months now, the Parse open-source server has been supporting the sending of push notifications. However, there are important features missing like sending queues, so it’s not really production-ready as of now.


Backendless offers a fully-functioning mobile-backend-as-a-service to developers. This service includes the ability to send push notifications from client or server and has cross-platform capabilities.

Perhaps the strongest feature of the Backendless MBaaS is the ability to push to iOS, Android, Windows Phone and Amazon users at the same time. Backendless offers a free license with extra features available when you need them.


If your main concern when finding a Parse alternative is avoiding downtime during migration, then Sashido is a strong choice. They offer to migrate your services with zero downtime.

Sashido also offer 24hr support. You can start your 14-free trial to see how quick migration really is and see if the service suits your needs. After that, you can use Sashido on a pay-as-you-go basis, choosing only the services you need!


Syncano offers the ability to send push notifications to Android and iOS users. This is possible from a dashboard that was designed with ease-of-use in mind. Syncano is a customizable tool with the ability to add sockets to your app.

You can get started with a 30 day free trial and continue using Syncano’s services from $25/month once it ends.


TeraData, or Appoxee as it was once known, offers their own complete tool for sending push notifications. TeraData offers a campaign builder, personalization options and a dashboard for tracking the success of push notifications to iOS and Android devices.

A demo of TeraData is available on request.


Although Kumulos is mainly aimed at app marketing agencies, it may have some use to you as a developer. It offers cross-platform push notifications for Android and iOS and user segmentation features.

Kumulos service’s begin with a free trial and can be used on a pay-as-you-go basis after that.


Not only does Carnival offer push notifications, it provides a range of rich messaging services. These allow you to customize your push notifications with images and videos. The service also includes the ability to send in-app notifications and deep-link messages that bring your user to a different part of your app.

Carnival starts with a free demo available upon request.


StreetHawk offers push notifications for Android and iOS users along with a host of other user retention and engagement solutions. With a simple integration model and the ability to send triggered notifications, it may be worth checking out. StreetHawk starts as a free trial and integrates with a number of services such as Flurry. Mixpanel and


This service offers the ability to send push notifications to up to 500,000 devices free. It has support for Android, iOS and 19 other platforms.

If you’re interested in more than sending push notifications, things can get pricey quickly with this service. Their first paid license starts at $50/month, although it’s stacked with features.


Kinvey offers enterprise-level solutions for a number of business, but you can’t forget it’s MBaas too. Along with Push Notifications, it offers data storage, location tracking and more. If you have a large project in mind, it may be worth getting in touch with Kinvey to see what kind of a deal they can do for you.

While there’s no free trial to speak of, you may be interested to sign-up and take their free tutorial to see if you’re interested in what they have to offer.

Parse Alternatives for V-Play

You can add push notifications to your V-Play App or Game in just a couple of minutes. Here’s a quick code example to show you how easy it is to add OneSignal push notifications to V-Play:

import QtQuick 2.0
import VPlayPlugins 1.0

OneSignal {
  appId: "<add-your-app-id-here>"
  onNotificationReceived: {
    console.debug("Received notification with message:", message)

For further information on how to integrate the OneSignal Plugin with your V-Play app or game, see our documentation.


To summarize, we decided to go with two plugins for now: Our new OneSignal plugin, which features an easy setup and simple, targeted push notifications. And the new Google Cloud Messaging plugin that supports advanced use cases like client-side localized push notifications and invisible background downloads, as already provided by our Parse plugin.

You can access V-Play Plugins for monetization, analytics and more with the V-Play Indie License. To test the plugins for yourself, download our Qt Plugin Demo App from the App Store and Google Play.

App Store Google Play

For the full source code of this sample app, including all V-Play Plugins, you can check out this GitHub sample.

Get Source Code!

More Posts like This

16 Great Sites Featuring Free Game Graphics for Developers

game graphics

The 13 Best Qt, QML & V-Play Tutorials and Resources for Beginners

tutorials capture

21 Tips That Will Improve Your User Acquisition Strategy

User Acquisition

7 Useful Tips That Will Improve Your App Store Optimization

User Acquisition



The post 20 Free & Secure Alternatives to the Parse Push Service appeared first on V-Play Engine.

How to Make tvOS Games & Apps with V-Play and Qt

tvOS is the smart TV operating system from Apple that let’s you play games and use apps on your Apple TV. Support for tvOS apps and games has been added to V-Play & Qt so now you can launch your cross-platform games and apps on your Apple TV too.

Get tvOS Support!

What is tvOS?

Apple based tvOS on iOS but it also includes a range of frameworks that are only supported on Apple TV. The company launched it in September 2015 alongside the 4th generation of Apple TV. The Apple TV is a device that acts as a digital media player and micro-console with a touch-screen interface.

tvOS lets you play games and use apps from your Apple TV. It offers a unique experience in comparison to a mobile device or tablet. It’s better suited than smaller devices at creating a shared experience for users. This is because the large screen allows multiple people to interact with it at the same time.

This shared experience is the focus of the tvOS user experience. You need to keep it in mind when you create your own tvOS apps and games.

Why Develop for tvOS?

There are many reasons why making tvOS apps and games make sense.

The Growing Popularity of Smart Homes

Smart devices like the Apple TV are only a small part of the Internet of Things that will become more popular in the next few years. Many companies are working on ways to make the home more intelligent. As this trend grows, Apple TVs and tvOS may become as popular in homes as the MacBook or iPad.

As it’s only been a little over a year since it’s release, tvOS is still a relatively young OS. While there’s no guarantee of success, it’s hard to see Apple letting one of Steve Job’s greatest passion projects fail.

These factors point to one thing for developers considering the tvOS marketplace. It’s an opportunity to place your apps and games on a platform with huge potential for growth.

A Lack of Competitors

It’s no secret that it’s becoming harder for apps and games to get seen on both Google Play and the App Store. It’s not just harder for your app to get discovered, cost-per-install is on the rise for most developers too.

There are other avenues available to mobile developers. But targeting a platform other than these two means entering into shrinking marketplaces. These marketplaces are already struggling for relevance and will do for years to come.

tvOS apps and games don’t have either of these problems. They exist in a small marketplace that still has the opportunity to grow.


Not having to worry so much about app store optimization and user acquisition is a bonus. It means you can invest more time in developing a great app rather than marketing. And as the marketplace grows, you’ll be in the right place to take advantage of it’s popularity

The Unique Monetisation Possibilities of tvOS

V-Play developers will know about all the mobile platforms they can launch their apps & games on. But it’s worth noting that you will also be able to port your existing apps and games to tvOS with minimal effort.

With it being so easy to bring your game or app to this new platform, you should know that it can be profitable too. Opportunities exist for both F2P and premium apps and games to make money from Apple TV users.

If your F2P game or app is doing well, it won’t hurt to get a little extra ad revenue by putting your app or game on Apple TV. The real benefit is for developers seeking to release premium apps and games.

Historically, people seem to have no problem paying to see stuff on their televisions. Whether it’s extra channels, pay per view events or apps and games. There seems to be less resistance to shelling out for something that appears on TV.


It’s also worth noting that Apple users are more likely to buy premium apps anyway. Paid apps make up 47% of the apps available for Apple TV. So some developers must have had success in this area already.

What to Know Before Getting Started

Before you get started on making your tvOS app, here are a few considerations to keep in mind.

The Big Screen Experience

Using an app or playing a game on a TV screen is a different experience than using a phone or tablet. Make sure you understand the differences before you start making your app or game. If possible, try out the Apple TV for yourself and test some games and apps to see what works best.

Remote Controls & How to Use Them

All Apple TVs come with a remote that’s used for navigation. The main feature of the remote is a touch surface that works extensively with swipe gestures. It also features  buttons for standard actions such as play/pause and volume up/down. You’ll need to consider if these navigation differences will affect the UX that your app or game provides.

Will you need to change the user interface for your app or game to accommodate the remote? It’s an important factor to consider before porting your app or game to tvOS. The purpose of the remote control is to make navigation seamless. This means you need to straighten out any hitches in your UI before you target the platform.

Keep Multiple Users in Mind

As mentioned, the Apple TV creates a shared experience; just like a traditional television set. There’s no such thing as creating a tvOS app or game for just one person. You need to be aware that there may be multiple users viewing your app or game at any time.

No Local Storage

tvOS apps have a maximum size of 200 MB and don’t make use of local storage. Instead, you need to stream app data from iCloud. Apps larger than 200MB can be packaged and loaded with On-Demand Resources. If you’re not a fan of a data-conscious approach, then tvOS apps mightn’t be for you.

tvOS Development with V-Play

You can develop apps and games for tvOS using the exact same V-Play workflow as you would for Android or iOS. You write your code in Qt Creator and deploy it from there to an Apple TV or simulator. Porting your existing games is easy too. tvOS support for V-Play uses the same API as the current SDK, so your game or app won’t change in any way when you port it to Apple TV.


V-Play is yet to support touch input but it supports a range of swipe gestures on remote control. V-Play mapped these gestures to the up/down/left/right keys of a keyboard. This makes it possible to test your game or app on desktop before deploying to Apple TV.

Nativeutils are fully implemented for tvOS. This makes it possible to show native confirmation dialogs and input dialogs in your app or game. This feature is essential for providing your users with a native UX.

V-Play added support for key events such as buttons and focus hints. This enables you to improve the UX of your app or game by making it easier for users to see which button is selected.

You can also add the Google Analytics plugin to your tvOS app or game in just a few minutes. See our documentation for more details on how to add this plugin with just a few lines of code.

tvOS Example Game – One Card!

V-Play has an example tvOS game on the App Store. V-Play released One Card! for iOS and Android but we were able to port it to tvOS with only minor additions to the source code.

The only change we needed to make was to add support for keyboard input (up, down, left, right, enter). We wanted this feature so it would be easy to test apps and games on desktop before deployment to Apple TV.

As there’s no point device available, we also added a focus hint for the currently active (selected) item, like the currently active card from the user’s stack or the selected menu item in the main menu.

Finally we added one of those shiny app icons with parallax effect, which are the essence of the Apple TV user experience All of these changes took less than a day. You can do the same with your V-Play games or apps!


One Card! uses V-Play Multiplayer, an all-in-one multiplayer component that adds the following features to your game:

You can use this open-source game example as the basis for all your multiplayer card games. You can access the free source code when you download V-Play.



You can download One Card! for tvOS here and view the source code in the V-Play SDK.

You can also play One Card! on Android and iOS devices
google_play_badge-1 itunes_download_link
Current V-Play developers can also find more info on One Card! in the V-Play documentation and the source code in the V-Play SDK here:

<Path to your V-Play SDK>/Examples/V-Play/demos/OneCard/

Get V-Play Support for tvOS Development

At the moment, tvOS development with V-Play is available to Enterprise customers only. Enterprise customers can access all V-Play Plugins and features and receive advanced support and training. Make sure to get in touch if you’d like to become an Enterprise customer and we can arrange your Enterprise evaluation today!

Get tvOS Support!

More Posts Like This!

16 Great Sites Featuring Free Game Graphics for Developers

game graphics

16 Great Websites Featuring Free Game Sounds for Developers

game sounds


21 Tips That Will Improve Your User Acquisition Strategy

User Acquisition

7 Useful Tips That Will Improve Your App Store Optimization

ASO screen capture

The post How to Make tvOS Games & Apps with V-Play and Qt appeared first on V-Play Engine.

Qt Creator 4.2 RC1 released

We are happy to announce the release of Qt Creator 4.2 RC1.

Since the release of the Beta, we’ve been busy with polishing things and fixing bugs. Just to name a few:

  • We fixed that the run button could spuriously stay disabled after parsing QMake projects.
  • Qt Creator is no longer blocked while the iOS Simulator is starting up.
  • We added preliminary support for MSVC2017 (based on its RC).

For an overview of the new features in 4.2 please head over to the Beta release blog post. See our change log for a more detailed view on what has changed.

Get Qt Creator 4.2 RC1

The opensource version is available on the Qt download page, and you find commercially licensed packages on the Qt Account Portal. Please post issues in our bug tracker. You can also find us on IRC on #qt-creator on, and on the Qt Creator mailing list.

The post Qt Creator 4.2 RC1 released appeared first on Qt Blog.

Fuzzing Qt with libFuzzer

Disclaimer: I had this blog post in the drawer for several weeks now; I just held back with publishing it to give the Qt security team time to fix the reported issues (see below under 4.).
Inspired by the great talk from Hanno Böck aboutAmerican Fuzzy Lop and Address Sanitizer at QtCon, having a try on fuzzing Qt itself seemed like an interesting thing to do. For fuzzing different parts of a library like Qt, libfuzzer is a good choice: In contrast to e.g. American Fuzzy Lop, libfuzzer runs the test cases in the same process and does not need to spawn a new process for each test, which makes it very fast.
These are the steps to set up libFuzzer and test it on Qt:
1. Compile Qt with address sanitizer and code coverage information:
To get proper output when something is wrong (e.g. "heap user after free"), Qt needs to be built with address sanitizer; in addition, libFuzzer collects information about which code paths it has visited. To enable those two settings with clang on Linux, the following patch has been applied:
diff --git a/mkspecs/linux-clang/qmake.conf b/mkspecs/linux-clang/qmake.confindex 77d913f..03d4c47 100644--- a/mkspecs/linux-clang/qmake.conf+++ b/mkspecs/linux-clang/qmake.conf@@ -11,6 +11,8 @@ include(../common/linux.conf)include(../common/gcc-base-unix.conf)include(../common/clang.conf)-QMAKE_LFLAGS += -ccc-gcc-name g++
+QMAKE_LFLAGS += -ccc-gcc-name g++ -fsanitize-coverage=edge -fsanitize=address+QMAKE_CFLAGS += -fsanitize-coverage=edge -fsanitize=address+QMAKE_CXXFLAGS += -fsanitize-coverage=edge -fsanitize=address
Even without using a fuzzer, compiling Qt and an application with address sanitizer might highlight problems within the code.
Apparently the settings above are also available for gcc; also, it might be possible to specify those changes on the command line instead of patching the mkspec file.
2. build libfuzzer:
Libfuzzer is part of llvm, and has atutorial on how to build it. The resulting libFuzzer.a needs to be linked to the executables, as explained in the steps below.
3. write test cases:
For the fuzzing test cases, there is one function to be implemented, which will be called automatically by the fuzzer. Here is an example of a simple Qt test case:
#include <QtCore>#include <QtSvg>extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {QByteArray byteArrayData(reinterpret_cast<const char *>(Data), Size);QSvgRenderer renderer(byteArrayData);return 0;}
In particular, the test programs do not need a main() function, as it is already contained in libFuzzer.a. Here is the .pro file for the test case above:
TEMPLATE = appTARGET = QSvgRendererINCLUDEPATH += .QT += svg# InputSOURCES += qsvgrenderer.cppLIBS += -L/home/peter/dev/fuzzers -lFuzzer
The full set of Qt test cases written so far can be found on github:
This repository contains tests for QImage, QJsonDocument, QtNetwork and QXmlStreamReader, among others.
4. run and report results:
The test cases can be run using all available cores via e.g. "./QSvgRenderer -jobs=4 -workers=4 testcases". Also, the github repository above contains an initial set of test cases the fuzzer can start with. For instance when fuzzing SVG images, it makes sense to start with a valid SVG file as initial input.
The tests from the repository produced some issues in Qt, which have been reported to the Qt security mailing list or the Qt bugtracker (for stack traces and information on how to reproduce see the links):
QtDbus heap use-after-free(reported to the security mailing list on 16th of October 2016)
QJsonDocument heap buffer overflow(reported to the security mailing list on 19th of October 2016)
memory leak when creating an invalid SVG filereported to the Qt bug tracker on (23rd of October 2016)
Next steps:
A good way to improve results seems to look intouser-supplied mutatorsto have more control over which input is fed into the test cases. E.g. flipping bits seems like a good default way for binary data such as images, but when it comes to JSON or XML, there might be smarter ways to produce faulty input.

Fuzzing Qt for fun and profit

Many KDAB engineers are part of the Qt Security Team. The purpose of this team is to get notified of security-related issues, and then decide the best course of action for the Qt project.

Most of the time, this implies identifying the problem, creating and submitting a patch through the usual Qt contribution process, waiting for it to be merged in all the relevant branches, and then releasing a notice to the users about the extent of the security issue. We also work together with downstreams, such as our customers, Linux distributions and so on, in order to minimize the risks for Qt users of exposing the security vulnerability.

However, that’s only part of the story. As part of the security team, we can’t simply wait for reports to fall in our laps; we also need to have a proactive approach and constantly review our code base and poke it in order to find problems. For that, we use a variety of tools: the excellent Coverity Scan service; the sanitizers available in GCC and Clang; clazy, maintained by KDAB’s engineer Sérgio Martins; and so on.

Note that all these tools help catch any sorts of bugs, not only the security-related ones. For instance, take a look at the issues found and fixed by looking at the Undefined Behavior Sanitizer’s reports, and the issues fixed by looking at Coverity Scan’s reports.

Today I want to tell you a little more about one of the tools used to test Qt’s code: the American Fuzzy Lop, or AFL to friends.


What is AFL? It’s a fuzzer: a program that keeps changing the input to a test in order to make it crash (or, in general, misbehave). This “mutation” of the input goes on forever — AFL never ends, just keeps finding more stuff, and optimizes its own searching process.

AFL gained a lot of popularity because:

  • it is very fast (it instruments your binaries);
  • it uses state-of-the-art algorithms to mutate the input in ways that maximize the effect on the target program;
  • the setup is immediate;
  • it has a very nice text-based UI.

The results speaks for themselves: AFL has found security issues in all major libraries out there. Therefore, I decided to give it a try on Qt.

The setup

Setting up AFL is straightforward: just download it from its website and run make. That’s it — this will produce a series of executables that will act as a proxy for your compiler, instrumenting the generated binaries with information that AFL will need. So, after this step, we will end up with afl-gcc, afl-g++ and so on.

You can go ahead and build an instrumented Qt. If you’ve never built Qt from source, here’s the relevant documentation. On Unix systems it’s really a matter of running configure with some options, followed by make and optionally make install. The problem at this step is making Qt use AFL’s compilers, not the system ones. This turns out to be very simple, however: just export a few environment variables, pointing them to AFL’s binaries:

export CC=/path/to/afl-gcc
export CXX=/path/to/afl-g++
./configure ...

And that’s it, this will build an instrumented Qt. (A more thorough solution would involve creating a custom mkspec for qmake; this would have the advantage of making the final testscase application also use AFL automatically. For this task, however, I felt it was not worth it.)

Creating a testcase

What you need here is to create a very simple application that takes an input file from the command line (or stdin) and uses it to stress the code paths you want to test.

Now, when looking at a big library like Qt, there are many places where Qt reads untrusted input from the user and tries to parse it: image loading, QML parsing, (binary) JSON parsing, and so on. I decided to give a shot at binary JSON parsing, feeding it with AFL’s mutated input. The testcase I built was straightforward:

#include <QtCore>

int main(int argc, char **argv)
    QCoreApplication app(argc, argv);

    QFile file(app.arguments().at(1));
    if (!
        return 1;

    QJsonDocument jd = QJsonDocument::fromBinaryData(file.readAll());

    return 0;

Together with the testcase, you will also need a few test files to bootstrap AFL’s finding process. These files should be extremely small (ideally, 1-2KB at maximum) to let the fuzzer do its magic. For this, just dump a few interesting files somewhere next to your testcase. I’ve taken random JSON documents, converted them to binary JSON and put the results in a directory.

Running the fuzzer

Once the testcase is ready, you can run it into the fuzzer like this:

afl-fuzz -m memorylimit \
         -t timeoutlimit \
         [master/slave options] \
         -i testcases/ \
         -o findings/ \
         -- ./test @@

A few explanatory remarks:

  • The testcases directory contains your reference input files, while the findings of the fuzzers will be written in findings.
  • To avoid blowing up your system, AFL sets very strict limits for execution of your test: it is allowed to allocate at most memorylimit megabytes of virtual memory and it is allowed to run for at most timeoutlimit milliseconds. You will typically want to raise the memory limit from its default (50MB) to something bigger, depending on your system and on the test.
  • One instance of afl-fuzz is single threaded; in order to maximize the search throughput on a machine with multiple cores/CPUs, you must manually launch it multiple times with the same -i and -o arguments. You should also give each instance a unique name and, if you want, elect one instance to do a deterministic search rather than a random one. This is all expressed through the master/slave options: pass to one instance the -M fuzzername option, and to all the others pass the -S fuzzername option. (All the fuzzernames must be unique).
  • Last but not least, @@ gets replaced by the name of a file generated by AFL, containing the mutated input.

For reference, I’ve launched my master like this:

afl-fuzz -m 512 -t 20 -i testcases -o findings-json -M fuzzer00 -- ./afl-qjson @@

The output is a nice colored summary of what’s going on, updated in real time:

AFL running over a testcase.

AFL running over a testcase.

Now: go do something else. This is supposed to run for days! So remember to launch it in a screen session, and maybe launch it via nice so that it runs with a lower priority.


After running for a while, the first findings started to appear: inputs that crashed the test program or made it run for too long. Once AFL sees such inputs, it will save them for later inspection; you will find them under the findings/fuzzername subdirectories:


If you’re lucky (well, I guess it depends how you look at it…), you will end up with inputs that indeed crash your testcase. Time to fix something!

You may also get false positives, in the form of crashes because the testcase runs out of memory. Remember that AFL imposes a strict memory limit on your executable, so if your testcase allocates too much memory and does not know how to recover from OOM it will crash. If you see many inputs crashing into AFL but not crashing when running normally, maybe your testcase is behaving properly, but just running out of memory, and increasing the memory limit passed to AFL will fix this.

The sig part in the name of each saved input should give you a hint, telling you which Unix signal caused the crash. In the listing above, signal number 11 is a SIGSEGV, which is indeed a problem. The signal 06 is SIGABRT (that is, an abort), which was generated due to running out of memory.

To reproduce this last case, just manually run the test over that input, and check that it doesn’t misbehave; then rerun it, but this time limiting its available memory via ulimit -v memory_available_in_kilobytes. If the testcase works normally but crashes under a stricter ulimit, it’s likely that you’re in an out-of-memory scenario. This may or may not require a fix in your code; it really depends whether it makes sense for your application/library to recover from an OOM.

Fixing upstream

After reporting the findings to the Security Team, it was a matter of a few days before a fix was produced, tested and merged into Qt. You can find the patches here and here.

Tips and tricks

If you want to play with AFL, I would recommend you to do a couple of things:

  • Set your CPU scaling governor to “performance”. This is for a couple of reasons: it makes no sense for the kernel to try to throttle down your CPUs if AFL is running; and it is actually a bad thing because it interferes with AFL measurements. AFL complains about this, so keep it happy and disable “powersave” or “ondemand” or similar governors.
  • Use a ramdisk for the tests. AFL needs to write a new input file every time it runs your application; for the JSON testcase above, AFL was achieving about 1000 executions/second/core. Each of this run needs a new test file as input; in addition to that, AFL needs to write stuff for its own bookkeeping.This will put your disk under very considerable stress, possibly even wear it out. Now, any modern filesystem will still flush data to disk only a few times every second (at most), but still, why hit the disk at all? One can simply create a ramdisk, and run AFL in there:
    $ mkdir afl
    # mount -t tmpfs -o size=1024M tmpfs afl/
    $ cd afl/
    $ afl-fuzz -i inputs -o findings ...
  • Do not let this run on a laptop or some other computer which may overheat. AFL is tremendously resource intensive and runs for days. If you want to get liquid cooling for your workstation, this is the perfect excuse.


Fuzzing is an excellent technique for testing code that needs to accept untrusted inputs. It is straightforward to set up and run, requires no modifications to the tested code, and it can find issues in a relatively short timespan. If your application feature parsers (especially of binary data), consider to keep AFL running over it for a while, as it may discover some serious problems. Happy fuzzing!

About KDAB

KDAB is a consulting company offering a wide variety of expert services in Qt, C++ and 3D/OpenGL and providing training courses in:

KDAB believes that it is critical for our business to contribute to the Qt framework and C++ thinking, to keep pushing these technologies forward to ensure they remain competitive.

The post Fuzzing Qt for fun and profit appeared first on KDAB.

SpeedCrunch 0.12 Released

Almost 3 years and 700 000 downloads later, here's the core new features of this release:
If you're curious, check out the complete list of enhancements and bug fixes. Or go straight to the downloads page. For better productivity, learn about all the user interface quirks at your disposal.

MacOS users: please note that a download is not yet available for you. If you can help us with that, please get in touch.

Don't forget to report issues or request new features in our tracker. See more ways to contribute in the Help menu on the new website. Please help us release 1.0 as quickly as possible. Have a look at what's planned already.

Massive thank you to TeyutPol WelterFelix KrullHadrien, all the translators at Transifex, and the folks over at Portable Apps (for representing a nice chunk of our user base).


KDAB and Meiller – Tipper Truck App

Design, Technical Excellence and Superb User Experience

Why does a tipper truck need an app? Meiller is the leading manufacturer of tippers in Europe. KDAB software developers and UI/UX designers worked with Meiller to create a mobile app that interacts with embedded hardware on the truck, allowing drivers to diagnose and fix problems – even when on the road. KDAB shows us how technical excellence and stunning user experience go hand in hand.

The post KDAB and Meiller – Tipper Truck App appeared first on KDAB.

Qt World Summit 2016 Webinar Series – Christmas Sessions


‘Tis the season to be jolly and as always we are just trying to be Qt /kjuːt/. We just keep on giving and giving and here is another present for you. We are hosting webinars based on the breakout sessions from The Qt World Summit 2016. So, grab a cup of cocoa and sign up for our December Tuesday webinars where you can join our R&D developers online for technical sessions that will keep your computer warm throughout 2017. The best thing of all – even if you can’t make it online – by signing up Santa will bring the recorded session to you.

Introducing Qt Visual Studio Tools

December 6th at 5 pm CET, by Maurice Kalinowski

New possibilities with Qt WebEngine

December 13th at 5 pm CET, by Allan Sandfeld Jensen

Qt Quick Scene Graph Advancements in Qt 5.8 and Beyond 

December 20th at 10 am CET (Rescheduled from November 15th), by Laszlo Agocs


Also, stay tuned for details on upcoming webinars in January!

Make sure to check our events calendar for the full list of Qt-related events delivered by us and our partners.

The post Qt World Summit 2016 Webinar Series – Christmas Sessions appeared first on Qt Blog.

Captain obvious: Sign a contract before starting to work

I have worked as a freelancer for more than a decade and was very very fortunate with the projects and partners I had. I apparently let my guards down a little bit too much and this is a reminder what to look-out for.

I have nice memories working with the Trolltech PSO team and helping with architecture, performance and low-level debugging in South Korea but when Nokia stopped investing into Qt my work on Qt and QtWebKit halted and I moved to work exclusively on GSM/3G systems. Through linkedin I got approached by a Korean business owner that spent some time working in Norway and for some companies well known to (old) Qt developers with something that looked like an opportunity to pick-up my old work. Given the common background and my work in Korea I immediately trusted this person.

I have a thing for tight deadlines and some forms of death march projects and was curious of how much the landscape changed. I thought we agreed on times and material for an exploration phase to see if the rest of the project is feasible and depending on the result move on or not, HW was sent and while there was no signed agreement I began to work. The exploration was fun but the setting was difficult and turns out there was no intention to pay for the exploration phase.

Which brings me to things I have to remember and want to share with you:

  • Don’t start to work before there is a written and signed agreement
  • If there is a tight deadline the burden on making the contract is on your customer and not you. If the contract is too long to read, reject it.
  • Don’t take the risk of unpaid exploration if you have no influence on the final project

Desktops DevRoom @ FOSDEM 2017: you are still on time to submit a talk

FOSDEM 2016 is going to be great (again!) and you still have the chance to be one of the stars.

Have you submitted your talk to the Desktops DevRoom yet?


Remember: we will only accept proposals until December 5th. After that, the Organization Team will get busy and vote and choose the talks.

Here is the full Call for Participation, in case you need to check the details on how to submit:

FOSDEM Desktops DevRoom 2017 Call for Participation

Topics include anything related to the Desktop: desktop environments, software development for desktop/cross-platform, applications, UI, etc