Three Common Pitfalls in Mobile Game Performance

App performance is now every mobile team’s concern. This is no exception in the gaming industry.

Game studios should get behind validating performance early and testing often. If all stakeholders support the vision of having high-performing games, it’ll be easier to devise a plan and stick to it. It’s also important for everyone to be aware of the causes of bad performance so that issues can be detected and remedied sooner.

Here are some common pitfalls we’ve seen in mobile game performance, plus some tips on how to improve it.

1- Low-End Devices & Fragmentation

Device fragmentation is the main cause of several issues that affect mobile users. Most game studios (especially in the Android world) are aware of it. A common mistake is to ignore the reality that a huge diversity of hardware and OS versions makes mobile game development difficult.

Mobile games heavily use a device’s resources. It’s often not possible to provide the same experience in both high and low-end devices, so a good strategy is needed. Consider the following tips: 

• Design your game based on the built-in Quality settings for each platform. You can choose specific settings for rendering & shadows for each quality level.
• Disable heavy animations on low-end devices.
• Create and handle different assets based on the device quality in your distributions and services.
• Run your early tests of new features in low-end devices first.

2 – RAM Consumption

Some of the best games in the app store support a wide range of devices. Imagine you have a game that needs to perform decently on a device that only has 1 GB of RAM. This means that your app will need to have a very small memory footprint. Consider the following to keep your memory footprint small: 

• Launch automated tests over a representative set of devices. For example, low-end devices (1 GB or less), mid-range devices (2 GB), and high-end devices (more than 2 GB).
• Load the smallest assets to the memory.
• Sacrifice loading performance by freeing memory space (objects and resources) that will be used in the short term for low-end devices.
• Build support for large-heap in older Android versions.

3 – FPS & Motion Stutter

FPS is the most measured indicator in games that tells us how fast the game can draw images to the screen. Usually, this indicator is monitored permanently by the Dev team to detect bad experiences (it even deserves its own blog post).

Unfortunately, drawing animations fast is not the only thing needed. Games also need to provide a smooth flow. A game can draw at 60 FPS but still lose frames causing what is known as “motion stutter.”

A typical example of this issue in Unity is when an object’s transformations are called on different events, like Update and FixedUpdate (check out this excellent example).

From a QA perspective, teams measure rendering performance using two different indicators: FPS & Janks. From a developer perspective, doing this properly consists of understanding each event stage of the underlying framework that you’re using.

Take a look at the following content:

• https://www.youtube.com/watch?v=qtV8JEIq0Ng
• https://www.kinematicsoup.com/news/2016/8/9/rrypp5tkubynjwxhxjzd42s3o034o8
• https://www.unity3dtips.com/unity-fix-movement-stutter/

In Summary

Mobile game performance directly affects user engagement, ratings, number of downloads, conversions, and, ultimately, revenue.

If you commit to creating a high-quality game that meets or exceeds user performance expectations, your users will want to use it over and over again, elevating their perception of your studio and strengthening the relationship they have with you.