The world of mobile technology revolves around the operating system, which has become synonymous with freedom of choice and variety of devices. When you pick up a smartphone, tablet, or even a smartwatch, you're likely interacting with a product built on open source code. This foundation is called Android Open Source Project, or abbreviated AOSP. This is not just a set of app files, but a global initiative managed by Google that allows manufacturers, developers and enthusiasts to create their own versions of Android.
Many users confuse the operating system itself with the services that we see on the screens of our gadgets every day. Understanding the difference between pure AOSP and commercial distributions like One UI or MIUI is critical to diving deep into the topic of customization and security. In this article, we will take a detailed look at the project's architecture, its licensing, and exactly how open source affects your daily life.
It is necessary to immediately clarify that open source code does not mean complete anarchy. There is a strict management hierarchy, code review processes, and certain compatibility rules that all participants in the ecosystem must adhere to. Without these mechanisms, we would have hundreds of systems that are incompatible with each other, which would make application development impossible.
The essence and architecture of the AOSP project
The basis of everything is the concept of openness, which allows any developer to download the source code, study it and modify it to suit their needs. Android Open Source Project provides full access to the system kernel, drivers, libraries and frameworks. This creates a unique environment where innovation can come not only from Google, but also from independent communities or large vendors.
The system architecture is built on the principle of multi-layers. At the lowest level is the Linux kernel, which is responsible for managing memory, processes, and hardware drivers. This is where the interaction between hardware and software occurs. Above is a layer of hardware abstractions (HAL), which allows the upper levels of the system to work with various components (camera, Bluetooth, GPS) regardless of the specific chip manufacturer.
The key element is the runtime environment Android Runtime (ART), which replaced the outdated one Dalvik. It is responsible for running applications written in Java or Kotlin. Thanks to JIT compilation (Just-In-Time) and Ahead-Of-Time compilation, the system provides high performance even on devices with modest characteristics. It is important to note that ART is an integral part of an open source project.
⚠️ Warning: Downloading the AOSP source code requires significant resources. For a complete system build, we recommend a computer with at least 16 GB of RAM and more than 250 GB of free space on a fast SSD drive.
The top level is occupied by system applications and the user interface. In its pure form AOSP contains only a basic set of apps: phone, messages, browser, contacts. There is no Google Play store, maps or voice assistant. These components are proprietary and are added separately by manufacturers upon receipt of a license.
To study the source code, it is not necessary to download the entire repository. Use the Android Source online code browser to quickly find classes and methods of interest without installing gigabytes of data.
Licensing and legal aspects of use
The legal basis of the project is built primarily on a license Apache License 2.0. This is one of the most liberal licenses in the open source software world. It allows you to use the code for commercial purposes, modify it and distribute modified versions without the obligation to open your own work.
However, there are important nuances. Some system components, especially those related to multimedia codecs or specific drivers, may be licensed under the GNU General Public License. This imposes stricter obligations: if you change GPL code, you must make those changes publicly available. Device manufacturers must carefully monitor compliance with these requirements. GPL (GNU General Public License). This imposes stricter obligations: if you change GPL code, you must make those changes publicly available. Device manufacturers must carefully ensure compliance with these requirements.
The compatibility app deserves special attention. Android Compatibility app. In order for a device to be officially called "Android" and gain access to Google services, it must pass testing CTS (Compatibility Test Suite). This ensures that apps from the store will work correctly on the device. Without passing these tests, the phone remains just a Linux-based device with an Android interface.
| Component | License | Obligations |
|---|---|---|
| Linux kernel | GPL v2 | Mandatory to publish kernel changes |
| Android framework | Apache 2.0 | You can close your modifications |
| Device drivers | Various (often proprietary) | Depends on the chipset vendor |
| Bionic Libraries | BSD / Apache 2.0 | Minimum restrictions |
The use of the "Android" trademark is strictly regulated. You can't call your operating system "Android" unless it's certified by Google. That is why many custom firmwares use names like “LineageOS” or “PixelExperience”, avoiding direct mention of the brand in the product name, although they are based on its code.
Differences between AOSP and commercial Android with Google services
The main misconception of users is that they consider Android and Google services to be one whole. In fact, these are two different layers. AOSP —this is the base, the “skeleton” of the system. Google services (GMS — Google Mobile Services) are the “muscles and organs” that add functionality. Smartphones sold in China often run purely AOSP without a single Google application, replacing them with local analogues.
The composition GMS includes critical components: application store Google Play Store, geolocation services, push notifications (FCM), as well as a set of popular applications (Gmail, YouTube, Maps). These services require a special license from Google, which is obtained from device manufacturers. This creates a situation where technically a device may be powerful and modern, but without a license it lacks the comfort the user is accustomed to.
Differences also appear in security updates. Google releases monthly patches for AOSP, but their implementation on devices depends on the manufacturer and telecom operator. While pure code is updated quickly, vendor firmware can delay these updates for months due to the need to adapt to their hardware and proprietary shell.
⚠️ Warning: Devices without certified Google services may experience problems with banking applications and some games that use license verification or geolocation API.
In terms of privacy, clean AOSP collects significantly less telemetry data by default than a system with integrated Google services. For privacy-conscious users, using de-Googled assemblies based on an open source project is the preferred choice, although it requires some configuration skills.
Why did Huawei switch to HarmonyOS?
After the imposition of sanctions, Huawei lost access to GMS licensing. This has forced them to accelerate the development of their own ecosystem, although their devices can still run Android applications through low-level AOSP compatibility.
The role of the community and custom ROMs
One of the main advantages of open source code is the ability to create custom ROMs. Enthusiasts from all over the world unite in projects like LineageOS, Pixel Experience or crDroid. These teams take the basis AOSP, add their own functions, optimize performance and extend the life of devices that have already ceased official support.
The process of creating your own firmware begins with synchronizing repositories through the tool repo. Developers download thousands of gigabytes of code, then customize the build for a specific device, adding drivers (often in the form of binary "blobs" from the manufacturer) and a kernel. This is a complex engineering process that requires deep knowledge in compiling and debugging Linux systems.
- 🚀 Performance: Custom firmware often removes system "garbage" (bloatware), which frees up RAM and speeds up the interface.
- 🔒 Security: Projects like GrapheneOS focus on enhanced data protection, disabling unnecessary network modules and improving the application sandbox.
- 🎨 Customization: Users get access to fine-tuning the appearance, animations and behavior of the system, not available in stock versions.
- 🔄 Relevance: The ability to install the latest version of Android on a smartphone released 5-6 years ago, for which the manufacturer no longer releases updates.
However, installing third-party software carries risks. Incorrect firmware can turn the device into a brick. In addition, some functions that depend on the hardware implementation (for example, the quality of photo processing with proprietary algorithms) may degrade on custom builds, since enthusiasts do not have access to the camera manufacturer’s proprietary ISP algorithms.
Custom firmware is the best way to give a second life to an old device, but they require unlocking the bootloader, which can void the warranty and disrupt banking applications (SafetyNet/Play Integrity).
The process of developing and releasing updates
The life cycle of Android versions begins in the bowels of Google. The company's engineers are developing new features, improving the API and optimizing the core. This entire process takes place publicly on special branches of the repository. First, the code enters the development branch, where it undergoes initial testing.
Each major release is accompanied by the release of Developer Preview and Betaversions. At this stage, the code is available to application developers so that they can adapt their products to new system capabilities. Regular users can also install the beta on compatible devices (mainly the Pixel line), but the stability of such a system is not guaranteed.
repo init -u https://android.googlesource.com/platform/manifest -b android-14.0.0_r1repo sync -c -j8
source build/envsetup.sh
lunch aosp_arm64-userdebug
m
After beta testing is completed, the code is frozen and becomes the basis for the next stable release. AOSP. At this point, the code is posted to the main repository. Device manufacturers (Samsung, Xiaomi, OPPO and others) take this code, integrate their drivers, apply a proprietary shell and begin internal testing.
There is a fragmentation problem. Due to the difficulty of adapting to thousands of different hardware configurations, new versions of Android reach end users with a long delay. Google is trying to combat this through a project Project Treblethat separated the vendor implementation from the Android framework, simplifying the update process.
☑️ Preparing to build AOSP
Future of the project and impact on the market
The Android ecosystem continues to evolve, and AOSP remains its heart. In recent years, there has been a trend toward system modularity. The project Project Mainline allows you to update key system components (media library, security, network) directly through Google Play, bypassing device manufacturers. This reduces the dependence of users on vendor policies regarding updates.
The influence of alternative operating systems based on Linux, but not Android in the classical sense, is also growing. However, compatibility with Android apps remains critical. Even new platforms, such as HarmonyOS from Huawei or various IoT systems, often use libraries AOSP to run APK files, which confirms the dominance of this standard.
⚠️ Attention: Interfaces and menu names in the settings for developers may differ depending on the version of Android and the manufacturer's shell. Always check the latest documentation before changing system settings.
Open source's influence extends beyond smartphones. Televisions, car systems, smart watches and even some ATMs run on modified versions of this project. The flexibility of the architecture allows it to be adapted to screens of any size and the computing power of any processor. Android TV, automotive systems Android Auto, smartwatches and even some ATMs run modified versions of this project. The flexibility of the architecture allows it to be adapted to any screen size and the computing power of any processor.
For developers, understanding the structure AOSP opens the door to creating system applications, working with low-level APIs and deep software optimization. This is not just a tool for building firmware, but a huge source of knowledge about how modern mobile operating systems work.
Frequently asked questions (FAQ)
Is it possible to install pure AOSP on any smartphone?
Theoretically yes, but in practice this is only possible for devices with an unlocked bootloader and availability of ready-made drivers. For most popular models, there are ready-made assemblies from the community (for example, LineageOS), but for rare devices the assembly will require writing drivers from scratch.
What is the difference between root access and access to the source code?
root access give the user full control over the already installed system on the device. Access to the source code AOSP allows you to change the system itself before installing it, rebuild the kernel, remove system applications or change the logic of the framework.
Is it safe to use phones without Google services?
Yes, it is safe from the point of view of viruses, since the openness of the code allows independent experts to check it on vulnerabilities. However, the user will have to look for alternative application stores (F-Droid, Aurora Store) and ways to install popular apps, since Google Play will not be available.
Why does Google make Android code publicly available?
This is a strategic move to maintain market dominance. Openness attracts manufacturers who receive a free OS and developers who create applications. In return, Google receives data on the use of services and the opportunity to promote its standards in the industry.
How can I find out which version of AOSP is used in my phone?
The exact build version can be found in the menu Settings → About phone → Software information. However, manufacturers often do not explicitly list the AOSP security patch number. For detailed information, you can use applications like Device Info HW or commands via ADB.