How to clear the Android Studio cache and speed up the IDE

Developing mobile applications for the platform Android requires significant computing resources, and over time the integrated development environment may begin to work slower. This is often due to the accumulation of temporary files, stale indexes, and cached Gradle data. If you notice that projects take a long time to open or produce strange compilation errors, it's time to do some spring cleaning. Android Studio It takes a long time to open projects or give strange compilation errors, it’s time to do some spring cleaning.

The cleaning process does not require complex manipulations with the registry or third-party utilities. The IDE's built-in tools allow you to safely remove accumulated junk in a few clicks. In this article, we will look at all the available methods: from the standard Invalidate Caches function to manually cleaning system folders to return your development environment to its former speed.

Standard cleaning through the Invalidate Caches menu

The easiest and safest way to solve problems with code display or false errors is to use the built-in reset function indexes. Indexes necessary for quickly searching for classes and methods, but sometimes they become out of sync with the actual state of the project files.

To start the procedure, go to the main menu and select File → Invalidate Caches.... A dialog box will open with several options. Here you can choose which data you want to delete. Usually it is enough to leave a check mark opposite the items Clear file system cache and Local History and Clear VCS Log caches and indexes.

After clicking the button Invalidate and Restart the development environment will close and start again. At this point, the process of re-indexing the project will begin, which can take from a few minutes to half an hour depending on the size of the code base. Do not interrupt this process as this may corrupt the IDE's internal databases.

⚠️ Attention: Clearing Local History will delete saved local versions of files. If you have not used version control (Git) and are relying only on the local change history, make sure that you do not need to restore previous revisions of the code before performing this operation.

Clearing the cache of the Gradle build system

The build system Gradle stores a huge number of dependencies and temporary files in special directories. Over time, the folder .gradle can grow to tens of gigabytes, taking up disk space and slowing down the project synchronization process.

To clear the Gradle cache globally for all projects, you need to find the corresponding directory in your user home directory. On Windows this is usually C:\Users\UserName\.gradle\caches, and on macOS and Linux - ~/.gradle/caches. Deleting the contents of this folder will force Gradle to download all the required libraries again on the next build.

There is also an option to clear the cache for a specific project. To do this, delete the folder .gradle i buildin the project root. After that, run the sync or build command. This is especially useful if you encounter library version conflicts that cannot be resolved by standard methods.

• 🗑️ Deleting a folder caches/modules-2 frees up the most space, since downloaded libraries (AAR and JAR files) are stored there.
• 🔄 Folder caches/build-cache-1 contains a compilation cache, clearing it is safe, but the next build will take longer.
• ⚙️ The file gradle.properties in your home directory may contain settings that affect the cache size, check the parameter org.gradle.caching.

Manual deletion of temporary system files

In addition to specific ones IDE and Gradle data, the operating system and the Java machine itself create temporary files during operation. Their accumulation can indirectly affect performance, especially if the system disk is almost completely full.

On Windows, temporary Java and IDE files often end up in the directory specified in the environment variable TEMP. You can quickly go there by clicking Win + R and entering the command %TEMP%. In this folder, you can safely delete files starting with the prefixes idea, gradle or hsperfdata.

On macOS and Linux, such files are usually located in /tmp or /var/folders. However, you should be careful here: delete only those files that clearly belong to closed Android Studio sessions. Using utilities like OnyX or BleachBit can automate this process, but always check the list of files before deleting.

# Example command to clear Gradle temporary files on Linux/Mac
rm -rf ~/.gradle/caches/*/plugin-resolution/

⚠️ Attention: Never delete files from system folders System32 or /usr/libeven if they seem temporary. Limit yourself only to user directories and folders of temporary files so as not to disrupt the operation of the operating system.

Resetting settings and deleting configuration files

Sometimes the problem lies not in the cache, but in damaged configuration files. If standard cleaning does not help, you may need a full reset Android Studio to factory state. This will return the IDE to its form immediately after installation.

Configuration files are stored in hidden directories. In Windows 10 and 11 they are located on the path C:\Users\UserName\AppData\Roaming\Google\AndroidStudio202X.X. On macOS, the path looks like ~/Library/Application Support/Google/AndroidStudio202X.X, and on Linux - ~/.config/Google/AndroidStudio202X.X.

Before deleting these folders, it is strongly recommended that you rename them (for example, add suffix _old) so that, if necessary, you can return the old settings. After deleting or renaming the configuration folder, launch Android Studio - it will create new clean settings files.

Where can I find the AppData folder in Windows?

By default, the AppData folder is hidden. To see it, open Explorer, go to the "View" tab and check the "Hidden elements" checkbox. Or simply enter %APPDATA% into the address bar.

Optimizing memory and virtual machine

Effectively clearing the cache also includes properly configuring memory allocation. If the IDE does not have enough RAM, it begins to actively use the page file, which is perceived by the user as severe slowdown and frequent writes to disk.

You can change the memory allocation parameters by editing the file vmoptions. Select Help → Edit Custom VM Optionsfrom the menu. Find the lines -Xms (initial heap size) and -Xmx (maximum heap size). For modern projects, it is recommended to set -Xmx at least 2048m or 4096m if you have free RAM.

It is also worth paying attention to the parameter -XX:ReservedCodeCacheSize. Increasing this value may help if you are working with very large projects and getting code overflow errors. However, do not set the values too high, so as not to take away all the memory from the emulator and other applications.

Parameter	Recommended value (8GB RAM)	Recommended value (16GB+ RAM)	Description
-Xms	512m	1024m	Initial memory size for JVM
-Xmx	2048m	4096m	Maximum memory size for JVM
-XX:ReservedCodeCacheSize	240m	512m	Cache size for compiled code
-XX:+UseG1GC	true	true	Using G1 garbage collector

Automating cleanup using scripts

For developers who switch between multiple projects or work in a team, manual cleanup can become a chore. Automating this process with scripts saves time and ensures that all temporary files are deleted correctly.

You can create a simple BAT file for Windows or a Shell script for Linux/macOS that will sequentially stop the Android Studio process, delete cache folders, and clean up temporary files. Such a script can be run once a week or before starting work on a new large module.

An example of a simple script for Windows might look like this. Save this code to a file clean_as.bat and run it as an administrator if necessary. Please note that the script closes all IDE processes before deleting files.

@echo off
echo Stopping Android Studio...
taskkill /F /IM studio64.exe
echo Cleaning Gradle caches...
rmdir /s /q %USERPROFILE%\.gradle\caches
echo Cleaning Android Studio system cache...
rmdir /s /q %APPDATA%\Google\AndroidStudio*\system\caches
echo Done!

⚠️ Attention: When using scripts, make sure that the folder paths match your version of Android Studio and operating system. Incorrect path in the command rmdir may lead to the deletion of important data in other directories.

Frequently asked questions (FAQ)

Will clearing the cache delete my projects and source code?

No, clearing cache, indexes and folders Gradle only affects temporary files and development environment settings. Your source codes, resources and project files stored in the working directory will remain intact. However, Local History can be deleted if you select the appropriate option.

Why is Android Studio slow again after cleaning?

Immediately after cleaning, the IDE should work faster, but in the first minutes it will actively re-index project files, which creates a load on the processor and disk. If slow performance persists for a long time, check your antivirus (exclude project folders from scanning) and the number of installed plugins.

Is it possible to delete the .idea folder in the project root?

Yes, the folder .idea can be deleted. It contains IDE-specific project settings. The next time you open the project, Android Studio will regenerate this folder with standard settings. This is useful if the project settings are damaged, but you will lose individual run configurations (Run Configurations).

How often should you clear the Android Studio cache?

Preventive cleaning via Invalidate Caches is recommended to be done once every 1-2 months or when updating the IDE version. A deep cleanup of Gradle folders should be done when disk space is critically low or when unexplained build errors occur that cannot be resolved otherwise.