Working with an emulator in Android Studio often turns into a test of patience: long loading times, lags when scrolling, freezes when launching applications. The problem is especially acute on weak PCs or when testing resource-intensive applications with OpenGL ES 3.0 or Vulkan. The reasons for the brakes lie in incorrect virtualization settings, suboptimal resource allocation, or an outdated version of the emulator.

In this article we will look at 7 working methods of accelerationwhich will help reduce the loading time of the emulator from 5-10 minutes to 30-60 seconds, as well as eliminate freezes when interacting with the interface. All solutions have been tested on Android Studio Giraffe | 2022.3.1 and newer, but the majority of principles are also relevant for older versions. Important: some of the settings require administrator rights and access to BIOS/UEFI.

If you use M1/M2 Mac, pay attention to a separate section - the architecture ARM has its own nuances. For PC owners on Windows 11 s Hyper-V there are also separate recommendations.

1. Enabling hardware virtualization (HAXM/WHX)

Without hardware virtualization, the emulator works in software emulation mode, which is 5–10 times slower. On Intelprocessors it is used on Intel HAXM, on AMD — Windows Hypervisor Platform (WHX) or AMD-V. On Apple Silicon (M1/M2) virtualization is enabled automatically via Rosetta 2, but requires additional settings.

To check virtualization support:

  • 🔹 On Windows: open Task Manager → Performance → CPU. The “Virtualization” item should be marked as “Enabled.”
  • 🔹 On macOS: run the command in the terminal 
    sysctl -a | grep machdep.cpu.features
    and find the flag VMX (for Intel) or SVM (for AMD).
  • 🔹 On Linux: enter 
    egrep -c '(vmx|svm)' /proc/cpuinfo
    —the result must be greater than 0.

If virtualization is disabled, activate it in BIOS/UEFI (options Intel VT-x, AMD-V or SVM ModeAfter that:

  1. In Android Studio go to Tools → SDK Manager → SDK Tools.
  2. Tick the box opposite Intel x86 Emulator Accelerator (HAXM installer) (for Intel) or Android Emulator Hypervisor Driver (for Windows with Hyper-V).
  3. After installation, restart your PC.
📊 What processor does yours have? PC?
Intel (Core i3/i5/i7/i9)
AMD (Ryzen 3/5/7/9)
Apple Silicon (M1/M2)
Other
⚠️ Attention: On Windows 11 with Hyper-V enabled (for example, for WSL2 or Docker Desktop) Intel HAXM does not work. Instead use Windows Hypervisor Platform (WHX), but keep in mind that performance will be 10-15% lower.

2. Optimizing emulator settings

Even with virtualization enabled, the emulator may slow down due to incorrectly selected ones parameters. Optimal settings depend on the configuration of your PC:

Parameter Minimum requirements Recommended values For weak PCs
Emulator RAM 1 GB 2–4 GB (50% of physical RAM) 1–1.5 GB
Video memory 64 MB 512 MB – 1 GB 128–256 MB
CPU Cores 1 core 4–6 cores (but not more than 75% of physical ones) 1–2 cores
Resolution screen 480×800 1080×1920 (Full HD) 720×1280
Android version Any Android 11–13 (API 30–33) Android 10 (API 29)

To change parameters:

  1. In Android Studio open AVD Manager (icon with phone in the right panel).
  2. Click on the pencil (✏️) next to your device.
  3. In the section Emulated Performance select:
    • 📱 Graphics: Hardware - GLES 2.0 (for maximum speed) or Automatic.
    • 🖥️ Boot Option: Quick Boot (saves state between launches).
  • In section Advanced Settings set:
    • 🔄 RAM: 2048–4096 MB (depending on physical RAM).
    • 🖥️ VM Heap: 256–512 MB.
    • 💾 Internal Storage: 2–4 GB (enough for most tasks).

    Select an image marked "Google Play" (if you need the Play Market)|

    Install Graphics to "Hardware - GLES 2.0"|

    Limit RAM to 50% of physical|

    Disable animation in the emulator developer settings|

    Use Quick Boot for quick startup-->

    Critical error: If you select "Software - GLES 2.0" instead of "Hardware" in the emulator settings, performance will drop 5-7 times, and loading will take 5+ minutes even on powerful PCs.

    3. Using alternative images (x86 vs ARM)

    Default Android Studio offers images based on ARM, which are emulated in software and work extremely slowly on x86-processors. The solution is to use images marked x86 or x86_64:

    • 🚀 Google Play x86: full compatibility with Google services, optimized for Intel/AMD.
    • ⚡ Android-x86: lightweight images without Google Play (suitable for testing without services).
    • 🍎 ARM on M1/M2: only for Apple Silicon (emulation x86 on ARM works 3-4 times slower).

    How to install x86-image:

    1. In AVD Manager click Create Virtual Device.
    2. Select a device (for example, Pixel 5).
    3. At the stage of selecting a system image, filter by x86_64 and select the version with marked Google Play (if needed Play Market).
    4. Click Download (size ~1.5 GB) and wait for installation.
    ⚠️ Attention: On Apple M1/M2 emulation of x86applications through Rosetta 2 gives a performance drawdown of up to 40%. Use images ARM (for example, svelte or vanilla without Google Play), even if they are marked as "slow" - in practice they work faster.

    4. Acceleration through the command line (ADB)

    Some emulator parameters can only be optimized through ADB (Android Debug Bridge). data-i="162">) gives an increase of 15-20% FPS.vsync) gives an increase of 15–20% FPS.

    Basic commands for acceleration:

    # Disable animation (speeds up navigation)

    adb shell settings put global window_animation_scale 0
    

    adb shell settings put global transition_animation_scale 0
    

    adb shell settings put global animator_duration_scale 0
    


    Reduce vsync frequency (for weak PCs)
    

    adb shell setprop debug.hwui.render_dirty_regions false
    


    Disable checking for updates (saves resources)
    

    adb shell pm disable-user --user 0 com.google.android.gsf.updateSystem

    To apply commands:

    1. Start the emulator.
    2. Open a terminal in the folder platform-tools (usually C:\Users\YourName\AppData\Local\Android\Sdk\platform-tools).
    3. Enter commands one by one by clicking Enter.
    4. Reboot the emulator: 
      adb reboot
    💡

    If the emulator does not respond to ADB commands, check the connection via adb devices. If the list is empty, restart the ADB server with the command adb kill-server && adb start-server.

    5. Optimizing the host system (Windows/macOS/Linux)

    The performance of the emulator depends not only on its settings, but also on the state of your OS. data-i="178">Disable

    • 🖥️ Windows:
      • Disable Hyper-Vif you do not use WSL2 or Docker Desktop (via Control Panel → apps → Turn Windows components on or off).
      • Add emulator.exe to exceptions Windows Defender (folder Android\Sdk\emulator).
    • 🍎 macOS:
      • Disable FileVault (if enabled) - it slows down disk access on 10–15%.
      • Increase the size of the swap file: 
        sudo rm /private/var/vm/sleepimage && sudo touch /private/var/vm/sleepimage && sudo chmod 600 /private/var/vm/sleepimage
    • 🐧 Linux:
      • Install qemu-kvm and add the user to the group kvm:
        • sudo apt install qemu-kvm libvirt-daemon-system && sudo adduser $USER kvm
      • Disable SELinuxif it is active (may block access k /dev/kvm).

    General recommendations for all OS:

    • 🔌 Use SSD (HDD slows down the loading of the emulator by 3-5 times).
    • 🧹 Close background apps that consume RAM (Chrome, Discord, Slack).
    • 🔄 Regularly clear the emulator cache through AVD Manager → Wipe Data.
    💡

    On Linux, the emulator works fastest thanks to direct access to KVM. On Windows, an additional 5-10% of performance is provided by disabling Hyper-V (if it is not needed for other tasks).

    6. Alternative emulators (Genymotion, BlueStacks, Android-x86)

    If the built-in emulator Android Studio still slows down, consider alternatives:

    Emulator Pros Cons Best for
    Genymotion High speed, cloud solutions, support OpenGL Paid (free for personal use only) UI/UX testing, cloud development
    BlueStacks Optimized for games, simple interface Closed source, lots of bloatware Game testing applications
    Android-x86 Free, runs on bare metal (no virtualization) Complicated installation, no Google Play by default Advanced users, testing on real hardware
    NoxPlayer Multi-screen support, rooting Lots of advertising, Chinese software Multi-account (for example, for cloning applications)

    For integration with Android Studio best suited Genymotion:

    1. Download and install Genymotion from official website.
    2. In Android Studio go to File → Settings → Plugins and install the plugin Genymotion.
    3. Create a new device in Genymotion and connect it via ADB.
    ⚠️ Attention: BlueStacks and NoxPlayer may conflict with Hyper-V on Windows 11If the emulator does not start, disable Core Isolation in the Windows security settings.

    7. Updating software and drivers

    Outdated versions of Android Studio, SDK Tools or virtualization drivers may cause brakes Check the relevance:

    • 🔄 Android Studio: update. via Help → Check for Updates.
    • 🛠️ SDK Tools:
      • Open SDK Manager.
      • Update Android Emulator, Intel HAXM, SDK Platform-Tools.
    • 🖥️ Drivers:
      • On Windows: update chipset and video card drivers via Device Manager or utilities manufacturer (Intel Driver & Support Assistant, NVIDIA GeForce Experience).
      • On macOS: install the latest updates via System settings → Software update.

    If after the update the emulator stops starting:

    1. Delete old images via AVD Manager → Delete.
    2. Create a new emulator with the current version of Android.
    3. Check the error logs in ~/.android/avd//config.ini (Linux/macOS) or %USERPROFILE%\.android\avd\.ini (Windows).
    How to return the old version of Android Emulator?

    If the new version of the emulator works worse, download old via SDK archive. Unpack the ZIP into a folder Android\Sdk\emulator and replace the files (make a backup first!).

    FAQ: Frequently asked questions about accelerating the emulator

    ❓ Why does the emulator slow down even on a powerful PC?

    The most common reasons:

    • Hardware virtualization is not enabled (Intel VT-x/AMD-V).
    • Image selected ARM instead x86.
    • Insufficient RAM (less than 2 GB for the emulator).
    • Conflict with Hyper-V or WSL2 on Windows.

    Check the settings according to the instructions above.

    ❓ How to speed up the emulator on M1/M2 Mac?

    On Apple Silicon:

    • Use images ARM (for example, svelte or vanilla without Google Play).
    • Disable Rosetta for Android Studio (right click on the application → Information → uncheck Open with Rosetta).
    • Increase the swap file (see section 5).

    Emulation x86 on ARM works 3-4 times slower!

    ❓ Is it possible to use the GPU of the host system for acceleration?

    Yes, but with reservations:

    • In the emulator settings, select Hardware - GLES 2.0 or Automatic.
    • On Windows install latest drivers for video card (NVIDIA/AMD/Intel).
    • On macOS GPU acceleration works only on Metal (supported with Android 11+).

    If the emulator gives an error Failed to initialize EGL, try switching to Software - GLES 2.0.

    ❓ Why does the emulator start slowly for the first time?

    The first launch is always longer (3-7 minutes), because:

    • A virtual disk is created (qcow2).
    • System applications are installed.
    • Cached libraries ART.

    Use Quick Boot (saves state between starts) or clone a ready-made virtual machine.

    ❓ How to transfer the emulator to another PC?

    Copy the folder with the image along the path:

    • Windows: %USERPROFILE%\.android\avd
    • macOS/Linux: ~/.android/avd

    On a new PC:

    1. Install the same version Android Studio and SDK Tools.
    2. Copy the folder avd to the appropriate directory.
    3. Open AVD Manager —the emulator will appear in the list.