Updated November 2026
Android apps behave differently on x86 emulators because native code is compiled for one CPU architecture at a time. Kotlin and Java run on ART and don’t care. Native .so libraries do. An x86 emulator runs either the app’s x86 libraries, which ARM phones never use, or ARM libraries translated to x86 inside the app’s process. Testing on ARM hardware, physical or cloud-hosted, closes both gaps.
What are Android ABIs?
An ABI (application binary interface) is the contract between compiled code and the CPU and system it runs on. Android’s NDK docs describe one ABI per combination of CPU and instruction set. It covers the instruction set, calling conventions, the binary format (always ELF on Android) and endianness (always little-endian).
The NDK supports four ABIs today:
armeabi-v7a: 32-bit ARM, with Thumb-2 and Neonarm64-v8a: 64-bit ARM (AArch64)x86: 32-bit Intel and AMDx86_64: 64-bit Intel and AMD
Older ABIs like armeabi and MIPS were removed in NDK r17.
Every device reports which ABIs it can run, primary first:
bash
adb shell getprop ro.product.cpu.abilist
The primary ABI matches the machine code of the system image itself. Any others listed are secondary ABIs the image also supports. That one line tells you more about a test device than its model name.
On the app side, native libraries live inside the APK at lib/<abi>/lib<name>.so. A “fat” APK carries a folder for each ABI it supports. Since an APK is a zip file, you can check this in seconds:
bash
unzip -l app.apk 'lib/*'
At install time, the package manager looks for libraries under the device’s primary ABI first. If it finds none, it tries the secondary ABIs. It copies the best match into the app’s native library directory and ignores the rest.
That detail drives most of what follows.
What happens when an ARM-only app runs on an x86 emulator?
It depends on the system image. On an image without ARM translation, an ARM-only app usually won’t install. On an image with translation, it installs and runs, with the ARM code translated to x86 inside the app’s process.
Here’s the background. In March 2020, Google announced Android 11 emulator system images for x86 that can run ARM binaries. Before that, you had two options for ARM-only apps on an x86 computer. You could use a full ARM emulation image, which Google describes as much slower, or test on a physical device.
How the translation works, per that Android Developers Blog post:
- The whole system runs as x86, with normal hardware virtualization.
- When an app’s process needs an ARM binary, only that binary is translated to x86, inside that process.
- Everything else in the process, including ART and graphics libraries like libGLES and libvulkan, keeps running natively as x86.
- The translator skips low-level, hardware-specific libraries to avoid a performance hit.
Two conditions matter for teams. The translation ships only on Google APIs and Play Store system images. It’s also licensed for development and debugging on your own machines, on-premises servers and cloud environments you procure yourself, not for commercial hosted services.
Without translation, the package manager finds no library folder matching any ABI on the image. You’ll usually see INSTALL_FAILED_NO_MATCHING_ABIS and “Failed to extract native libraries” in the install output.
What if the APK also ships x86 libraries?
Then translation never happens, and that’s the trap worth knowing about. The emulator’s primary ABI is x86 or x86_64, so the package manager picks the x86 libraries first. Your test passes on code no ARM phone will ever run.
Usually that’s fine. The x86 and ARM builds come from the same source. But compiler flags, intrinsics, hand-written assembly and third-party SDKs can differ per ABI. A bug that lives only in the ARM build won’t show up on the emulator.
You can push the emulator toward the ARM build on a translation-capable image. Android’s docs describe forcing an ABI at install time on devices that support more than one:
bash
adb install --abi arm64-v8a app.apk
Now you’re testing the ARM library through the translator. That’s closer to what users run, but still not the same as ARM silicon.
On ARM hosts, the picture changes again. Google’s Apple silicon emulator preview ran ARM64 system images through ARM64 hardware virtualization, with no translation involved. Your library then runs as ARM code, but on a laptop CPU inside an emulator, not on a phone’s chipset and vendor build.
What did the test show?
[WRITER: one sentence on the setup. Suggested: “On [date], I installed three apps with native libraries on an x86_64 emulator ([image: API level, Google APIs or Play] on [host CPU]) and on an ARM device ([model, Android version, physical or cloud]).”]
*When is ARM hardware worth it for testing?
*
When native code is part of what you’re testing. If your app is pure Kotlin or Java and every dependency ships x86 builds, an emulator covers most of your day-to-day work. Once native libraries enter the picture, an ARM run before release earns its place.
It’s worth it when:
- A dependency ships ARM only. Many third-party SDKs never build x86, so on the emulator you’re always testing through translation.
- You ship x86 libraries too. The emulator runs those by default, so it never touches your ARM build.
- Native code is performance-sensitive. Games, video, audio, image processing and crypto behave differently under translation, and frame timings on an x86 laptop say little about a phone.
- Crash reports come only from ARM devices. Reproduce them where they happen.
- It’s a release candidate. One pass on ARM hardware, the way users install from the store, catches packaging mistakes like a missing ABI folder.
Google’s own advice in the translation announcement points the same way. It still recommends publishing both x86 and ARM variants and treating translation as a testing convenience.
*Where do you get ARM devices?
*
Most teams mix these:
- Physical phones. The real thing, with sensors, SIM and vendor builds. They need a desk, cables and someone to keep them charged.
- Device farms. Services like Firebase Test Lab and BrowserStack host physical devices you test on per session. Good for broad coverage and CI. Devices reset between sessions.
- Cloud phone providers. Persistent Android devices in a data centre that you keep and reach over the network. Multilogin, a cloud Android phone platform for multi-account management, is one example: each cloud phone runs on its own real ARM Android device. It offers 30+ device types across 12 brands, Android versions selectable per profile, APK upload and full ADB access, so the commands above work as-is. Its cloud phones can’t receive SMS or calls, and they need a reliable connection. GeeLark, DuoPlus and VMOS Cloud also offer cloud phones.
- ARM hosts running ARM64 emulator images. No translation, but still an emulator, not a phone.
Whichever you pick, run getprop ro.product.cpu.abilist first. It’s the quickest way to know what you’re actually testing on.
FAQ
What’s the difference between ARM and x86 Android emulators?
An x86 emulator runs an x86 system image. ARM native libraries run there only through translation, and only on images that include it. An ARM64 image on an ARM host runs ARM code directly. Neither is a phone, but only the second runs your ARM libraries as ARM code.
Why does my app crash only on the emulator?
Check which library it loaded. If the APK has x86 libraries, the emulator runs those, so the crash may sit in your x86 build. If it’s ARM-only, the crash may come from code the translator handles differently. adb logcat -b crash -d shows the native stack, including the library path.
Do I need ARM hardware if my app is pure Kotlin or Java?
Rarely for day-to-day work, because ART runs your bytecode on any ABI. Check your dependencies with unzip -l app.apk 'lib/*'. If a lib/ folder shows up, you have native code after all.
Can I use the emulator’s ARM translation in a hosted testing service?
Not as a commercial service. Google’s announcement limits it to development and debugging on your own machines, on-premises servers and cloud environments you procure. It isn’t meant for providing commercial hosted services.
Is a cloud-hosted ARM device the same as a physical phone for testing?
For native code, it runs ARM binaries on ARM hardware, as a phone does. Other details depend on the provider, such as device models, Android versions, SIM and sensors. Multilogin’s cloud phones, for example, offer full ADB access but can’t receive SMS or calls.
Top comments (1)
The point about bundled x86 libraries disabling translation is the one that surprises people. It often comes from a third-party SDK shipping x86 .so files, so the emulator quietly runs code paths that real ARM phones never touch. Checking the APK's lib/ folders is a quick sanity step.