Image Generation

Generate images from text prompts using on-device Stable Diffusion. All processing happens locally on the device.

Basic Usage

Create an image generator and generate images from text prompts:

ImageGenerator.swift

import Kuzco
import SwiftUI
struct ImageGeneratorView: View {
    @State private var generatedImage: UIImage?
    @State private var isGenerating = false
    @State private var prompt = "A serene mountain landscape at sunset"
    var body: some View {
        VStack(spacing: 20) {
            if let image = generatedImage {
                Image(uiImage: image)
                    .resizable()
                    .scaledToFit()
                    .frame(maxHeight: 400)
                    .cornerRadius(12)
            }
            TextField("Enter prompt", text: $prompt)
                .textFieldStyle(.roundedBorder)
            Button(isGenerating ? "Generating..." : "Generate Image") {
                generateImage()
            }
            .disabled(isGenerating || prompt.isEmpty)
        }
        .padding()
    }
    func generateImage() {
        isGenerating = true
        Task {
            do {
                let generator = try await KuzcoImageGenerator(model: .stableDiffusion21)
                let image = try await generator.generate(prompt: prompt)
                generatedImage = image
            } catch {
                print("Generation failed: \(error)")
            }
            isGenerating = false
        }
    }
}

Customizing Dimensions

Specify custom width and height for generated images:

let generator = try await KuzcoImageGenerator(model: .stableDiffusion21)
// Square image (default)
let square = try await generator.generate(
    prompt: "A cute robot",
    width: 512,
    height: 512
)
// Landscape
let landscape = try await generator.generate(
    prompt: "A panoramic beach scene",
    width: 768,
    height: 512
)
// Portrait
let portrait = try await generator.generate(
    prompt: "A tall lighthouse",
    width: 512,
    height: 768
)

Dimension Guidelines

Dimensions should be multiples of 64. Larger images require more memory and generation time. Recommended maximum: 768x768 on most devices.

Inference Steps

Control image quality with inference steps. More steps produce higher quality but take longer:

// Quick preview (faster, lower quality)
let preview = try await generator.generate(
    prompt: "A fantasy castle",
    steps: 20
)
// Standard quality
let standard = try await generator.generate(
    prompt: "A fantasy castle",
    steps: 30
)
// High quality (slower)
let highQuality = try await generator.generate(
    prompt: "A fantasy castle",
    steps: 50
)

Progress Tracking

Track generation progress for better user experience:

ProgressTracking.swift

import SwiftUI
import Kuzco
struct ProgressImageView: View {
    @State private var progress: Double = 0
    @State private var generatedImage: UIImage?
    @State private var isGenerating = false
    var body: some View {
        VStack(spacing: 20) {
            if let image = generatedImage {
                Image(uiImage: image)
                    .resizable()
                    .scaledToFit()
            } else if isGenerating {
                VStack {
                    ProgressView(value: progress)
                        .progressViewStyle(.linear)
                    Text("\(Int(progress * 100))%")
                        .font(.caption)
                        .foregroundColor(.secondary)
                }
            }
            Button("Generate") {
                generate()
            }
            .disabled(isGenerating)
        }
        .padding()
    }
    func generate() {
        isGenerating = true
        progress = 0
        Task {
            do {
                let generator = try await KuzcoImageGenerator(model: .stableDiffusion21)
                for try await update in generator.generateWithProgress(
                    prompt: "A magical forest",
                    steps: 30
                ) {
                    progress = update.progress
                    if let image = update.image {
                        generatedImage = image
                    }
                }
            } catch {
                print("Error: \(error)")
            }
            isGenerating = false
        }
    }
}

Negative Prompts

Use negative prompts to exclude unwanted elements from generated images:

let image = try await generator.generate(
    prompt: "A professional portrait photo, high quality, detailed",
    negativePrompt: "blurry, low quality, distorted, deformed",
    width: 512,
    height: 512,
    steps: 30
)

Seed Control

Use seeds for reproducible image generation:

// Generate with a specific seed
let image1 = try await generator.generate(
    prompt: "A colorful abstract pattern",
    seed: 12345
)
// Same seed produces the same image
let image2 = try await generator.generate(
    prompt: "A colorful abstract pattern",
    seed: 12345
)
// image1 and image2 will be identical
// Random seed (default behavior)
let random1 = try await generator.generate(prompt: "A colorful abstract pattern")
let random2 = try await generator.generate(prompt: "A colorful abstract pattern")
// random1 and random2 will be different

Guidance Scale

Control how closely the image follows the prompt:

// Lower guidance = more creative interpretation
let creative = try await generator.generate(
    prompt: "A futuristic city",
    guidanceScale: 5.0
)
// Default guidance
let balanced = try await generator.generate(
    prompt: "A futuristic city",
    guidanceScale: 7.5
)
// Higher guidance = stricter prompt adherence
let strict = try await generator.generate(
    prompt: "A futuristic city",
    guidanceScale: 12.0
)

Prompt Tips

Be Specific

Include details about style, lighting, composition, and subject matter for better results.

"A golden retriever puppy playing in autumn leaves, soft afternoon light, shallow depth of field"

Use Style Keywords

Add artistic style references to guide the aesthetic.

"digital art", "oil painting", "watercolor", "photorealistic", "anime style"

Quality Modifiers

Add quality keywords to improve output.

"highly detailed", "sharp focus", "professional", "8k resolution"

Memory Considerations

Image generation requires significant memory. Handle memory warnings appropriately:

do {
    let generator = try await KuzcoImageGenerator(model: .stableDiffusion21)
    let image = try await generator.generate(prompt: "A landscape")
} catch KuzcoError.insufficientMemory {
    // Suggest closing other apps or using smaller dimensions
    print("Not enough memory. Try closing other apps or using smaller image size.")
} catch {
    print("Error: \(error)")
}

Text Generation Vision AI