How to Fix “Emulator Process finished with exit code 1” in Android Studio

Emulator Process finished with exit code 1

What Does “Emulator Process finished with exit code 1” Mean?

When Android Studio launches an AVD, it starts the Android Emulator process.

A successful launch opens the virtual-device window and boots Android.

If the Emulator process fails during initialization, Android Studio may display:

Emulator Process finished with exit code 1

The number 1 only tells you that the program did not exit successfully.

It does not tell you whether the underlying problem is graphics, virtualization, storage, an AVD configuration, a System Image, or another dependency.

Common Situations

The error can appear after:

• Creating a new AVD.
• Updating Android Studio.
• Updating the Android Emulator.
• Resuming a Quick Boot snapshot.
• An unexpected computer shutdown.
• Updating a GPU driver.
• Changing the System Image.
• Copying an AVD from another computer.
• Moving the Android SDK or AVD directory.
• Running low on disk space.
• Changing virtualization settings.

Common Causes

1. The Quick Boot Snapshot Is Corrupted

Android Emulator can save the previous virtual-device state so that subsequent startups are faster.

If this Quick Boot snapshot becomes corrupted, loading it can cause the Emulator to terminate.

Google’s current Emulator command-line documentation describes -no-snapshot-load as an option that performs a cold boot instead of restoring a saved snapshot. :contentReference[oaicite:13]{index=13}

2. The AVD Data Is Corrupted

User data, settings, caches, or other files inside the AVD can become inconsistent.

Android Studio’s Device Manager provides a Wipe Data operation that resets the virtual device’s data. :contentReference[oaicite:14]{index=14}

3. The Android Emulator Package Is Outdated or Damaged

The Android Emulator is an SDK component that can be updated independently of Android Studio itself.

An incomplete update or old Emulator version can contribute to startup failures.

4. The System Image Is Damaged

If only AVDs using one specific API level or System Image fail, the downloaded System Image may be incomplete or damaged.

5. GPU, OpenGL, or Vulkan Problems

The Android Emulator uses the host computer’s graphics system.

A GPU driver incompatibility or Vulkan/OpenGL initialization failure can terminate the Emulator during startup.

6. Hardware Acceleration Is Unavailable

Android Emulator relies on CPU virtualization technologies for efficient execution.

Disabled BIOS/UEFI virtualization, incompatible hypervisor settings, or virtualization conflicts can prevent an AVD from launching normally.

7. The AVD Configuration Is Too Demanding

An AVD with excessive RAM, storage, or unusual hardware settings may fail on a computer with limited resources.

8. Disk Space Is Insufficient

AVDs store virtual disks, user data, settings, and snapshots on the host computer.

If the storage volume is nearly full, initialization or snapshot operations can fail.

9. SDK or AVD Paths Are Invalid

If the Android SDK or AVD directory was manually moved, configuration files may continue referencing a location that no longer exists.

10. The AVD Contains Legacy Configuration

An AVD that has survived many Android Studio and Emulator upgrades may contain old settings or snapshots that no longer behave correctly.

Step 1: Check the AVD in Device Manager

Open Android Studio’s Device Manager:

Tools → Device Manager

Google’s current documentation describes Device Manager as the tool for creating, launching, stopping, editing, wiping, and deleting Android Virtual Devices. :contentReference[oaicite:15]{index=15}

Determine whether the problem affects one AVD or every AVD.

Step 2: Try Another AVD

If another virtual device is already available, start it.

For example:

Pixel 8 API 35 → fails Pixel 7 API 34 → works

This points toward the first AVD or its System Image.

If every AVD fails, investigate the Emulator package, graphics, virtualization, SDK installation, and host resources.

Solution 1: Cold Boot the AVD

This is usually the best first fix.

Open the AVD menu in Device Manager and use Cold Boot Now or the equivalent cold-boot action.

This avoids restoring the existing Quick Boot state.

With the traditional Emulator CLI, you can test a cold boot with:

emulator @AVD_NAME -no-snapshot-load

Google documents -no-snapshot-load as performing a cold boot while still allowing the Emulator state to be saved on exit. :contentReference[oaicite:16]{index=16}

Solution 2: Wipe the AVD Data

If Cold Boot does not help, reset the virtual device.

In Device Manager, open the AVD menu and choose Wipe Data.

Google’s current Device Manager documentation confirms that AVD user data can be cleared from this menu. :contentReference[oaicite:17]{index=17}

Solution 3: Delete and Recreate the AVD

If resetting the data does not help, delete the affected AVD and create a new one.

Device Manager supports both deletion and creation of AVDs. :contentReference[oaicite:18]{index=18}

For troubleshooting, start with a standard Pixel hardware profile and a commonly used stable System Image.

Solution 4: Update the Android Emulator

Open:

Tools → SDK Manager → SDK Tools

Update Android Emulator if an update is available.

Google notes that Android Emulator continues to be developed and improved, so keeping the Emulator package current can resolve known compatibility issues. :contentReference[oaicite:19]{index=19}

Solution 5: Reinstall the System Image

If only AVDs using a specific API level fail, reinstall that System Image through SDK Manager.

After reinstalling it, create a new AVD using the fresh image and test again.

Solution 6: Start the Emulator from the Command Line

The Android Studio message may only show the final exit status.

Starting the Emulator from a terminal can reveal the underlying error.

With environments that still expose the traditional Emulator CLI, list AVDs with:

emulator -list-avds

Then start one:

emulator @Pixel_8_API_35

Google’s Emulator command-line documentation describes launching virtual devices from a terminal and using startup options for troubleshooting. As of September 2026, Google’s latest documentation also notes the migration toward the newer Android CLI for Emulator management. :contentReference[oaicite:20]{index=20}

Look near the end of the output for messages such as:

ERROR: ... FATAL: ... Vulkan ... OpenGL ... PANIC: ... Could not ... Failed to ...

Solution 7: Enable Verbose Emulator Logging

With the traditional Emulator command-line interface, use:

emulator @AVD_NAME -verbose

The verbose output can reveal failures involving the AVD, graphics system, memory, System Image, or virtualization.

Solution 8: Change the AVD Graphics Setting

If the logs suggest a graphics problem, edit the AVD in Device Manager.

Check the Graphics setting and test a different rendering mode when available.

If hardware rendering fails, Software rendering can be useful as a diagnostic test.

Solution 9: Test Software GPU Rendering

With the traditional CLI, environments that support the option can test software graphics with:

emulator @AVD_NAME -gpu software

If the Emulator starts with software rendering but fails with hardware graphics, investigate the GPU driver or Vulkan/OpenGL compatibility.

Solution 10: Update the GPU Driver

On Windows or Linux, install an appropriate current driver from Intel, AMD, NVIDIA, or your computer manufacturer.

If the failure began immediately after a graphics-driver update, the update itself may also be involved.

Solution 11: Check for Vulkan Errors

Look for log messages containing terms such as:

Vulkan vulkan-1.dll VK_ERROR Failed to initialize Vulkan

If they appear, test updated graphics drivers or software rendering.

Solution 12: Check Hardware Virtualization

Make sure CPU virtualization support is enabled.

On Windows, Task Manager can indicate whether virtualization is enabled.

If disabled, check BIOS or UEFI settings for Intel VT-x, AMD-V, or the equivalent option supported by your hardware.

Solution 13: Check the Windows Hypervisor Configuration

Modern Windows Android Emulator configurations rely on supported Windows virtualization technologies.

Be careful with older troubleshooting guides that assume Intel HAXM is still the default solution.

Use the virtualization method appropriate for your current Android Emulator and Windows version.

Solution 14: Close Other Virtualization Software

Temporarily stop unnecessary VMware, VirtualBox, Docker virtual machines, third-party Android Emulators, and other virtualization-heavy applications.

Then try starting the Android Emulator again.

Solution 15: Reduce AVD RAM

If the AVD is configured with excessive RAM, edit the virtual device and reduce the allocation.

Also stop other running Emulators before testing.

Solution 16: Free Host RAM

Close memory-intensive applications such as browsers with many tabs, Docker environments, virtual machines, and unnecessary IDE instances.

Then start the Emulator again.

Solution 17: Check Disk Space

AVDs store virtual-device user data, applications, settings, and other files on the host computer.

Google’s Device Manager documentation describes the dedicated storage area associated with each AVD. :contentReference[oaicite:21]{index=21}

Check free space on the system drive and on the volume that contains your Android SDK and AVD files.

Solution 18: Check the AVD Storage Location

With the traditional AVD layout, virtual-device configuration is normally stored under:

~/.android/avd/

when no custom location is specified. Google’s AVD documentation describes this default directory. :contentReference[oaicite:22]{index=22}

If you manually moved or deleted AVD files, recreate the AVD rather than trying to repair a partially missing configuration.

Solution 19: Avoid Problematic SDK or AVD Paths

If the SDK or AVD is stored on a network share, restricted enterprise directory, removable drive, or unusual path, create a test AVD in a standard local configuration.

This helps isolate file-access and path problems.

Solution 20: Verify the Android SDK Location

The Emulator executable is normally stored inside the Android SDK’s emulator directory.

A common Windows location is:

C:\Users\User\AppData\Local\Android\Sdk\emulator

A common macOS location is:

~/Library/Android/sdk/emulator

Google’s current Emulator archive documentation lists `%LocalAppData%\Android\Sdk` on Windows and `$HOME/Library/Android/sdk` on macOS as standard SDK locations. :contentReference[oaicite:23]{index=23}

Solution 21: Restart Android Studio

After changing SDK, AVD, GPU, or System Image settings, close and reopen Android Studio before testing again.

Solution 22: Restart the Computer

A full restart can reset Emulator processes, graphics drivers, hypervisor state, and other system resources.

This is especially useful after:

• Repeated Emulator crashes.
• Changing virtualization settings.
• Updating graphics drivers.
• Changing Windows virtualization features.

Solution 23: Create an AVD with Another API Level

Create a new virtual device using a different System Image.

For example:

Existing: Pixel 7 API 33 → exit code 1

New:
Pixel 8 API 35 → starts normally

This strongly suggests that the older AVD or System Image is the problem.

Solution 24: Try Another Hardware Profile

Create an AVD using another standard hardware profile while keeping the same or similar System Image.

Google’s Device Manager documentation explains that an AVD combines a device hardware profile, System Image, storage, and other configuration properties. :contentReference[oaicite:24]{index=24}

Solution 25: Reinstall the Android Emulator Package

If every AVD immediately exits with code 1, reinstall the Android Emulator SDK component.

In SDK Manager under SDK Tools, remove:

Android Emulator

and install it again.

Restart Android Studio and test with a newly created AVD.

Read the Log Before the Exit-Code Message

This is the most important diagnostic step.

For example:

ERROR: Vulkan initialization failed Emulator Process finished with exit code 1

points toward graphics or Vulkan.

PANIC: Cannot find AVD system path Emulator Process finished with exit code 1

points toward an AVD or SDK path problem.

Not enough space Emulator Process finished with exit code 1

points toward host storage.

Difference from “The emulator process for AVD has terminated”

Android Studio may also report:

The emulator process for AVD ... has terminated.

Both messages indicate that the Emulator process terminated abnormally, so their troubleshooting steps overlap heavily.

Check Cold Boot, Wipe Data, AVD recreation, Emulator updates, graphics, and virtualization.

Difference from “Unable to launch AVD”

Another related message is:

Unable to launch AVD

This is also a broad AVD startup failure.

It may appear together with exit code 1, so the detailed log remains the best diagnostic source.

Recommended Windows Troubleshooting Order

1. Cold Boot the AVD.
2. Wipe Data.
3. Create another AVD.
4. Update Android Emulator.
5. Test Software graphics.
6. Update or review the GPU driver.
7. Check whether virtualization is enabled.
8. Review the Windows hypervisor configuration.
9. Check disk space.
10. Restart the computer.

Recommended macOS Troubleshooting Order

1. Cold Boot the AVD.
2. Wipe Data.
3. Recreate the AVD.
4. Update Android Emulator.
5. Try another System Image.
6. Check disk space.
7. Inspect the command-line Emulator log.
8. Restart the Mac.

Recommended Linux Troubleshooting Order

1. Try Cold Boot and Wipe Data.
2. Update Android Emulator.
3. Inspect GPU, OpenGL, and Vulkan errors.
4. Check KVM and virtualization.
5. Check SDK and AVD file permissions.
6. Check disk space.
7. Start the Emulator from a terminal and inspect the log.

Fastest General Troubleshooting Order

1. Cold Boot the affected AVD.
2. Wipe its data.
3. Update Android Emulator.
4. Create a fresh AVD.
5. Try another System Image.
6. Test software graphics.
7. Check free disk space.
8. Check virtualization support.
9. Start the Emulator from a terminal and inspect detailed errors.

If the Problem Still Occurs

If “Emulator Process finished with exit code 1” continues, verify all of the following:

• You tried Cold Boot.
• You tried Wipe Data.
• You created a new AVD.
• Android Emulator is current.
• You reinstalled the System Image.
• You tested another API level.
• You changed the graphics mode.
• You checked the GPU driver.
• You looked for Vulkan or OpenGL errors.
• Hardware virtualization is enabled.
• Other virtualization software is not interfering.
• The computer has enough free RAM.
• The disk has enough free space.
• The SDK and AVD paths are valid.
• You restarted Android Studio and the computer.
• You inspected the log before the exit-code message.

Summary

The Android Studio “Emulator Process finished with exit code 1” message means that the Android Emulator process terminated abnormally during startup.

Exit code 1 is not a specific diagnosis. It is the final status produced by many different failures.

The most useful first fixes are:

1. Cold Boot.
2. Wipe Data.
3. Recreate the AVD.
4. Update Android Emulator.
5. Reinstall the System Image.
6. Change graphics settings.
7. Check virtualization.
8. Check disk space.

Google’s current documentation provides Device Manager controls for launching, stopping, wiping, and deleting AVDs, and the Emulator command-line interface provides options such as -no-snapshot-load for bypassing saved Quick Boot state. :contentReference[oaicite:25]{index=25}

Most importantly, do not troubleshoot only the final line:

Emulator Process finished with exit code 1

Read the log immediately before it and look for ERROR, FATAL, PANIC, Vulkan, OpenGL, missing-file, storage, or virtualization messages.

If only one AVD fails, focus on its snapshot, data, System Image, and configuration. If every AVD fails, focus on the Android Emulator package, graphics, virtualization, SDK installation, and host computer resources.