How to find out what an Android application is written in: technical methods of analysis

Many users and novice developers often wonder about the internal architecture of popular apps on their smartphones. Knowing what a particular app is written in can help you understand its performance, device compatibility, and even data security. Determining the technology stack is not as simple as looking at the software version in the settings, but there are a number of reliable methods for such analysis.

In this article we will look at professional approaches to reverse engineering mobile products without the need to have source code. We will look at how to distinguish native development from cross-platform solutions and how to identify the use of game engines. The knowledge gained will allow you to better understand the structure of the ecosystem Android.

Analysis of the contents of the APK file

The first and most fundamental step is to obtain the application installation package. A file with the extension .apk is essentially a regular ZIP archive containing all resources and app code. To begin the analysis, you need to extract this file from your device or download it from a trusted source. After receiving the file, change its extension to .zip and unpack the contents into a convenient directory.

Inside the unpacked folder, the key element for determining the programming language is the directory lib. This is where the compiled native libraries are stored. If you see folders with names of processor architectures, such as armeabi-v7a or arm64-v8a, and inside them there are files with the extension .so, this is a sure sign of the presence of native code. Most often, such libraries are written in languages C or C++ and are used for heavy calculations or working with graphics.

However, the presence of native libraries does not always mean that the entire application is written in them. Many apps use JNI (Java Native Interface) to link high-level code with low-level code. Therefore, the presence of a folder lib needs to be considered in conjunction with other files in the project structure. Particular attention should be paid to the file classes.dexthat contains bytecode executed by the virtual machine Dalvik or ART.

⚠️ Attention: Modifying or reassembling the APK file may violate the digital signature of the developer, which will lead to the inability to install the application or block access to online services. Use unpacked files only for analysis.

Identification of native development in Java and Kotlin

Traditional development under Android is carried out using languages Java and Kotlin. Both of these languages ​​are compiled into the same bytecode, which is placed in files .dex. Therefore, it is almost impossible to visually distinguish them inside a finished APK file without using specialized decompilers. However, there are indirect signs that allow us to make an assumption about the dominant language.

If, when analyzing the structure, you do not find heavy game engines or specific frameworks, which will be discussed below, then with a high degree of probability the application is written natively. Tools like JADX allow you to decompile classes.dex back into readable code. When opening received files, pay attention to the syntax: the presence of keywords fun, val, var indicates Kotlin, while the classic semicolon syntax is typical Java.

Often developers use a mixed approach, migrating old modules from Java to Kotlin. In this case, the project will contain constructions from both languages. For the average user, it is enough to know that both options are “native” to the platform and provide the best integration with the system. Such applications usually consume less battery resources compared to cross-platform counterparts with equal functionality.

Recognizing cross-platform frameworks

The modern mobile application market is saturated with products created using cross-platform technologies. This allows developers to write code once and run it on both Androidand iOS. It is quite easy to determine the use of such frameworks by looking at specific files and directories inside the APK.

The most popular solutions are Flutter, React Native and Xamarin. Each of them leaves unique traces in the application's file structure. For example, the presence of a library libflutter.so unambiguously indicates the use of an engine Flutter from the company Google. Such applications draw the entire interface on their own, bypassing the standard components of the operating system, which is often noticeable by the specific smoothness of the animations.

In the case of React Native, which is based on JavaScript, you will find files with the extension .bundle or a folder assetscontaining the code on JavaScript. An application Xamarinusing the language C#will contain in the folder lib many libraries with the prefix mono or xamarin. Knowing these signs allows you to instantly classify the technology for creating a app.

• 🔹 The presence of a file libflutter.so indicates the Flutter framework (Dart language).
• 🔹 Files .bundle and an abundance of JavaScript code are typical for React Native.
• 🔹 Libraries libmonodroid.so indicate the use of Xamarin (.NET/C#).
• 🔹 The absence of specific engines and pure DEX code indicate native development.

Identification of game engines in applications

Mobile Games make up a significant portion of the content in app stores, and almost all of them are created using specialized engines. Unlike utilities, games require high graphics and physics performance, which is achieved through the use of platforms such as Unity, Unreal Engine or Cocos2d-x.

The most popular engine is Unity. Its presence in the APK file indicates the presence of the folder assets/bin/Data, as well as specific configuration files and resources. Inside the folder lib you will find libraries with names containing unity. Games on this engine often have a characteristic cache size and structure, which can be downloaded after the first installation.

Heavier artillery in the form Unreal Engine is used for projects with console-quality graphics. Such applications take up significantly more space and contain files with the extension .pak in the directory assets. Another characteristic feature is the presence of libraries libUE4.so or libUE5.so depending on the version of the engine. These games require powerful hardware and often do not run on budget devices.

Typical structure of a Unity game:
/assets/bin/Data/
/assets/bin/Data/globalgamemanagers
/assets/bin/Data/resources.assets
/lib/armeabi-v7a/libunity.so

⚠️ Attention: Game engines often use their own anti-modification system. An attempt to open or change game files may result in anti-cheat or account blocking in online mode.

Using decompilation tools

Manual analysis of files can be labor-intensive, so experts use automated tools to deeply study applications. One of the most powerful and accessible solutions is the utility JADX. It allows you to open an APK file and see the project structure in a form close to the source code, with syntax highlighting and class navigation.

When uploading a file to JADX pay attention to the resource tree. If you see a lot of files with names consisting of hashes or strange characters, this may indicate code obfuscation, an obfuscation procedure used to protect against hacking. However, even obfuscated code often reveals its affiliation with a specific framework through package names (for example, io.flutter or com.facebook.react).

Another useful tool is APKToolwhich allows you not only to view, but also to decode application resources into a readable format. XML. This It is especially useful for analyzing a file AndroidManifest.xmlwhere all permissions and components are specified. In the manifest you can often find references to specific activities or services belonging to certain SDKs or advertising networks.

What is code obfuscation?

Obfuscation is the process of deliberately complicating the source code of a app without changing its functionality. is done to protect intellectual property and make it more difficult for hackers trying to find vulnerabilities or crack a license.

Table of characteristics of popular technologies

For quick orientation in the variety of technical solutions, we have compiled a summary table. It will help you quickly compare the artifacts found in the APK file with a specific development technology.

Technology	Key file or folder	Programming language	Application type
Native (Android)	classes.dex, no engines	Java / Kotlin	Utilities, Social Networks
Flutter	libflutter.so, libapp.so	Dart	Interface applications
Unity	assets/bin/Data, libunity.so	C#	Games (mobile)
React Native	index.android.bundle	JavaScript	Hybrid applications
Unreal Engine	assets/*.pak, libUE4.so	C++	Heavy 3D games

Remember that modern applications are often a “hybrid of hybrids”. For example, the main menu can be written in Kotlin, game mechanics are implemented in Unity, and analytics are connected via SDK in Java. Therefore, when analyzing, it is worth looking for the dominant technology that determines the bulk of the code and resources.

Frequently asked questions about Android technologies

Is it possible to accurately determine the version of the Java or Kotlin language?

Without access to the source code with comments, this is extremely difficult to do. The bytecode .dex is unified, and the compiler removes most of the metadata about the language version. One can only guess the version based on the use of certain APIs that appeared in specific versions of the standard, but this requires deep knowledge of the specifics of compilers.

Does the development language affect the speed of the application?

Yes, it does. Native applications on Kotlin or Java usually work faster and smoother, since they directly interact with the system API. Cross-platform solutions add a layer of abstraction, which can lead to micro-latencies, although modern engines like Flutter have reduced this difference to a minimum by compiling into native code.

Why does the average user need to know what the application is written in?

This information is useful when choosing a device. If you are the owner of a weak smartphone, you should avoid heavy games on Unreal Engine or applications with poor optimization on React Native. Also, knowing the stack helps you understand why an application takes up so much space or requires specific permissions.

Is it safe to download APK files for analysis?

Downloading files from third-party resources always carries a risk. For analysis, use only official application stores or verified repositories like APKMirror. Never install files whose origin is in doubt on your main device, even if your goal is simply to look inside the archive.

⚠️ Attention: The interfaces of analysis tools and the structure of APK files may change slightly with the release of new versions of the Android SDK. Always check the official documentation of tool developers if standard methods do not produce results.