Generating images via Stable Diffusion, DALL·E 3, or Midjourney API – the bottleneck is not the algorithm but UX expectations and resource management. A cloud model request takes 5–30 seconds; on-device generation on mobile takes 10–60 seconds depending on model and device. Throughout that time, the user must understand what is happening. We have implemented similar mechanisms in dozens of projects and know how to avoid typical problems: from thermal throttling to content policy blocks. Contact us for a preliminary assessment of your project.
How to Integrate AI Image Generation into a Mobile App
Cloud Generation: DALL·E 3 and Stable Diffusion API
OpenAI Images API (POST /v1/images/generations) is the simplest path. The request returns an image URL or base64. Response time is 8–20 seconds for 1024×1024.
struct ImageGenerationRequest: Encodable { let model: String // "dall-e-3" let prompt: String let n: Int // 1 (dall-e-3 does not support > 1) let size: String // "1024x1024" let quality: String // "standard" or "hd" let responseFormat: String // "url" or "b64_json" enum CodingKeys: String, CodingKey { case model, prompt, n, size, quality case responseFormat = "response_format" } } Replicate API provides access to Stable Diffusion XL, FLUX, and other open-source models. It uses an async model: the first request returns a prediction ID, then you need polling or a webhook. On mobile client, polling every 2 seconds with exponential backoff on errors:
suspend fun pollPrediction(predictionId: String): String { var delay = 2000L repeat(15) { delay(delay) val result = api.getPrediction(predictionId) if (result.status == "succeeded") return result.output.first() if (result.status == "failed") throw GenerationException(result.error) delay = minOf(delay * 1.5, 8000L).toLong() } throw TimeoutException("Generation timed out") } On-device Generation via Core ML
Apple ML Research released Stable Diffusion for Apple Silicon. On iPhone 15 Pro / M-series iPad – about 20 seconds for 512×512, 20 steps. On iPhone 12 – 60–90 seconds. The model weighs 2–6 GB depending on quantization.
import StableDiffusion let pipeline = try StableDiffusionPipeline( resourcesAt: modelDirectory, controlNet: [], configuration: .init() ) pipeline.loadResources() var config = StableDiffusionPipeline.Configuration(prompt: userPrompt) config.stepCount = 20 config.guidanceScale = 7.5 config.seed = UInt32.random(in: 0...UInt32.max) let images = try pipeline.generateImages(configuration: config) { progress in DispatchQueue.main.async { self.generationProgress = Double(progress.step) / Double(progress.stepCount) } return true // continue generation } Thermal throttling is a real problem. After 3–4 consecutive generations, the iPhone drops performance. Solution: pause between generations, monitor ProcessInfo.thermalState, and warn the user.
On Android, on-device Stable Diffusion works via MediaPipe with LlmInferenceSession or directly through ONNX Runtime with GPU delegate. Support is significantly worse than on Apple Silicon – we recommend a cloud-first approach for Android.
What to Choose: Cloud or On-device Generation?
| Criteria | Cloud (DALL·E / Replicate) | On-device (Core ML) |
|---|---|---|
| Speed | 5–30 seconds | 20–90 seconds |
| Quality | 1024×1024, high detail | 512×512, lower detail |
| Privacy | data on server | local, private |
| Cost | pay per generation | free (CPU/GPU) |
| Offline | no | yes |
| Heat generation | no | yes, thermal throttling |
UX During Generation
A progress bar with a real value (not a spinner) is critical for long operations. Stable Diffusion returns progress.step – use it. Show intermediate previews (latent-preview) starting from step 5 – this keeps user attention.
Cancel generation: cloud request can be cancelled via URLSessionTask.cancel() or Replicate API POST /predictions/{id}/cancel. On-device – via a shouldContinue flag in the progress callback.
Save to gallery: PHPhotoLibrary.requestAuthorization(for: .addOnly) on iOS. WRITE_EXTERNAL_STORAGE permission (up to Android 9) or MediaStore.Images API. Request permission only at the moment of first save, not when opening the generation screen.
How to Manage Prompts and Avoid Content Policy Errors?
Content policy violations – DALL·E 3 rejects prompts with violence, NSFW, celebrity content. This requires prompt validation before submission (OpenAI Moderation API) and a clear error message. Do not show a system message “Your request was rejected” – explain what exactly is not allowed.
Device memory: on-device Stable Diffusion requires 4–6 GB RAM at peak. os_proc_available_memory() on iOS gives insight into available memory – if less than 1 GB is free, better to fall back to cloud.
Comparison of Integration Approaches
| Method | Integration Time | Complexity | Flexibility |
|---|---|---|---|
| DALL·E 3 API | 2-3 days | Low | High quality, but content policy restrictions |
| Replicate API | 3-4 days | Medium | Wide model selection, asynchronous |
| On-device Core ML | 1-2 weeks | High | Full privacy, but requires powerful device |
Work Process
Architecture selection → API integration → Generation UX → Error handling → Testing → Documentation. At each stage we provide intermediate results and agree on decisions with you. Order a turnkey integration and get a ready-made solution within agreed deadlines.
What Is Included in the Work
- Integration documentation (API specification, data schemas)
- Access to the code repository and CI/CD
- Training of the client's team (2–3 hours)
- Support during deployment to stores (App Store, Google Play)
- 3-month warranty on identified bugs
Timeline Estimates
Cloud generation with basic UI – 4–6 days. On-device Stable Diffusion with latent-preview and thermal management – 2–3 weeks. The exact estimate depends on the complexity of your project – contact us for a calculation.
Our team has 5+ years of experience in mobile development and has implemented more than 50 projects with AI generation. We guarantee quality at all stages – from prototype to production. Get a consultation today.