**Warning:** Google Play Instant will no longer be available. Starting December 2025,
Instant Apps cannot be published through Google Play, and all
[Google Play services Instant APIs](https://developers.google.com/android/reference/com/google/android/gms/instantapps/package-summary)
will no longer work. Users will no longer be served Instant Apps by Play using any
mechanism.

We're making this change based on developer feedback and our continuous investments
to improve the ecosystem since the introduction of Google Play Instant.

To continue optimizing for user growth, we encourage developers to refer users to
their regular app or game, using [deeplinks](https://support.google.com/googleplay/android-developer/answer/12463044)
to redirect them to specific journeys or features when relevant.
| **Note:** From June 2023 on, only instant apps published using app bundles are available to users. Please ensure all APK based instant apps have been updated to instant enabled bundles.

If you're still using the deprecated Feature Android Gradle plugin
(`com.android.feature`) for your Android Instant App modules, you need to
migrate to using the base app plugin (`com.android.application`) and
Dynamic Feature plugin (`com.android.dynamic-feature`).

On Android Gradle plugin 3.3.0 and higher, the base app plugin includes support
for instant experiences. That is, if the base app module satisfies the
requirements for being an instant experience, you get the benefit automatically.
You can then include additional features that users can download on demand as
instant experiences using the Dynamic Feature plugin. This setup makes it
easier to support both an installed and instant app experience from a single
project, and allows you to benefit from publishing with
[Android App Bundles](https://developer.android.com/guide/app-bundle).

The following table better describes which plugins you will migrate to:

| Description of module | Old plugin | Current plugin |
|---|---|---|
| The module that includes the basic code, resources, and functionality for your installed or instant app experience. | `com.android.feature` (with `baseFeature = true`) | `com.android.application` **Note:** This module includes all the manifest and signing information required to build and package your app as an Android App Bundle or APK. |
| Additional, modular features that users can download on demand | `com.android.feature` | `com.android.dynamic-feature` (with `dist:instant="true"` and `dist:onDemand="false"` in the module's manifest) |
| Code and resource for a feature available only to the installed version of your app. | `com.android.application` | `com.android.dynamic-feature` (with `dist:instant="false"` and `dist:onDemand="false"` in the module's manifest) |

This page shows you how to migrate your existing instant app project to build an
instant-enabled Android App Bundle. It also describes how to build, test, and
publish an instant-enabled Android App Bundle.

If you are creating new instant experiences for your app, instead read
[Create an instant-enabled feature module](https://developer.android.com/studio/projects/dynamic-delivery#create_instant_enabled).

## Understand the changes

When you migrate your project to instead use the Dynamic Feature plugin,
[Android App Bundles](https://developer.android.com/guide/app-bundle) provide a new way to build and publish
your app that substantially simplifies distributing optimized APKs to your
users.

App bundles simplifies distribution by packaging all your app's compiled code
and resources for upload, but defers APK generation and signing to Google Play.
Google Play's new app serving model then uses your
app bundle to generate and serve optimized APKs for each user's device
configuration, so they download only the code and resources they need to run
your app. You no longer have to build, sign, and manage multiple APKs to support
different devices, and users get smaller, more optimized downloads.

When using the now-deprecated feature plugin, building an instant app required
creating a base feature module, which contained the shared code and resources
for all your modules, including your instant app module. The rest of your code
was included in multiple non-base feature modules, which contained entry points
for your instant experiences. For the installed version of your app, your
project might have included a separate app module, which contained the code and
activities required only for your installed app.

When you migrate your app to support Android App Bundles, your app module
reclaims the role of the base module, and you organize additional installed or
instant experiences as feature modules. That is, your project now more
closely resembles a standard app project, with an instant-enabled base module
and the ability to include additional, modular instant experiences.

To migrate your existing instant app project and adopt Android App Bundle's
more optimized distribution model, follow the steps described in the sections
below.

## Convert the base feature module into an app module

You first need to edit the base feature module's `build.gradle` file before
converting it into the main app module, as follows:

1. Delete the `baseFeature true` line.
2. Remove any dependencies that use the `feature` or `application` dependency
   configurations.

   ### Groovy

   ```groovy
   dependencies {
       ...
       // delete any lines that look like
       // feature project(":foo")
       // feature project(":bar")
       // application project(":app")
   }
   ```

   ### Kotlin

   ```kotlin
   dependencies {
       ...
       // delete any lines that look like
       // feature(project(":foo"))
       // feature(project(":bar"))
       // application(project(":app"))
   }
   ```
3. Move the `applicationId`, along with any other build script configurations you
   would expect to be in your base app module, from the current
   `com.android.application` module to the `com.android.feature` module. Some
   examples are shown below. For this step, depending on your specific
   `build.gradle` setup, it might be easier to copy and paste the `android`
   block of the `build.gradle` from the previous app module into the new app
   module's `build.gradle` file. However, you should exercise caution when doing
   so.

   ### Groovy

   ```groovy
   android {
       ...
       defaultConfig {
           // You need to move the application ID from the app module
           // to your feature module.
           applicationId "com.example.myapp"
           ...
       }
       // Some additional build configurations you might want to
       // copy from your current 'app' module may include ProGuard
       // rules and code shrinking settings.
       buildTypes {
           release {
               minifyEnabled true
               proguardFiles getDefaultProguardFile(
                 'proguard-android-optimize.txt'),
                 'proguard-rules.pro'
           }
       }
   }
   ```

   ### Kotlin

   ```kotlin
   android {
       ...
       defaultConfig {
           // You need to move the application ID from the app module
           // to your feature module.
           applicationId = "com.example.myapp"
           ...
       }
       // Some additional build configurations you might want to
       // copy from your current 'app' module may include ProGuard
       // rules and code shrinking settings.
       buildTypes {
           getByName("release") {
               minifyEnabled = true
               proguardFiles(
                   getDefaultProguardFile("proguard-android-optimize.txt"),
                   "proguard-rules.pro"
               )
           }
       }
   }
   ```
4. Mark the feature module as instant-enabled by adding the appropriate bundle
   distribution tags to the manifest, as shown below.

       <manifest ... xmlns:dist="http://schemas.android.com/apk/distribution">
           <dist:module dist:instant="true" />
           ...
       </manifest>

5. Convert the feature module to your base app module by changing its plugin
   type to `com.android.application`:

   ### Groovy

   ```groovy
   // Replace  "plugins { id 'com.android.feature' }"
   // with the following
   plugins {
     id 'com.android.application'
   }
   ```

   ### Kotlin

   ```kotlin
   // Replace  "plugins { id("com.android.feature") }"
   // with the following
   plugins {
       id("com.android.application")
   }
   ```

## Convert the old app module into an install-time feature module

If you have no code or resources in the old app module, you can simply
delete it---because the steps you followed in the previous section converted your
feature module into your app's base app module.

However, if you have code and resources in the old app module that represent
functionality you'd like to be available to users when they install your app,
follow the steps in this section to convert the app module to a feature module.

Creating a feature module involves changing the plugin type from
`com.android.application` to `com.android.dynamic-feature`, along with a few
other `build.gradle` changes, as follows:

1. Change the plugin type from `com.android.application` to
   `com.android.dynamic-feature`.

   ### Groovy

   ```groovy
   // Replace "plugins { id 'com.android.feature' }"
   // with the following:
   plugins {
     id 'com.android.dynamic-feature'
   }
   ```

   ### Kotlin

   ```kotlin
   // Replace "plugins { id("com.android.application") }"
   // with the following:
   plugins {
       id("com.android.dynamic-feature")
   }
   ```
2. As described in the previous section, make sure you've moved build
   configurations that are required by the `com.android.application` plugin to the
   base app module, such as `applicationId` or `proguardFiles` rules.

3. Rename the module to something like "installed_feature" as follows:

   1. Open the **Project** pane by selecting **View \> Tool Windows \> Project** from the menu bar.
   2. Right-click on the feature module and select **Refactor \> Rename**.
   3. In the dialog that appears, select **Rename module** and click **OK**.
   4. Enter the new name for the module and click **OK**.
4. Similar to step 3, rename the new app module you created in the previous
   section to something like "app".

5. Add an implementation dependency on the "app" module in the feature
   module's `build.gradle` file, as shown below.

   ### Groovy

   ```groovy
   dependencies {
       ...
       // In the feature module, add an implementation dependency
       // on the base app module.
       implementation project(":app")
   }
   ```

   ### Kotlin

   ```kotlin
   dependencies {
       ...
       // In the feature module, add an implementation dependency
       // on the base app module.
       implementation(project(":app"))
   }
   ```
6. Add the feature to the new app module's `build.gradle` file.

   ### Groovy

   ```groovy
   android {
       ...
       // In the base app module, specify each feature module.
       dynamicFeatures = [":installed_feature"]
   }
   ```

   ### Kotlin

   ```kotlin
   android {
       ...
       // In the base app module, specify each feature module.
       dynamicFeatures.addAll(listOf(":installed_feature"))
   }
   ```
7. In the feature module's manifest, mark the feature module as
   an installable module by adding the appropriate bundle distribution tags to the
   manifest.

       <manifest ... xmlns:dist="http://schemas.android.com/apk/distribution">
           <dist:module dist:instant="false" dist:onDemand="false"
                   dist:title="@string/title_dynamic_feature">
               <dist:fusing dist:include="true" />
           </dist:module>
           ...
       </manifest>

## Convert other feature modules into instant-enabled feature modules

If you've modularized additional functionality of your app into multiple Feature
modules, you need to follow the steps in this section to convert those modules
into instant-enabled feature modules.

For each remaining feature module in your project, proceed as follows to convert
them into instant-enabled features:

1. Change the plugin type in the `build.gradle` file to
   `com.android.dynamic-feature`, as shown below:

   ### Groovy

   ```groovy
   // Replace 'com.android.feature' with 'com.android.dynamic-feature'
   plugins {
     id 'com.android.dynamic-feature'
   }
   ```

   ### Kotlin

   ```kotlin
   // Replace "com.android.feature" with "com.android.dynamic-feature"
   plugins {
       id("com.android.dynamic-feature")
   }
   ```
2. Mark each feature module as instant-enabled by adding the following
   to the manifest.

       <manifest ... xmlns:dist="http://schemas.android.com/apk/distribution">
           <dist:module dist:instant="true" dist:onDemand="false"
                   dist:title="@string/title_dynamic_feature">
               <dist:fusing dist:include="true" />
           </dist:module>
           ...
       </manifest>

3. Add the feature module to the new application module's `build.gradle` file
   where you added the `installed_feature` to the list of feature modules.

   ### Groovy

   ```groovy
   android {
      ...
      dynamicFeatures = [":installed_feature", ":feature_1", ":feature_2"]
      // or whichever name exists for the instant enabled feature module
   }
   ```

   ### Kotlin

   ```kotlin
   android {
      ...
      dynamicFeatures.addAll(listOf(":installed_feature", ":feature_1", ":feature_2"))
      // or whichever name exists for the instant enabled feature module
   }
   ```

## Build, test, and publish new instant-enabled app bundle

After completing the steps on this page, your project is able to produce a
single artifact, an Android App Bundle, that you can use to publish both the
installed and instant version of your app to the Google Play Console, and roll
out separately for the instant and installed tracks. Additionally with app
bundles, you get the benefit of serving optimized APKs
for each user's device configuration, so they download only the code and
resources they need to run your app. That is, you no longer have to build, sign,
and manage multiple APKs to support different devices, and users get smaller,
more optimized downloads.

To start building and testing your instant-enabled app bundle, go to
[Build the app bundle](https://developer.android.com/topic/google-play-instant/getting-started/instant-enabled-app-bundle#build).