Over the past decade, several cross-platform technologies have emerged in the field of mobile development, including Cordova in 2009, React Native in 2015, Flutter in 2017, and KMM (Kotlin Multiplatform for Mobile) in 2020. In this article, I will examine the market share that these cross-platform technologies hold as of 2023.
The article is organized into three main sections:
For the scope of this study, I selected the top 100 featured applications on the Play Store as a sample. The list was retrieved from France on July 30, 2023, and may have since been updated. Opting for the Play Store's featured applications (rather than selecting 100 applications randomly or based on personal choices) offers the following advantages:
Out of the 100 featured applications, only 93 were retained for study, the remaining seven were excluded because their underlying frameworks could not be identified using the method explained below.
It's worth noting that 23 of the 93 retained applications are games. The categorization as a 'game' was based solely on the Play Store's classification to ensure minimal bias.
Again, this is the technical section of the article, feel free to skip this section if you're solely interested in the findings.
The initial step in identifying the technology behind an application involves downloading its APK (Android Package Kit) file. There are multiple methods to acquire an application's APK, each with its own pros and cons:
The ++code>classes.dex++/code> files
Once the APK is acquired, the focus shifts to the ++code>classes*.dex++/code> files contained within it. These files store the Java bytecode for the application (more specifically, it’s the Dalvik bytecode format) and therefore contains all the class definitions used in the application. To extract these files, simply execute the following command: ++code>yes | unzip -qq base.apk 'classes*.dex' -d unzipped_apk++/code>. The ++code>yes++/code> command is included to automatically confirm any prompts. An APK is just a compressed archive, making this extraction straightforward.
Analyzing DEX Files
In order to disassemble the bytecode stored in the ++code>classes.dex++/code> files, the ++code>dexdump++/code> tool should be used to display the information in a human-readable way. The ++code>dexdump++/code> tool is typically located in the ++code>~/path/to/android/sdk/build-tools/sdk_version/dexdump directory++/code>. The figure below shows an extract of the result of the ++code>dexdump++/code> command on a ++code>classes.dex++/code> files (the complete output is a lot longer) :
Identifying the Framework
As can be seen through the figure above, the ++code>dexdump++/code> returns the definitions of all classes used in an application, including their name : In the example above, we can see that the application uses the ++code>com/facebook/react/bridge/InvalidIteratorException++/code> which is a class used by the React Native framework.
Therefore, To determine the framework an application is built with, it is possible to scan through the classes to find any attached to a specific framework. Below is the table that was used in this article to associate the beginnings of class names with corresponding frameworks that:
It's important to note that KMM is absent from this list. KMM generates purely native applications, particularly for Android, since it relies solely on native elements. As a result, it's impossible to detect KMM-based applications using the method outlined in this article.
To sum up, this is the shell script I used to conduct this study. It accepts an APK file as an argument and returns the framework used by the application would look like this:
Out of the 100 applications, the execution of this command revealed that 7 applications had more than two frameworks. These 7 applications were consequently discarded in this study.
As previously mentioned, out of the initial 100 selected applications, only 93 were included in our analysis mainly because the development technology for seven of the apps could not be identified. The graph below provides a visual representation of the technology distribution:
Noticeably, the “Other / No framework” category dominates. This represents the number of applications for which no specific framework was detected. For the purpose of this article, we'll treat these applications as native, a fair assumption since none of the popular frameworks was detected.
The graph also highlights Unity's strong foothold in mobile app development. This is due to Unity being the number one choice when it comes to building 3D games filled with rich visuals.
Let’s zoom in on non-gaming apps. The next graph illustrates the distribution of technologies among the 70 remaining apps:
As expected, excluding games dramatically reduces Unity's presence to a mere two applications. Even though React Native and Flutter are relatively newcomers in the cross-platform scene, they already account for 18.5% of the applications, outperforming some older platforms like Cordova. Yet, native development still holds its ground, representing 71% (50 out of 70) of the analyzed apps
As a React Native developer, I was interested in the footprint of React Native in this sample. In our study, React Native's presence was 10% (7 out of 70 applications). However, when juxtaposed with data from the U.S. shared by Evan Bacon on Twitter, the findings diverge:
It appears therefore that the adoption of React Native in the US is more accelerated than in France, at least based on the of application used in this article.
Even though native development is still undeniably dominant, there's a clear shift towards cross-platform solutions. Since entering the market, React Native and Flutter have evolved immensely, proving their worth in powering industry giants such as Instagram (React Native, with over 5 billion downloads) and Alibaba (Flutter, with more than 100 million downloads).
In fact, adopting these two technologies offers several advantages:
If you've reached this point in the article and are still hesitating about migrating to cross-platform, consider our dedicated offer. Transition from a native application to a cross-platform framework can be smooth, allowing you to consistently release new features throughout the migration period.
Thank you for reading. I hope you found this article interesting, and I look forward to sharing more with you in our 2024 edition!