If your Android Studio emulator running slow is holding back your development work, you’re not the only one dealing with it. Almost every Android developer hits this wall at some point — you launch the emulator, wait forever, and by the time it boots, you’ve already lost your focus.
The good news is that most of the slowness isn’t about your hardware being bad. It’s about a few settings that are either misconfigured or never set up correctly in the first place. In this guide, you’ll get 5 clear, actionable steps to get your emulator running the way it should.
No fluff, just fixes.
Why Is the Android Studio Emulator So Slow?
Before jumping into solutions, it helps to understand what’s actually happening under the hood.
The Android emulator runs a full Android operating system inside a virtual machine on your computer. Without hardware help, your CPU has to simulate every single instruction the virtual device tries to run — including graphics operations, touch events, and background processes.
That’s an enormous amount of work for software alone.
The most common reasons your emulator drags are:
- Hardware acceleration is disabled or misconfigured — this is the biggest one
- You’re using an ARM system image instead of x86/x86_64
- Not enough RAM is allocated to the virtual device
- Antivirus software is scanning every emulator file in real time
- Quick Boot is turned off, so the emulator does a full cold start every time
Each of the 5 steps below targets one of these root causes.
Step 1: Enable Hardware Acceleration (This One Matters Most)
Hardware acceleration is the single most important fix for an Android Studio emulator running slow. Without it, you’ll always have a sluggish experience no matter how powerful your machine is.
How you enable it depends on your operating system and processor.
On Windows (Intel CPU)
For emulator versions 36.2 and above, the recommended path is Windows Hypervisor Platform (WHPX). HAXM has been deprecated in newer emulator versions, so use WHPX going forward.
Here’s how to enable it:
- Press the Windows key and search for “Turn Windows features on or off”
- Check Windows Hypervisor Platform
- Also check Hyper-V if available
- Click OK and restart your computer
- Make sure Virtualization (VT-x) is enabled in your BIOS
On Windows (AMD CPU)
WHPX also works on AMD processors. You’ll need to enable SVM (Secure Virtual Machine) in your BIOS settings. The steps for enabling WHPX in Windows are the same as above.
On macOS
macOS uses the built-in Hypervisor.Framework, so there’s nothing to install manually. Just make sure your emulator is up to date and using an x86_64 image.
On Linux
Linux uses KVM (Kernel-based Virtual Machine). Run this command to install and verify:
bash
sudo apt-get install qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils
emulator -accel-checkAfter enabling acceleration, restart Android Studio and launch your AVD again. The difference is usually immediate and very noticeable.
Step 2: Use an x86 or x86_64 System Image (Not ARM)
This is a mistake a lot of developers make without realizing it, especially when creating a new virtual device.
When you pick a system image for your AVD, there are ARM-based and x86-based options. ARM images look familiar because real Android phones run on ARM chips. But your development computer almost certainly has an Intel or AMD processor, not ARM.
Running an ARM image on an x86 machine means the emulator has to translate every single instruction from one architecture to another. This is incredibly slow — think 10x slower than it should be.
The fix is simple: always choose an x86 or x86_64 system image.
To change your system image:
- Open Android Studio and go to Device Manager
- Click the pencil icon next to your AVD to edit it
- Click Change next to the system image
- Filter by x86 Images tab
- Select an x86_64 image (Google APIs x86_64 is a good choice)
- Finish and relaunch the emulator
You’ll need Google Play Store features? Pick an image labeled Google Play in the x86 Images tab.
Step 3: Allocate More RAM and CPU Cores to the AVD
Even if hardware acceleration is working and you’re using an x86 image, an underpowered virtual device configuration can still make the emulator feel slow.
By default, Android Studio might create an AVD with only 1.5GB or 2GB of RAM. That’s often not enough for a smooth experience, especially on newer Android versions.
Recommended RAM allocation: 2GB to 4GB, depending on how much your machine has. Don’t give it more than half your total RAM — if you do, your system starts swapping and everything grinds to a halt.
Here’s how to adjust it:
- Go to Device Manager in Android Studio
- Click the pencil icon to edit your AVD
- Click Show Advanced Settings
- Find RAM and increase it to 2048MB or 4096MB
- Also increase VM Heap to at least 512MB
- Set CPU Cores to 2 or 4 if your machine has them to spare
While you’re there, you can also disable emulator features you don’t need for your current testing — GPS, camera, sensors. Less simulation = less overhead.
Step 4: Enable Quick Boot and Use Snapshots
Every time you do a cold boot of the emulator, it goes through a full Android startup sequence. That’s 30 seconds to 2 minutes of your life, every single session. Multiply that over a week of development and it adds up fast.
Quick Boot solves this by saving a snapshot of the emulator’s state when you close it and restoring it the next time you launch. It’s like waking your laptop from sleep instead of turning it on from scratch.
Quick Boot is enabled by default in most setups, but it’s worth double-checking:
- In Android Studio, go to Device Manager
- Edit your AVD (pencil icon)
- Click Show Advanced Settings
- Under Emulator Performance, make sure Boot option is set to Quick Boot
- Save and relaunch
You can also manually take snapshots at any point using the emulator’s camera icon in the side toolbar. This lets you freeze a specific app state and jump back to it instantly.
If Quick Boot isn’t working, try this: launch the emulator, wait for it to fully boot, then cold boot once to create a fresh snapshot. After that, Quick Boot will pick it up.
Step 5: Check for Antivirus Interference and Free Up Disk Space
This one catches a lot of developers by surprise.
Antivirus software works by monitoring every file read and write on your machine. The Android emulator creates and accesses thousands of small files during build and boot. When your antivirus scans every single one of those in real time, it takes a serious performance hit.
The fix: add Android Studio and the emulator folder to your antivirus exclusion list.
Folders to exclude:
- The Android SDK directory (usually
C:\Users\YourName\AppData\Local\Android\Sdkon Windows) - Your Android Studio project directory
- The emulator executable itself
This is not a security risk — these are your own development files, not downloaded executables from the internet.
Also, make sure you have at least 5GB of free disk space. The Android emulator actually checks for this on startup and won’t run if disk space is too low. An SSD also helps significantly here — if you’re still on a traditional hard drive, moving your SDK and project files to an SSD can cut boot times in half.
On Windows, there’s one more thing to check: the emulator works better on the GPU of a discrete graphics card than on integrated Intel graphics. If your machine has both, open Device Manager and confirm you’re using the discrete GPU. Keeping your graphics drivers updated also matters, especially on Intel HD 4000 systems.
Quick Summary: 5 Steps to Fix Android Studio Emulator Running Slow
| Step | What to Do | Impact |
|---|---|---|
| 1 | Enable WHPX or KVM hardware acceleration | Very High |
| 2 | Switch to x86 or x86_64 system image | High |
| 3 | Increase RAM and CPU cores in AVD settings | Medium–High |
| 4 | Enable Quick Boot and use snapshots | Medium |
| 5 | Exclude from antivirus, free up disk space | Low–Medium |
Do all five, and the difference is dramatic.
Bonus: Should You Use a Physical Device Instead?
Sometimes the honest answer is: yes. If you’re doing intensive UI work, testing camera features, or your machine is older and can’t be upgraded, running your app on a real Android phone connected via USB debugging is often faster and more accurate than any emulator.
That said, the emulator is still the best tool for:
- Testing multiple Android versions quickly
- Testing without needing a physical device on hand
- Automated testing pipelines
A well-configured emulator and a physical device aren’t competing — they complement each other.
FAQ
Why is my Android Studio emulator so slow even on a good computer?
The most common reason is that hardware acceleration isn’t properly configured. Even on a fast machine, if WHPX or KVM isn’t enabled, the emulator falls back to software emulation, which is extremely slow. Check Step 1 first.
How much RAM should I allocate to the Android emulator?
Between 2GB and 4GB is the sweet spot for most setups. Never allocate more than half your total system RAM, or your machine will start swapping memory to disk, which makes everything slower.
What is the difference between x86 and ARM system images?
x86 images are designed to run on Intel/AMD processors — the kind in your development machine. ARM images are meant for actual phones. Running ARM images on an x86 machine requires instruction translation, which is very slow. Always use x86_64 images for development.
Does HAXM still work in 2025?
HAXM has been deprecated starting from emulator version 33.x and removed in version 36.2+. If you’re on a recent version of Android Studio, you should use WHPX (Windows) or AEHD instead. Check your emulator version and follow the current documentation.
Can antivirus software really slow down the Android emulator that much?
Yes — significantly. Security software that scans every file read/write in real time can cause massive slowdowns during emulator boot and operation. Adding your SDK and project folders to the antivirus exclusion list is a safe and effective fix.
Why does Quick Boot sometimes not work?
Quick Boot requires a valid snapshot from a previous session. If the emulator crashed or was force-closed, the snapshot might be corrupted. Do a full cold boot once to create a fresh, clean snapshot, and Quick Boot should work from that point on.
Is 8GB of RAM enough to run Android Studio with the emulator?
It can work, but 16GB is much more comfortable. With 8GB, you’ll want to close other applications while running the emulator, keep RAM allocation to 2GB or less, and be selective about which Chrome tabs and background apps are open.
Editor’s Opinion
honestly, i dealt with slow emulator for months before figuring this out. the hardware acceleration thing is what got me — i had no idea it wasnt enabled. once i switched to x86 images and turned on WHPX, it felt like a totaly different machine. if your emulator is crawling, just do step 1 and step 2 first. probly fixes it for 80% of people. the antivirus tip also surprised me more than i expected. simple stuff but nobody tells you.
