How to Fix Android Emulator “Cannot find AVD system path”

PANIC: Cannot find AVD system path

What Does “Cannot find AVD system path” Mean?

Android Emulator needs two major groups of files to start an AVD:

• The Android System Image
• The AVD-specific configuration and writable data

Google’s Android Emulator documentation describes the System Image directory separately from each AVD’s data directory. :contentReference[oaicite:15]{index=15}

The System Image can contain files such as:

kernel-ranchu ramdisk.img system.img userdata.img

The AVD data directory can contain files such as:

config.ini userdata-qemu.img cache.img snapshots ...

If the Emulator cannot resolve these locations or required files are missing, startup can fail with an AVD system-path error.

Common Causes

1. The Android SDK Was Moved Manually

Moving the Android SDK from one drive or directory to another can leave Android Studio or existing AVDs referencing the old location.

2. The Required System Image Was Removed

An AVD can remain in Device Manager even after the System Image it depends on has been removed from the SDK.

3. The System Image Is Corrupted

An interrupted SDK update can leave the directory present but required files missing or incomplete.

4. The AVD Directory Was Moved Manually

Moving only the .avd directory can break the relationship between the AVD metadata and its actual data directory.

5. The AVD Configuration References an Old Path

An existing AVD may still contain references to a System Image or directory that no longer exists.

6. Multiple Android SDKs Exist

Android Studio may use one SDK while a terminal launches the Emulator from another SDK installation.

7. Environment Variables Point to Old Locations

Custom Android SDK or AVD environment variables can force the Emulator to look in an outdated directory.

8. The AVD Directory Is Inaccessible

An AVD stored on a disconnected external drive, network share, or restricted folder may be impossible for the Emulator to read.

9. The AVD Was Copied from Another Computer

An AVD copied from another development machine may contain paths that only existed on that machine.

10. Different User Accounts Use Different AVD Directories

Running Android Studio or Emulator under different user accounts can make the expected AVD directory change.

Step 1: List Available AVDs

First open Android Studio’s Device Manager:

Tools → Device Manager

Check whether the affected AVD still appears.

With the traditional Emulator CLI:

emulator -list-avds

As of September 2026, Google’s current documentation marks the traditional emulator management tool as deprecated and introduces the Android CLI instead. :contentReference[oaicite:16]{index=16}

android emulator list

If the AVD does not appear at all, investigate the AVD storage directory and metadata.

Step 2: Verify Android SDK Location

Check the Android SDK Location configured in Android Studio.

The SDK should contain directories such as:

emulator platform-tools system-images

If Android Studio points to an old or nonexistent SDK directory, correct it before doing anything else.

Step 3: Check the Required System Image

Determine which API level and System Image the AVD uses.

For an API 35 Google APIs x86_64 image, the SDK can contain a structure similar to:

system-images/ └─ android-35/ └─ google_apis/ └─ x86_64/ ├─ system.img ├─ ramdisk.img └─ userdata.img

Google’s current Emulator documentation confirms that Android Emulator reads the system files for an AVD from the SDK’s System Image directory. :contentReference[oaicite:17]{index=17}

Solution 1: Reinstall the System Image

Open:

Tools → SDK Manager

Find the API level and System Image used by the failing AVD.

If the image is missing, install it.

If it is already installed but the error persists, remove and reinstall the image to replace damaged files.

Solution 2: Delete and Recreate the AVD

If the AVD contains obsolete path information, recreating it is often safer than editing several configuration files manually.

Delete the failing virtual device from Device Manager and create a new one using the installed System Image.

Google’s current documentation describes creating and managing virtual devices through Android Studio or the Android CLI. :contentReference[oaicite:18]{index=18}

Solution 3: Correct Android Studio’s SDK Location

Make sure Android Studio points to the actual SDK directory.

A common Windows location is:

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

A common macOS location is:

/Users/User/Library/Android/sdk

Your SDK may be stored elsewhere if you changed the location manually.

Solution 4: Run the Emulator from the Correct SDK

To rule out multiple SDK installations, run the Emulator directly from the SDK configured in Android Studio.

macOS example:

~/Library/Android/sdk/emulator/emulator -list-avds

Windows example:

"C:\Users\User\AppData\Local\Android\Sdk\emulator\emulator.exe" -list-avds

Then launch the AVD:

emulator @Pixel_8_API_35

Google’s current documentation describes starting an AVD by name using the Emulator executable from the Android SDK. :contentReference[oaicite:19]{index=19}

Solution 5: Check Which Emulator Binary Is Being Used

On macOS or Linux:

which emulator

On Windows:

where emulator

If multiple results appear, an older Android SDK may be taking precedence.

Solution 6: Check the AVD Data Directory

Google’s current documentation identifies the normal AVD data locations as follows. :contentReference[oaicite:20]{index=20}

macOS and Linux:

~/.android/avd/AVD_NAME.avd/

Windows 10 and later:

C:\Users\User\.android\AVD_NAME.avd\

Verify that the affected AVD directory actually exists.

Solution 7: Inspect config.ini

An AVD normally contains a config.ini file.

~/.android/avd/Pixel_8_API_35.avd/config.ini

If you manually moved the SDK or AVD, inspect the configuration for references to directories or System Images that no longer exist.

In many cases, recreating the AVD is safer than manually repairing several entries.

Solution 8: Inspect the AVD .ini File

Some AVD configurations also use an INI file that points to the virtual device’s data directory.

For example:

~/.android/avd/Pixel_8_API_35.ini

Verify that it points to an existing .avd directory.

Solution 9: Restore a Manually Moved AVD

If you manually moved the AVD directory, move it back to its previous location temporarily and test the Emulator.

For a permanent custom location, configure the Android environment properly instead of moving individual files without updating their references.

Solution 10: Check System Image Files

The System Image directory normally includes files such as:

kernel-ranchu ramdisk.img system.img userdata.img

Google’s current Emulator documentation identifies these as important files read from the System Image directory. :contentReference[oaicite:21]{index=21}

If files are missing, reinstall the System Image through SDK Manager instead of copying individual files manually.

Solution 11: Do Not Manually Copy system.img from Another Computer

A System Image contains several coordinated files and is tied to a specific API level, variant, and CPU architecture.

Copying only system.img from another machine can leave the installation inconsistent.

Use SDK Manager to install the complete System Image package.

Solution 12: Check Android Environment Variables

If you customized SDK or AVD locations, inspect Android-related environment variables.

macOS and Linux:

env | grep ANDROID

Windows Command Prompt:

set ANDROID

Windows PowerShell:

Get-ChildItem Env:ANDROID*

Look for obsolete paths that refer to deleted drives, old user directories, or previous Android SDK locations.

Solution 13: Be Careful with Legacy ANDROID_SDK_HOME Settings

Older Android development environments used ANDROID_SDK_HOME for user-specific Android configuration and AVD storage behavior.

Android Studio 4.2 deprecated ANDROID_SDK_HOME in favor of ANDROID_PREFS_ROOT for Android Studio preferences. :contentReference[oaicite:22]{index=22}

On a machine that has been used for Android development for many years, check whether legacy environment variables are still redirecting AVD discovery to an obsolete directory.

Solution 14: Check Custom AVD Location Settings

If you deliberately moved AVD storage to another drive, verify that the configured AVD directory still exists.

This is especially important after changing drive letters, replacing disks, renaming a user account, or disconnecting an external drive.

Solution 15: Use the Same User Account

On Windows, repeatedly switching between normal and Administrator accounts can expose different user-specific AVD directories.

Run Android Studio and the Emulator under the same user account that owns the AVD files.

Solution 16: Check AVD Directory Permissions

On macOS or Linux, inspect the AVD directory:

ls -ld ~/.android/avd ls -l ~/.android/avd

If AVD files were copied from another account or machine, confirm that the current user can read and write them.

Solution 17: Check External and Network Drives

If the Android SDK or AVD is stored on an external SSD, USB disk, or network drive, verify that the storage is currently mounted and accessible.

On Windows, also check whether the drive letter has changed.

Solution 18: Use the Exact AVD Name

List the AVDs first:

emulator -list-avds

If the result is:

Pixel_8_API_35

launch it with the exact name:

emulator @Pixel_8_API_35

Solution 19: Use -verbose to See the Actual Paths

If the problem is unclear, run:

emulator @AVD_NAME -verbose

Google’s current Emulator documentation states that -verbose prints initialization information including the files and settings actually selected when the AVD starts. :contentReference[oaicite:23]{index=23}

Look for entries related to:

system image sysdir avd datadir path PANIC

Solution 20: Use -sysdir for Diagnostic Testing

The traditional Emulator CLI allows you to explicitly specify a System Image directory:

emulator @AVD_NAME -sysdir /path/to/system-image

Google documents -sysdir as an option for specifying a different system directory for an AVD. :contentReference[oaicite:24]{index=24}

Solution 21: Update Android Emulator

Open:

Tools → SDK Manager → SDK Tools → Android Emulator

Install the latest available Android Emulator update.

Solution 22: Reinstall Android Emulator

If every AVD produces path-related failures, reinstall the Android Emulator SDK component.

Remove it from SDK Manager, install it again, and restart Android Studio.

Solution 23: Restart Android Studio

After changing the SDK Location, System Images, AVD configuration, or environment variables, restart Android Studio.

Solution 24: Restart the Computer

If environment-variable or SDK-path changes do not appear to take effect, restart the computer to eliminate processes still using old values.

Difference Between “Cannot find AVD system path” and “Unable to launch AVD”

“Unable to launch AVD” is a broad startup error:

Unable to launch AVD

If the log specifically reports:

PANIC: Cannot find AVD system path

prioritize the Android SDK Location, System Image, AVD directory, and environment variables.

Difference Between an AVD Path Error and a GPU Error

A GPU problem often contains messages such as:

Vulkan OpenGL GPU Failed to initialize Vulkan

An AVD path problem is more likely to contain:

AVD system path system image sysdir PANIC

Changing graphics settings usually does not fix a missing System Image path.

If Only One AVD Fails

Use this order:

1. Check the AVD’s System Image.
2. Reinstall that System Image.
3. Check the AVD data directory.
4. Delete the affected AVD.
5. Create a fresh AVD.

If Every AVD Fails

Prioritize:

• Android Studio’s SDK Location
• Recent SDK moves
• Android environment variables
• Multiple Android SDK installations
• The Android Emulator package
• AVD directory permissions

Recommended Windows Troubleshooting Order

1. Check Android Studio’s SDK Location.
2. Inspect the SDK’s system-images directory.
3. Check the AVD in Device Manager.
4. Run where emulator.
5. Run set ANDROID.
6. Reinstall the System Image.
7. Recreate the AVD.

Recommended macOS Troubleshooting Order

1. Check the SDK Location.
2. Inspect ~/Library/Android/sdk/system-images.
3. Inspect ~/.android/avd.
4. Run which emulator.
5. Run env | grep ANDROID.
6. Reinstall the System Image.
7. Recreate the AVD.

Recommended Linux Troubleshooting Order

1. Check Android Studio’s SDK Location.
2. Inspect the SDK’s system-images directory.
3. Inspect ~/.android/avd.
4. Run which emulator.
5. Run env | grep ANDROID.
6. Check AVD directory permissions.
7. Reinstall the System Image and recreate the AVD.

Fastest Troubleshooting Order

If you do not know the cause, try:

1. Check Android Studio’s SDK Location.
2. Check which System Image the AVD requires.
3. Verify that the System Image exists in the SDK.
4. Reinstall the System Image.
5. Delete and recreate the AVD.
6. Check multiple SDK installations and environment variables.
7. Use -verbose to inspect the actual paths used by the Emulator.

If the Problem Still Occurs

If “Cannot find AVD system path” continues, verify all of the following:

• Android Studio points to the correct SDK.
• The Android SDK was not moved without updating settings.
• The required System Image exists.
• You reinstalled the System Image.
• You recreated the AVD.
• The AVD directory was not manually moved.
• The AVD INI and config.ini files exist.
• Multiple Android SDKs are not conflicting.
• You checked where emulator or which emulator.
• Android environment variables do not contain obsolete paths.
• The AVD directory is readable and writable.
• External or network storage is connected.
• You updated or reinstalled Android Emulator.
• You used -verbose to inspect the actual paths.

Summary

The Android Emulator “Cannot find AVD system path” error usually means that the Emulator cannot locate the System Image or AVD data required by the selected virtual device.

Android Emulator stores System Images and AVD-specific data separately. Google’s current documentation describes the System Image under the Android SDK and each AVD’s writable data under the user-specific AVD directory. :contentReference[oaicite:25]{index=25}

Start by checking four things:

1. Android Studio’s Android SDK Location.
2. The System Image required by the AVD.
3. The AVD data directory.
4. Android-related environment variables.

If the System Image is missing or damaged, reinstall it through SDK Manager. If the AVD still references an obsolete path, deleting and recreating the AVD is usually safer than manually repairing all of its files.

For detailed diagnosis, the traditional CLI provides:

emulator @AVD_NAME -verbose

which shows the files and paths selected during Emulator initialization. :contentReference[oaicite:26]{index=26}

As of September 2026, Google’s current documentation also marks the older emulator and avdmanager management tools as deprecated in favor of the newer android emulator Android CLI. :contentReference[oaicite:27]{index=27}

If only one AVD fails, focus on its System Image and recreate that AVD. If every AVD fails, focus on Android SDK Location, environment variables, duplicate SDK installations, and the Android Emulator installation itself.