What Android is written on: from the core to the interface - a complete analysis of technologies

Android is the most popular mobile operating system in the world, but few people think about what technologies are behind its operation. If you've ever wondered what programming language is Android written inthe answer is not clear cut. This is a complex multi-level system, where each layer uses its own tools: from low-level C/C++ in the kernel to Kotlin and Java in the user interface.

In this article we will go into detail Let's look at:

• 🔹 Android architecture and the role of each layer (from the Linux kernel to applications).
• 🔹 Main programming languagesused in the system, and their purpose.
• 🔹 How code is compiled Android applications and why it is important for performance.
• 🔹 Evolution of technologies: from Java to Kotlin and new trends (Jetpack Compose, Rust).

If you developer, enthusiast or just a curious user - here you will find answers to questions that are rarely covered in standard guides.

1. Android architecture: layers and their purpose

Android is built on Multi-layer architecture, where each layer is responsible for certain tasks. This allows the system to remain flexible, secure and productive. Let's look at the key layers from top to bottom:

Interesting fact: Android uses a modified Linux kernel, but is not a Linux distribution in the usual sense.. Google has replaced many standard components (for example, glibc to Bionicto optimize for mobile devices.

Why is this important? For example, when you see an error "kernel panic" on your smartphone screen, the problem lies precisely in this layer - the Linux kernel. And if the application crashes with a message "ANR" (Application Not Responding), the layer Android Runtime or the application code itself is to blame.

2. Android kernel: why Linux and how it is modified

The basis of Android is Linux kernel, written mainly in C interspersed with assembler for critical areas. Google chose Linux for several reasons:

• 🐧 Open source (GPLv2 license), which allowed it to be modified for mobile devices.
• 🛡️ Reliability and security: Linux has been used in servers and embedded systems for decades.
• 🔧 Support for multiple architectures (ARM, x86, RISC-V), which is critical for smartphones.

However, “pure” Linux was not suitable for mobile devices. Google has made hundreds of changes:

• 🔋 Low Memory Killer (LMK): Aggressive memory management to prevent lag.
• 📡 Wake Locks: A mechanism to allow apps to "wake up" the device (for example, for push notifications).
• 🔒 SELinux: Mandatory access control.
• 🎮 Binder IPC: Replacement standard interprocess communication (IPC) in Linux to a faster mechanism.

⚠️ Attention: If you are installing a custom kernel (for example, to overclock the processor), make sure that it supports SELinux in Enforcingmode. Disabling SELinux for the sake of “performance” will leave your device vulnerable to attacks.

An interesting point: in 2022, Google began experimenting with replacing parts of the kernel with Rust a language that guarantees memory safety. This should reduce the number of buffer overflow vulnerabilities. So far, Rust is only used in new modules (for example, in drivers for Pixel 6), but the trend is obvious.

3. Android Runtime (ART): how application code is executed

Before version Android 5.0 Lollipop (2014), applications were executed using Dalvik Virtual Machine (DVM). It was a virtual machine, similar to the JVM, but optimized for mobile devices. However, DVM had a serious drawback: it used bytecode interpretationwhich slowed down the launch of applications.

With the advent ART (Android Runtime) everything changed. Now application code compiled in advance (AOT - Ahead-of-Time) into native machine code during installation. This gives:

• ⚡ Fast startup applications (no need to compile code on the fly).
• 🔋 Less power consumption (the processor spends less resources on execution).
• 🛡️ Greater security (the code is checked at the compilation stage).

How does this work in practice? When you install an APK file, the system:

1. Extracts .dexfiles (Dalvik Executable) from the APK.
2. Converts them to .oatfiles (Optimized ART) using compiler dex2oat.
3. Saves the compiled code in the cache (/data/dalvik-cache).

⚠️ Attention: If you manually delete files from /data/dalvik-cache (for example, through root access), applications will begin to recompile the next time you launch them. This may cause lags and increased battery consumption until the cache is restored.

It is interesting that ART supports also JIT compilation (Just-In-Time) for dynamic optimization of code at runtime. This is used, for example, for "hot" replacement of methods in debug mode (Android Studio Profiler).

4. Programming languages in Android: what is used where

Android is not a monolith written in one language. Different parts of the system use different technologies. Here are the key languages and their role:

🔹 C and C++: the basis of productivity

Most of them low level code Android is written in C low-level code C++:

• 🖥️ Linux kernel and device drivers.
• 🎮 Graphics libraries: OpenGL ES, Vulkan, Skia (for UI rendering).
• 🔊 Audio stack: AudioFlinger, OpenSL ES.
• 📱 Android Runtime (ART) and virtual machine.

🔹 Java and Kotlin: application development

Since the creation of Android (2008), the main language for applications was Java. However, in 2017, Google announced Kotlin preferred language for development. Why?

• 📝 Concise syntax: Kotlin requires 40% less code for the same tasks.
• 🛡️ Null Safety: protection from NullPointerException at the language level.
• 🔄 100% compatibility with Java: you can gradually migrate old projects.

Example code in Kotlin vs Java:

// Java
Button button = findViewById(R.id.my_button);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Toast.makeText(MainActivity.this, "Clicked!", Toast.LENGTH_SHORT).show();
}
});

// Kotlin
myButton.setOnClickListener {
Toast.makeText(this, "Clicked!", Toast.LENGTH_SHORT).show()
}

🔹 Other languages in the Android ecosystem

• 🦀 Rust: Used in new parts of the kernel and for critical components (for example, in Android 12 for processing media codecs).
• 🎯 Dart: language for Flutter a framework from Google for cross-platform development.
• 🐍 Python: sometimes used for automation scripts (for example, in Android Things for IoT).

5. How an Android application is compiled: from code to APK

The process of building an Android application is a complex puzzle that involves several compilers and tools. Let's look at the main stages:

1. Compilation of source code:
   • 📝 Kotlin/Java → bytecode (.class-files).
   • 🔧 C/C++ → native libraries (.so-files).

Important nuance: since Android 8.0 Oreo Google has introduced mandatory verification 64-bit support for applications on Google Play. This means that if your application contains native libraries (.so), they must be compiled for arm64-v8a, x86_64 other 64-bit architectures.

⚠️ Attention: If you are developing an application with native code (C/C++), make sure that build.gradle all necessary ABIs (Application Binary Interface) are specified, otherwise your application will not work on some devices or will take up extra memory due to the inclusion of unnecessary libraries.

Are they used? 64-bit libraries (if there is native code)?

Is the APK signed with a release key (not debug)?

Tested on devices with different versions of Android?

Is the APK size optimized (is unnecessary code removed)?

-->

6. Evolution of technologies: from Java to Jetpack Compose

Android has not stood still. Over the past 15 years, the platform has undergone a lot of changes, and programming languages are no exception. Here are the key milestones:

One of the most noticeable trends in recent years is Jetpack ComposeThis is a modern framework for creating interfaces that replaces. outdated XML + View. Code example on Compose:

@Composable
fun Greeting(name: String) {
Text(text = "Hello, $name!", modifier = Modifier.padding(24.dp))
}

Advantages of Compose:

• 🎨 Declarative syntax: you describe what what should be on the screen, and not how it should be drawn.
• 🔄 Reactivity: automatic update of the UI when data changes.
• 📱 Cross-platform: the same code works on Android, iOS and desktop (via Compose Multiplatform).

However, Compose also has disadvantages: it requires Android 5.0+ and can increase the size of the APK due to additional libraries. However, Google is actively promoting it as the future of Android development.

7. Myths and misconceptions about languages in Android

There are many myths floating around Android technologies. Let's look at the most common ones:

🔹 "Android is entirely written in Java"

This is not true. Java/Kotlin are used only for the top level (applications and framework). drivers and critical components are written in C/C++, and in new versions it appears Rust.

🔹 "Kotlin is slower than Java"

In practice, the differences in performance between Kotlin and Java no. Both languages are compiled into the same bytecode and then into native code via ART. Kotlin may even be faster due to its more concise syntax, which makes it easier for the compiler to optimize.

🔹 "Native code (C++) is always faster. JavaScript data-i="248">🔹 "Android is just Linux with a shell"

That's right not always. For computationally intensive tasks (for example, video processing or 3D graphics), C++ is indeed preferable. But for typical UI tasks the difference is minimal, and development in Java/Kotlin is easier and safer.

🔹 "Android is just Linux with a shell"

Although Android uses the Linux kernel, is not a regular Linux distributionAndroid:

• 🚫 There is no standard shell (bash, zsh).
• 🚫 There is no support for many Linux utilities (grep, sed etc.).
• 🚫 Own libraries are used (Bionic instead glibc).

Therefore, porting Linux applications to Android "out of the box" will not work - you need adapt them to a specific environment.

FAQ: Frequently asked questions about languages in Android

source build/envsetup.sh
brunch [device_codename]