> [!WARNING]
> **All Imagen models shut down on
> August 17, 2026.** As a replacement, you can follow this guide to migrate your apps to use Gemini Nano Banana models.

<br />

All Imagen models **shut down on
August 17, 2026** . This shutdown is applicable
across Google and for both the Gemini Developer API and
Agent Platform Gemini API (formerly Vertex AI).

To continue generating or editing images in your apps, migrate from using
Imagen models to using
[Gemini Nano Banana models](https://firebase.google.com/docs/ai-logic/generate-images-gemini.md.txt),
as described in this guide.

If you have an urgent issue involving this deprecation and shutdown,
[reach out to Firebase Support](https://firebase.google.com/support/troubleshooter/contact).

## Replacement Nano Banana models

The following table can help you choose a replacement
Nano Banana model for your app.

| Imagen model | Gemini Nano Banana models |
|---|---|
| `imagen-4.0-fast-generate-001` | `gemini-nano-banana-2.1` (with thinking level `MINIMAL`) |
| `imagen-4.0-generate-001` | `gemini-nano-banana-2.1` (with thinking level `HIGH`) |
| `imagen-4.0-ultra-generate-001` | `gemini-3-pro-image` |
| `imagen-3.0-capability-001` | `gemini-nano-banana-2.1` |

## Migrate your app

This section shows before and after examples for migrating from an
Imagen model to a Gemini Nano Banana model.

### Generate an image from text

|---|
| *Click your Gemini API provider to view provider-specific content and code on this page.* <button value="dev" default="">Gemini Developer API</button> <button value="vertex">Agent Platform Gemini API</button> |

To generate an image from text, migrate your app by making the following
changes:

- Use an appropriate
  [replacement Nano Banana model](https://firebase.google.com/docs/ai-logic/imagen-models-migration.md.txt#replacement-gemini-models)
  (such as `gemini-nano-banana-2.1`).

- Create a `GenerativeModel` instance (instead of an `ImagenModel` instance).

- Update the [model configuration options](https://firebase.google.com/docs/ai-logic/imagen-models-migration.md.txt#replacement-config) to accommodate
  Nano Banana models.

  - As part of this configuration, set a response modality of `IMAGE`.  
    Note that Nano Banana models can be configured to return both images *and* text.

### Swift

**Before**

```swift

import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create an `ImagenModel` instance with a model that supports your use case.
let model = ai.imagenModel(modelName: "IMAGEN_MODEL_NAME")

// Provide an image generation prompt.
let prompt = "An astronaut riding a horse"

// To generate an image, call `generateImages` with the text prompt.
let response = try await model.generateImages(prompt: prompt)

// Handle the generated image.
guard let image = response.images.first else {
  fatalError("No image in the response.")
}
let uiImage = UIImage(data: image.data)

```

**After**

```swift

import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a Gemini model that supports image output.
let model = ai.generativeModel(
  modelName: "GEMINI_NANOBANANA_MODEL_NAME",
  generationConfig: GenerationConfig(
    responseModalities: [.image],
    imageConfig: ImageConfig(aspectRatio: .landscape4x3)
  )
)

// Provide an image generation prompt.
let prompt = "An astronaut riding a horse"

// To generate an image, call `generateContent` with the text prompt.
let response = try await model.generateContent(prompt)

// Handle the case where no images were generated.
guard let inlineDataPart = response.inlineDataParts.first else {
  fatalError("No image in the response.")
}

// Process the image.
guard let uiImage = UIImage(data: inlineDataPart.data) else {
  fatalError("Failed to convert data to UIImage.")
}

```

### Kotlin

**Before**

```kotlin

// Initialize the Gemini Developer API backend service.
val ai = Firebase.ai(backend = GenerativeBackend.googleAI())

// Create an `ImagenModel` instance with an Imagen model that supports your use case.
val model = ai.imagenModel("IMAGEN_MODEL_NAME")

// Provide an image generation prompt.
val prompt = "An astronaut riding a horse"

// To generate an image, call `generateImages` with the text prompt.
val imageResponse = model.generateImages(prompt)

// Handle the generated image.
val image = imageResponse.images.first()

val bitmapImage = image.asBitmap()

```

**After**

```kotlin

// Initialize the Gemini Developer API backend service.
val ai = Firebase.ai(backend = GenerativeBackend.googleAI())

// Create a `GenerativeModel` instance with a Gemini model that supports image output.
val model = ai.generativeModel(
    modelName = "GEMINI_NANOBANANA_MODEL_NAME",
    generationConfig = generationConfig {
      responseModalities = listOf(ResponseModality.IMAGE),
      imageConfig = imageConfig {
        aspectRatio = AspectRatio.LANDSCAPE_4x3
      }
    }
)

// Provide an image generation prompt.
val prompt = "An astronaut riding a horse"

// To generate an image, call `generateContent` with the text prompt.
val imageResponse = model.generateContent(prompt)

if (imageResponse.finishReason == FinishReason.NO_IMAGE) {
  // Handle the case where no images were generated.
} else {
  // Handle the generated image.
  val bitmapImage = imageResponse.candidates.first().content.parts.filterIsInstance().firstOrNull()?.image
}

```

### Java

**Before**

```java

// Initialize the Gemini Developer API backend service.
// Create an `ImagenModel` instance with an Imagen model that supports your use case.
ImagenModel imagenModel = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .imagenModel(
                /* modelName */ "IMAGEN_MODEL_NAME");

ImagenModelFutures model = ImagenModelFutures.from(imagenModel);

// Provide an image generation prompt.
String prompt = "An astronaut riding a horse";

// To generate an image, call `generateImages` with the text prompt.
Futures.addCallback(model.generateImages(prompt), new FutureCallback<ImagenGenerationResponse>() {
    @Override
    public void onSuccess(ImagenGenerationResponse result) {
        if (result.getImages().isEmpty()) {
            Log.d("TAG", "No images generated");
        }
        Bitmap bitmap = result.getImages().get(0).asBitmap();
        // Use the bitmap to display the image in your UI.
    }

    @Override
    public void onFailure(Throwable t) {
        // ...
    }
}, Executors.newSingleThreadExecutor());

```

**After**

```java

// Initialize the Gemini Developer API backend service.
// Create a `GenerativeModel` instance with a Gemini model that supports image output.
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI()).generativeModel(
    "GEMINI_NANOBANANA_MODEL_NAME",
    new GenerationConfig.Builder()
        .setResponseModalities(Arrays.asList(ResponseModality.IMAGE))
        .setImageConfig(new ImageConfig(AspectRatio.LANDSCAPE_4x3, null))
        .build()
);

GenerativeModelFutures model = GenerativeModelFutures.from(ai);

// Provide a text prompt instructing the model to generate an image.
Content prompt = new Content.Builder()
        .addText("An astronaut riding a horse")
        .build();

// To generate an image, call `generateContent` with the text input.
Executor executor = Executors.newSingleThreadExecutor();
ListenableFuture response = model.generateContent(prompt);
Futures.addCallback(response, new FutureCallback() {
    @Override
    public void onSuccess(GenerateContentResponse result) {
        if (result.finishReason == FinishReason.NO_IMAGE) {
            // handle the case where no images were generated
            return;
        }
        // iterate over all the parts in the first candidate in the result object.
        for (Part part : result.getCandidates().get(0).getContent().getParts()) {
            if (part instanceof ImagePart) {
                ImagePart imagePart = (ImagePart) part;
                // The returned image as a bitmap
                Bitmap generatedImageAsBitmap = imagePart.getImage();
                break;
            }
        }
    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
    }
}, executor);

```

### Web

**Before**

```javascript

import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, getImagenModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer): Replace the following with your app's Firebase configuration
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create an `ImagenModel` instance with an Imagen model that supports your use case.
const model = getImagenModel(ai, { model: "IMAGEN_MODEL_NAME" });

// Provide an image generation prompt.
const prompt = "An astronaut riding a horse.";

// To generate an image, call `generateImages` with the text prompt.
const response = await model.generateImages(prompt)

// If fewer images were generated than were requested,
// then `filteredReason` will describe the reason they were filtered out.
if (response.filteredReason) {
  console.log(response.filteredReason);
}

if (response.images.length == 0) {
  throw new Error("No images in the response.")
}

const image = response.images[0];

```

**After**

```javascript

import { initializeApp } from "firebase/app";
import {
  getAI,
  getGenerativeModel,
  GoogleAIBackend,
  ResponseModality,
  ImageConfigAspectRatio,
  FinishReason
} from "firebase/ai";

// TODO(developer): Replace the following with your app's Firebase configuration
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service.
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case.
const model = getGenerativeModel(ai, {
  model: "GEMINI_NANOBANANA_MODEL_NAME",
  generationConfig: {
    responseModalities: [ResponseModality.IMAGE],
    imageConfig: {
      aspectRatio: ImageConfigAspectRatio.LANDSCAPE_4x3
    }
  },
});

// Provide an image generation prompt.
const prompt = "An astronaut riding a horse.";

// To generate an image, call `generateContent` with the text prompt.
const result = await model.generateContent(prompt);

// Handle the generated image.
try {
  const response = result.response;
  if (response.candidates?.[0].finishReason == FinishReason.NO_IMAGE) {
    // Handle the case where no images were generated.
  }
  const inlineDataParts = response.inlineDataParts();
  if (inlineDataParts?.[0]) {
    const image = inlineDataParts[0].inlineData;
    // Use this mimeType and base64 data to display the image using your preferred tooling.
    console.log(image.mimeType, image.data);
  }
} catch (err) {
  console.error('Prompt or candidate was blocked:', err);
}

```

### Dart

**Before**

```dart

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service.
final ai = FirebaseAI.googleAI();

// Create an `ImagenModel` instance with an Imagen model that supports your use case.
final model = ai.imagenModel(model: 'IMAGEN_MODEL_NAME');

// Provide an image generation prompt.
const prompt = 'An astronaut riding a horse.';

// To generate an image, call `generateImages` with the text prompt.
final response = await model.generateImages(prompt);

if (response.images.isNotEmpty) {
  final image = response.images[0];
  // Process the image.
} else {
  // Handle the case where no images were generated.
  print('Error: No images were generated.');
}

```

**After**

```dart

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service.
final ai = FirebaseAI.googleAI();

// Create a `GenerativeModel` instance with a Gemini model that supports image output.
final model = ai.generativeModel(
  model: 'GEMINI_NANOBANANA_MODEL_NAME',
  generationConfig: GenerationConfig(
    responseModalities: [ResponseModalities.image],
    imageConfig: ImageConfig(aspectRatio: ImageAspectRatio.landscape4x3)
  ),
);

// Provide a text prompt instructing the model to generate an image.
final prompt = [Content.text('An astronaut riding a horse.')];

// To generate an image, call `generateContent` with the text prompt.
final response = await model.generateContent(prompt);
if (response.inlineDataParts.isNotEmpty) {
  final imageBytes = response.inlineDataParts.first.bytes;
  // Process the image.
} else {
  // Handle the case where no images were generated.
  print('Error: No images were generated.');
}

```

### Unity

**Before**

```c#

using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create an `ImagenModel` instance with a model that supports your use case
var model = ai.GetImagenModel(modelName: "IMAGEN_MODEL_NAME");

// Provide an image generation prompt
var prompt = "An astronaut riding a horse";

// To generate an image, call `generateImages` with the text prompt
var response = await model.GenerateImagesAsync(prompt: prompt);

// Handle the generated image
if (response.Images.Count == 0) {
  throw new Exception("No image in the response.");
}
var image = response.Images[0].AsTexture2D();

```

**After**

```c#

using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service.
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a Gemini model that supports image output.
var model = ai.GetGenerativeModel(
  modelName: "GEMINI_NANOBANANA_MODEL_NAME",
  generationConfig: new GenerationConfig(
    responseModalities: new[] { ResponseModality.Image },
    imageConfig: new ImageConfig(aspectRatio: ImageConfig.AspectRatio.Landscape4x3)
  )
);

// Provide an image generation prompt.
var prompt = "An astronaut riding a horse";

// To generate an image, call `GenerateContentAsync` with the text prompt.
var response = await model.GenerateContentAsync(prompt);

if (response.Candidates.First().FinishReason == FinishReason.NoImage) {
  // Handle the case where no images were generated.
}

// Handle the generated image.
var imageParts = response.Candidates.First().Content.Parts
                         .OfType<ModelContent.InlineDataPart>()
                         .Where(part => part.MimeType == "image/png");

foreach (var imagePart in imageParts) {
  // Load the Image into a Unity Texture2D object.
  UnityEngine.Texture2D texture2D = new(2, 2);
  if (texture2D.LoadImage(imagePart.Data.ToArray())) {
    // Do something with the image.
  }
}

```

## Replacement configuration options

This section describes replacement options for various model configuration
options to help control the response of the model.

### Safety settings

You configure the safety settings for Imagen models using
`ImagenSafetySettings`. However, for Nano Banana models,
you need to migrate to using
[`SafetySetting`](https://firebase.google.com/docs/ai-logic/safety-settings.md.txt#gemini).

### Model configuration parameters

You configure Imagen models with an `ImagenGenerationConfig`. However,
for Nano Banana models, you need to migrate to using a
`GenerationConfig` and optionally a nested
[`ImageConfig`](https://firebase.google.com/docs/ai-logic/generate-images-gemini.md.txt#configure-image-generation)
(this is available starting with the early May 2026 versions of the SDKs).

As part of the `GenerationConfig`, set a response modality of `IMAGE` (as shown
in the "after" code samples earlier in this guide). Note that you can optionally
configure Nano Banana models to return both
`IMAGE` *and* `TEXT`.

The following table can help you understand how to migrate your model
configuration parameters from Imagen to
Nano Banana models:

| Imagen models | Gemini Nano Banana models |
|---|---|
| `addWatermark` | Not supported Nano Banana models always return generated images with a SynthID watermark. |
| `aspectRatio` | Use `aspectRatio` in an `ImageConfig` For code samples and supported values, see [Configure image generation](https://firebase.google.com/docs/ai-logic/generate-images-gemini.md.txt#configure-image-generation) in the Nano Banana models guide. |
| `imageFormat` | Not supported Nano Banana models always return generated images in PNG format. |
| `negativePrompt` | Not supported Note that negative prompts are a legacy feature, and they haven't been supported since `imagen-3.0-generate-002` (or by any of the Imagen 4 models). |
| `numberOfImages` | Not supported Nano Banana models always return a single generated image. As a workaround, you can run your generation in a loop to achieve the same result. Note that candidate count doesn't work as a replacement. |
| `personGeneration` | Not supported By default, Nano Banana models allow generating images of people. |