How to change the name of an application in Android Studio

Developing a mobile product on the Android platform requires careful attention to detail, and one of the first steps is the correct identification of your creation. Often, novice developers are faced with a situation where a test application created in Android Studio has a standard name like “My Application”, which needs to be replaced with a unique and commercially attractive name. This process affects several levels of project configuration, since the name visible to the user on the desktop and the internal package identifier are different entities that require a separate editing approach.

Changing the display name (App Name) affects only how the app is labeled under the icon in the smartphone menu, and does not require a complete rebuild of the project structure or changing Java class packages. However, for a full release in Google Play or other stores, you may need to change the Application ID, which is a more complex procedure related to the uniqueness of the application in the ecosystem. In this article, we will look in detail at safe renaming methods, eliminating the risk of breaking the assembly or signature conflicts.

The difference between the application name and the package identifier

Before making any changes to the code, it is critical to understand the architectural difference between the human name of the app and its technical address in the system. App Name is a resource string that is displayed to the user under the icon on the main screen of the device. You can change it an infinite number of times, and this will not in any way affect the updates of already installed versions of your clients, since the system identifies the application differently.

On the other hand, Application ID (often coinciding with the package name at the file system level) acts as a unique digital fingerprint. It is by this parameter that the operating system Android determines whether the APK file being installed is an update to an existing app or a completely new product. If you change the Application ID, the application store and devices will consider it a completely different software, which will make it impossible to update the user database.

⚠️ Attention: Never change the Application ID in an already published project if your goal is simply to correct a typo in the name on the screen. This will lead to loss of connection with previous versions and user reviews in the Google Play Console.

For local development or creating a fork of an existing project, changing the identifier is acceptable and even necessary to avoid version conflicts when debugging on the same device. For the purposes of this tutorial, we'll focus primarily on changing the visible name, since this is the most common request, but we'll also touch on the nuances of working with Gradle configuration files.

Editing the strings.xml file to change the display name

The most correct and standard way to change what the user sees is to work with resource files. In the Android project structure, all text strings are placed in a separate file, which makes it easy to localize the application and change names without interfering with the app code. You need to open the directory app/src/main/res/values and find the file named strings.xml.

Inside this XML document there is a tag <string> with an attribute name="app_name". It is the value enclosed between the opening and closing tags that is the very name that is written in the manifest and displayed on the screen. It is enough to replace the text inside the tag with the desired name, following the encoding rules and avoiding special characters that may be displayed incorrectly on some devices.

<resources>
My New Application
Settings
</resources>

After saving file Android Studio automatically prompts you to synchronize the project. If this does not happen, make sure that in the file AndroidManifest.xml attribute android:label for the tag <application> there is a link to the resource @string/app_nameand not a hard-coded string. This approach ensures that when changing the system language or adding new locales, the name will be pulled up correctly from the corresponding resource files.

Setting the Application ID in the file build.gradle

If your task goes beyond simply changing the sign and requires changing the technical identifier, for example when cloning a project to create a white label or test version, you will need to edit the build script. Open the file build.gradle (app module level), which is usually located at the path app/build.gradle. In modern versions Android Studio using Kotlin DSL, this file may have the extension .kts.

Inside the block defaultConfig you need to find the parameter applicationId. Changing the value of this variable will cause the compiled APK file to be registered on the system under a new package name. This action will break the connection with previous builds, so perform it only at the beginning of developing a new branch of the project or when creating a completely new application from scratch.

Parameter	Where is	Impact on the user	Impact on update
app_name	strings.xml	The name under the icon changes	Update works correctly
applicationId	build.gradle	Not visible to the user	Update becomes impossible
packageName	Manifest / Java	Internal code structure	Requires refactoring imports

It is important to note that in older versions of the development environment the parameter packageName in the manifest file and applicationId in Gradle could be tightly coupled, but now they are separated. It is recommended to always set unique applicationId in Gradle using reverse domain notation (for example com.company.projectname) to ensure that your product is globally unique in the app store.

Refactoring of Java package structure and Kotlin

Often users confuse changing the application name with renaming the physical structure of the source code folders. If you created a project with the name com.example.oldname and want to bring the structure to the form com.example.newname, simply renaming the folders in Explorer will not be enough - this will break links to classes and resources. To safely change the package structure, you must use the built-in refactoring tools Android Studio.

Select the root folder of the package in the project window (Project Files mode), right-click and select Refactor → Rename. The development environment will offer several options: rename only the directory or update all references in the code. Select the option that updates packages (Rename package) so that the system will automatically go through all files .java or .kt and change declarations package at the beginning of the files.

⚠️ Attention: After refactoring packages, be sure to check the file AndroidManifest.xml. Sometimes an attribute package at the root of the manifest is not updated automatically and remains old, which can lead to compilation errors or incorrect R class generation.

This process may take some time depending on the size of the project, as the IDE indexes all dependencies. If your project uses third-party libraries that are tightly bound to the old package name (which is rare, but possible in legacy code), you will have to manually adjust the imports. Always make a backup copy of the project or commit to Git version control before starting a bulk refactoring.

What to do if the refactoring did not work?

If the automatic renaming failed, try deleting the .idea and .gradle folder in the project root, then perform Invalidate Caches / Restart. This will force Android Studio to rebuild the indexes from scratch and correctly pick up the new package structure.

Clearing the cache and rebuilding the project

After making changes to configuration files and resources, the development environment may continue to display old names in the preview or emulator due to cached build data. To ensure that all changes are applied correctly, you must perform a complete cleanup of the project. This will remove all compiled classes and temporary files, forcing the system to rebuild the application with the new parameters.

In the top menu, select Build → Clean Project, wait for the process to complete, and then execute Build → Rebuild Project. In the console tab Build there should be no errors related to resources or manifest. If you are working with a connected device, it is recommended to completely remove the old application from the phone before launching the new version to avoid signature conflicts or residual data.

Sometimes, especially if you change Gradle settings frequently, the cache of the IDE itself can become corrupted. In such situations, the function File → Invalidate Caches / Restarthelps. This tool clears internal search indexes and interface component caches, which often solves mysterious problems where the code is correct but the studio behaves unpredictably. Do not neglect this step if the changes do not take effect immediately.

Checking the result on the emulator and the device

The final step is verification of the work done on real hardware or a virtual machine. Run the project on the emulator and carefully examine the main screen. The name under the icon must correspond to what you wrote in strings.xml. Also go to the phone settings, section Applications, and check how the app name is displayed there - sometimes system launchers cache shortcuts, and a manual screen refresh or reboot of the emulator is required.

For advanced checking, you can use the utility ADB (Android Debug Bridge). After connecting the device, run the command adb shell pm list packages | grep "your_package"to make sure that the system sees the application with the new ID. If you only changed the display name, the package should remain the same, which will confirm that the naming logic is separated correctly.

Note the upgrade behavior. Install the old version of the application (if you still have it), and then try installing the new build on top of it. If you changed applicationId, the installation will fail with a signature or identity conflict message, which is a normal Android security response. If only the name was changed, the update will be successful, saving all user data.

⚠️ Attention: Emulator interfaces and Android versions may differ. On some custom firmware (MIUI, OneUI), the launcher cache is more difficult to clear than in stock Android. If the name does not change, try long-pressing on the icon, deleting it and adding the application widget from the menu again.

Frequently asked questions (FAQ)

Is it possible to change the name of an application after publishing it on Google Play?

Yes, you can change the display name of the application (App Name) in the developer console in the "Basic Information" section (Store Listing). This change will be moderated and updated in the store. However, it is impossible to change the Application ID after publication - to do this you will have to create a new application from scratch.

Why does the application crash on startup after renaming?

Most likely, references to resources or classes were broken when refactoring the packages. Check the logs in Logcat, often the error lies in the fact that some Activity is not found in the new package, or an old link to the launch class remains in the manifest.

Does changing the name of an application affect its position in ASO search?

Yes, the name of the application is one of the key ranking factors in stores. Changing the name can make or break an app's visibility in search results, so new names should contain relevant keywords.

Do you need to change the package name in Java files when you change the app name?

No, if you only change what the user sees. You can leave any Java/Kotlin packages (within the naming rules), they do not affect the displayed name. Change them only if you need to change the Application ID.

How to rename a project in Android Studio itself (in the Project window)?

The project name in the window title and in the Project panel is not associated with the application name. To change it, close the project, rename the project folder in Explorer and reopen it, or edit the file .idea/name inside the project directory.