Android Emulator — what it is and how emulation works

What is Android Emulator?

Android Emulator is a virtual Android device running on QEMU (Quick EMUlator) that emulates the Android hardware platform. Unlike iOS Simulator, Android Emulator fully translates ARM instructions, allowing code compiled for mobile architecture to run on an x86_64 host.

Google released Android Emulator in 2007 alongside the first version of the Android SDK. Since then, the emulator has evolved from a slow ARM-only solution to a high-performance system with GPU support, hardware acceleration and sensor emulation. According to Google (Android Developer Blog, 2025), the modern emulator with HAxM runs 4-5 times faster than the first generation.

The emulator supports all components of an Android device: CPU, GPU, RAM, storage, touch screen, accelerometer, gyroscope, GPS, camera, battery, NFC, Bluetooth and Wi-Fi. Developers can simulate incoming calls, SMS, various network signal levels and geolocation through Extended Controls.

System images for the emulator

Android Emulator uses system images downloaded via SDK Manager. Each system image contains a full copy of the Android firmware for the selected API level and target processor architecture. Images are available with different architectures: x86_64 (recommended with HAxM), ARM64 (for ARM compatibility testing) and Google APIs (with pre-installed Google Play Services). Separate images are also available for Wear OS, Android TV and Automotive.

// Emulator type check in code
val isEmulator = Build.FINGERPRINT
    .contains("generic") ||
    Build.PRODUCT.contains("sdk")

if (isEmulator) {
    Timber.d("App is running in an emulator")
}

Setting up AVD in Android Studio

AVD (Android Virtual Device) is a virtual device configuration for the emulator. AVD Manager in Android Studio allows creating devices with any combination of characteristics: model, screen size, pixel density, RAM size, storage size and Android version.

Creating AVD is done through Device Manager in Android Studio: select a hardware profile (Pixel, Nexus, Galaxy and others), system image and configure parameters. After creation, the device appears in the Run Configurations list for immediate app launch.

Snapshot mode for quick start

The emulator supports Quick Boot — it saves the AVD state as a snapshot and restores it on the next launch. Boot time decreases from 30-60 seconds to 2-5 seconds. To reset to a clean state, use Cold Boot Now in AVD Manager.

ARM translation and hardware acceleration

ARM translation is a key Android Emulator technology that converts ARM instructions to x86_64 on the fly. Without translation, the emulator could only run x86_64 images, limiting testing capabilities. Google uses libhoudini for ARM→x86 translation and Intel libraries for HAXM acceleration.

# Checking HAxM status on Windows
sc query "IntelHaxm"

# Installing HAxM via SDK Manager
sdkmanager "extras;intel;Hardware_Accelerated_Execution_Manager"

# Starting emulator with hardware acceleration
emulator -avd Pixel_9_API_35 -accel on -gpu auto

Intel HAxM (Hardware Accelerated Execution Manager) is a virtualization driver for Intel VT-x processors that speeds up the emulator by 3-5 times. On Windows with an AMD processor, use Windows Hyper-V Platform and WHPX. Without hardware acceleration, the emulator runs slowly, with animation delays of up to 1-2 seconds.

On macOS with Apple Silicon (M-series), hardware acceleration works natively through Hypervisor.framework. According to Google (Android Emulator Release Notes 2025), the emulator on M2 Max achieves 95% of real device performance for basic operations.

Emulator vs real device

The choice between emulator and real device depends on the development stage. The emulator is convenient for development and debugging: fast startup, instant deployment, Extended Controls for sensor simulation. A real device is for final performance, battery and hardware testing.

Performance of the emulator with hardware acceleration is often higher than a real budget device. Therefore, run final tests on real devices with the target performance level.

Checking emulator in Kotlin code

Detecting the runtime environment in Kotlin is useful for disabling incorrect code or adding debug information. Android provides Build.FINGERPRINT, Build.PRODUCT and Build.HARDWARE for this purpose.

object EmulatorDetector {
    val isEmulator: Boolean
        get() = Build.FINGERPRINT.startsWith("generic")
                || Build.FINGERPRINT.contains("emulator")
                || Build.HARDWARE == "ranchu"
                || Build.HARDWARE == "goldfish"
    
    fun logEnvironment() {
        if (isEmulator) {
            Log.d("EmulatorDetector", "Environment: emulator")
        }
    }
}

Using an emulator detector helps during debugging: on the emulator you can enable extended logging, disable animations or replace real API calls with mocks. Avoid checking in production builds unless required for application business logic.

Testing apps on the emulator

Android Emulator is used for automated testing on CI servers. To run tests, you need to create an AVD, start the emulator and wait for the system to fully boot. Gradle Managed Devices simplify this process: AVD configuration is described in build.gradle.kts.

// build.gradle.kts — Gradle Managed Devices
android {
    testOptions {
        managedDevices {
            devices {
                register<ManagedVirtualDevice>("pixel9Api35") {
                    device = "Pixel 9"
                    apiLevel = 35
                    systemImageSource = "google"
                }
            }
        }
    }
}

To start the emulator manually use the command line: emulator -avd Pixel_9_API_35 -no-window -no-audio -gpu swiftshader_indirect. The -no-window flag disables the graphical interface for server environments, and -gpu swiftshader_indirect provides software rendering without host GPU.

Network and sensor emulation

Extended Controls in Android Emulator provides powerful tools for simulating network conditions: latency, bandwidth and network type (GPRS, EDGE, 3G, 4G, 5G). This allows testing application behavior under slow connections without physically traveling to an area with poor coverage.

Sensor simulation includes accelerometer, gyroscope and magnetometer through virtual 3D device models. For GPS, you can load GPX files with routes — the emulator simulates movement along coordinates, which is critical for testing navigation applications. Camera is emulated through the host webcam or image loading.

Multi-display in Android Emulator supports multiple screens for tablets and foldable devices. Extended Controls allow changing orientation, screen size and pixel density (DPI) without restarting the emulator. For testing foldable devices, Foldable modes are available with switching between folded and unfolded states.

Android Emulator for Wear OS and Android TV

The emulator supports not only smartphones but also Wear OS and Android TV. For Wear OS, round and rectangular AVD configurations are available, bezel rotation simulation and swipe gestures, as well as testing interaction with a phone emulator. For Android TV, an interface with D-pad navigation is used. Both platforms support hardware acceleration and testing with Google Play Services, which is important for the dev cycle of smartwatch and TV applications.