Development of large applications in the environment Android Studio often leads to expansion of the project structure. Over time, experimental branches, outdated libraries, or test modules appear that are no longer needed. Their presence not only clutters navigation, but can also slow down the project build process, increasing compilation time.
The process of deleting a module seems trivial, but simply erasing the folder with files leads to critical errors in the file settings.gradle and broken dependencies. To correctly get rid of an unnecessary component, you need to perform a series of steps to clean up the assembly configuration. In this article, we will look at a safe algorithm for deleting a module and methods for restoring a project in case of failures.
Before you start changing the structure, make sure that you have an up-to-date backup copy of the project or it is saved in a version control system Git. This will allow you to rollback changes if automatic synchronization Gradle does not succeed. Ignoring this step may result in loss of working configuration settings.
Preparing the project for structure changes
The first stage is dependency analysis. A module rarely exists in isolation; it may be referenced by other parts of the application or core libraries. If you remove a component that other modules depend on, the project build will fail with a compilation error. Use the built-in dependency graph analysis tool to identify all relationships.
Open the file build.gradle of the main application (usually a module :app) and check the section dependencies. Find lines containing a link to the module to be removed, for example implementation project(':my_old_module'). Such lines must be deleted or commented out before physical actions with the file system begin.
⚠️ Attention: Do not delete a module if it is connected through Dynamic Feature Modules without first updating the application manifest. This can lead to an application crash when trying to load missing code.
It is also worth checking the files proguard-rules.pro or keep.txtif the project has code obfuscation configured. Sometimes there are rules for saving classes specifically for the module being removed. Clearing these rules will help avoid warnings from the linter about unused configurations.
☑️ Preparing to remove the module
Correct removal through the IDE interface
The safest way to get rid of a module is to use the built-in tools Android Studio. This method ensures that the IDE itself updates the necessary configuration files. In the main menu, select File → Project Structure (or use hotkeys Ctrl+Alt+Shift+S).
In the window that opens, go to the section Modules in the left panel. A list of all modules connected to the project is displayed here. Select the one you plan to delete. A button with a minus symbol will appear at the top of the window. Press it initiates the deletion process. -. Clicking on it initiates the removal process.
The system will ask for confirmation of the action. After approval Android Studio it will automatically delete the module entry from the file settings.gradle and will remove the module folder from the project structure. However, physically deleting files from disk may require additional steps if the development environment decides to leave them in the cache.
If the delete button is grayed out, make sure that the module is not the main application module. The main module is usually marked with a green icon and cannot be deleted through the interface.
After completing the operation, the IDE will offer to synchronize the project with the Gradle files. Agree to sync immediately. This is a critical stage, since it is at this moment that the internal project graph is rebuilt and search indexes are updated.
Manual cleaning of configuration files
Sometimes automatic deletion through the interface does not work correctly, especially in older versions Android Studio or when the cache is damaged. In such cases, you must manually edit the file settings.gradlelocated in the root directory of the project.
Open this file in any text editor. Find the block includewhere all modules are listed. The line with the name of the module to be removed must be removed. The syntax usually looks like include ':app', ':library', ':deleted_module'. Make sure that after deleting the commas are placed correctly and there are no extra characters.
include ':app'
include ':feature-login'
// include ':old-experimental-module' - commented out line
include ':core-utils'
In addition to the settings file, check the root file build.gradle. In some architectures, version variables or special configurations specific to the module being removed may be written there. Their presence after removing the module itself will generate warnings about unused variables.
| Configuration file | What to check | Possible error |
|---|---|---|
settings.gradle |
List include |
Module not found |
build.gradle (root) |
Version variables | Unused variable warning |
local.properties |
SDK paths | SDK location not found |
gradle.properties |
Build flags | Unknown property |
If you are using the navigation system Jetpack Navigation, check the navigation graph. Links to screens that were in the remote module will become broken. They must be removed from the navigation XML files, otherwise the application will not compile.
Clearing the cache and resynchronizing
Even after deleting all links and files, Android Studio may continue to “see” the deleted module due to cached data. IDE indexes store information about the project structure to speed up searching and refactoring, and they are not always updated instantly.
To force a cleanup, run the command Invalidate Caches / Restart. It is in the menu File. In the dialog box that appears, check the boxes to clear the cache and reboot. This action will close the development environment and restart it with clean indexes.
⚠️ Attention: The indexing process after clearing the cache may take several minutes, especially in large projects. Do not interrupt it, otherwise the files may not be displayed correctly.
After restarting, open the panel Build and run the task Clean Project, and then Rebuild Project. This ensures that all intermediate compilation files (classes .class, resources .aar) will be generated anew without taking into account the removed module.
If errors related to a missing class or resource appear in the build log (tab Build at the bottom of the screen), This means there is a hidden link somewhere. Use the global project search (Ctrl+Shift+F) by entering the name of the removed module to find remaining references.
Solving common synchronization errors
The most common problem after deletion is an error "Module with the Main dispatcher had failed to initialize" or messages that the project cannot find the module. This occurs when Gradle attempts to resolve dependencies before the files have been fully updated.
Check the file gradle/wrapper/gradle-wrapper.properties. Sometimes the Gradle Wrapper version is not compatible with the current project configuration after changes. Updating the wrapper version to the current one can solve problems with path resolution.
What to do if Android Studio is stuck on synchronization?
If the synchronization process lasts more than 10 minutes, try stopping it with the Stop button. Then delete the .idea folder in the project root and the .gradle folder. After that, open the project again - the IDE will recreate the configuration from scratch.
It is also worth paying attention to the plugins. Some third-party extensions for Android Studio may cache information about modules separately from the main system. Disable suspicious plugins in the settings and check if the error has disappeared.
In difficult cases, deleting the folder .gradle in the user's home directory (not in the project, but in the system) helps. Global dependency caches are stored there. Cleaning them will force the system to download the libraries again, which will eliminate the possibility of using damaged artifacts.
Removing modules in a multi-project assembly
If your project is part of a larger ecosystem or is connected as a submodule to another application, the removal process becomes more complicated. You need to consider how changes will affect the parent project. Synchronization must take place consistently in all related repositories.
In the file settings.gradle of the parent project, paths to the module to be deleted can be specified through relative links. Make sure these paths don't lead anywhere. An error in the path can block the entire parent application from building, not just the current module.
Use a terminal command ./gradlew dependencies to visualize the dependency tree before deleting. This will show which external libraries are pulled by the module being removed. Perhaps some of them are used in other parts of the project, and they do not need to be removed from the general list of dependencies.
The main rule of a multi-project build: changes in the structure of modules must be committed and sent to the repository before other developers begin synchronizing their local copies.
When working in a team, be sure to notify your colleagues about changes in the project structure. Merge conflicts in files settings.gradle are one of the most painful, as they can completely disrupt the development environment for the entire team.
Frequently asked questions (FAQ)
Is it possible to restore a deleted module without a backup?
If you deleted the module via the IDE interface and did not synchronize immediately, try canceling the action via Ctrl+Z. If synchronization has already taken place, restoration is only possible through the version control system Git (command git revert or restoring files from history). Locally, files are deleted permanently if the OS recycle bin is not configured.
Why does the project not compile after deleting a module?
Most likely, imports of classes from the remote module remain in the code of the main application. The compiler does not find these classes and throws an error. Do a global search for the name of the package of the removed module and remove all relevant import lines. import com.example.module....
Does Android Studio delete the module folder from the hard drive?
When using the uninstall function Project Structure the development environment usually deletes the module directory. However, if you deleted the module only from the file settings.gradle manually, the folder with the files will remain on the disk. It must be removed manually through the file manager.
How to remove a module if the button in the settings is inactive?
This means that the module is critical to the current configuration or is the root one. In this case, open the file in a text editor, delete the line manually, save the file and restart. Then delete the module folder manually. settings.gradle in a text editor, delete the line include ':module_name' manually, save the file and restart Android Studio. Then delete the module folder manually.