Apple Intelligence y Foundation Models en SwiftUI

La llegada de Apple Intelligence en iOS 18, iPadOS 18 y macOS Sequoia marca el inicio de una nueva era para el desarrollo de software dentro del ecosistema de Cupertino. Lejos de ser un simple chatbot integrado en el sistema operativo, Apple ha diseñado una arquitectura profunda que combina modelos de lenguaje y difusión ejecutados directamente en el dispositivo (on-device) con una infraestructura segura en la nube (Private Cloud Compute).

Para los desarrolladores de iOS, esto representa una oportunidad sin precedentes: acceder a capacidades avanzadas de inteligencia artificial generativa, comprensión del lenguaje natural y procesamiento contextual sin incurrir en costes de servidores externos ni comprometer la privacidad del usuario.

En este artículo, exploraremos qué son realmente los Foundation Models de Apple y cómo puedes comenzar a integrar estas herramientas en tus aplicaciones utilizando SwiftUI y las nuevas APIs del sistema.

¿Qué es Apple Intelligence y qué ofrece a los desarrolladores?

Apple Intelligence no se presenta como una API REST tradicional ni como un clon de OpenAI. En su lugar, Apple ha integrado sus modelos fundacionales directamente en la pila del sistema operativo. Esto significa que las aplicaciones pueden interactuar con la IA de cuatro formas principales:

APIs del Sistema Nativas: Herramientas preconstruidas como Writing Tools (Herramientas de escritura) e Image Playground.
App Intents Mejorados: La vía principal para que Siri y el sistema comprendan las acciones y datos de tu aplicación con soporte semántico profundo.
APIs de Visión y Lenguaje Actualizadas: Mejoras drásticas en Core ML, Vision Framework y Natural Language, ahora optimizadas para la arquitectura Apple Silicon.
Framework Foundation Models (iOS 26): Acceso directo desde Swift al modelo de lenguaje que se ejecuta en el dispositivo.

El gran beneficio de esta arquitectura es la privacidad por diseño. Los modelos fundamentales pequeños (aproximadamente 3 mil millones de parámetros) se ejecutan localmente en el Neural Engine, garantizando baja latencia y funcionamiento sin conexión a internet.

Requisitos previos y entorno de desarrollo

Antes de escribir la primera línea de código, asegúrate de contar con el entorno adecuado:

Xcode 16 o superior para Writing Tools, Image Playground y App Intents (iOS 18).
Xcode 26 e iOS 26 (o macOS Tahoe 26) si quieres usar el framework Foundation Models.
macOS Sequoia 15 o superior.
Dispositivo de prueba compatible: iPhone 15 Pro/Pro Max, cualquier iPhone 16 o posterior o cualquier Mac o iPad con procesador Apple Silicon (M1 en adelante).
Conocimientos sólidos de Swift 6 y concurrencia moderna (async/await).

Integrando Herramientas de Escritura (Writing Tools) en SwiftUI

La forma más inmediata de aprovechar Apple Intelligence sin reescribir la lógica de tu negocio es a través de Writing Tools. Esta función permite a los usuarios reescribir, resumir, corregir el tono o revisar textos dentro de cualquier campo editable.

En SwiftUI, si utilizas los componentes nativos estándar, la integración es prácticamente automática, pero puedes personalizar su comportamiento.

import SwiftUI

struct NotesEditorView: View {
    @State private var textContent: String = ""

    var body: some View {
        NavigationStack {
            VStack {
                TextEditor(text: $textContent)
                    .padding()
                    // Configuración específica de Writing Tools en iOS 18
                    .writingToolsBehavior(.complete) 
            }
            .navigationTitle("Mi Nota Inteligente")
        }
    }
}

Modificadores de comportamiento de Writing Tools

Puedes ajustar cómo interactúa tu vista con la IA utilizando .writingToolsBehavior():

.automatic: El sistema decide el comportamiento más adecuado para la vista (es el valor por defecto).
.complete: Activa la experiencia completa, con reescrituras y correcciones aplicadas directamente sobre el texto.
.limited: Muestra los resultados en un panel superpuesto sin modificar el texto en línea, útil en campos donde el formato es crítico.
.disabled: Desactiva por completo la intervención de la IA en campos sensibles.

El corazón de la integración: App Intents y comprensión semántica

Para que los modelos de Apple interactúen con el contenido y las funciones de tu app mediante Siri o búsquedas contextuales, debes implementar el framework App Intents.

App Intents es la forma en que tu app expone acciones al sistema: Siri, Spotlight, la app Atajos y, cada vez más, Apple Intelligence las usan para entender qué puede hacer tu app sin que tengas que entrenar ningún modelo.

Ejemplo: Creando un Intent compatible con Apple Intelligence

Supongamos que desarrollas una app de gestión de proyectos. Quieres que el usuario pueda decir: «Siri, resume mis tareas pendientes para hoy en TareasApp».

import AppIntents

struct SummarizeTasksIntent: AppIntent {
    static let title: LocalizedStringResource = "Resumir Tareas Pendientes"
    static let description = IntentDescription("Genera un resumen inteligente de las tareas del usuario.")

    // Hace que la acción aparezca en Atajos y Spotlight (es el valor por defecto)
    static let isDiscoverable = true

    @MainActor
    func perform() async throws -> some IntentResult & ProvidesDialog & ShowsSnippetView {
        let tasks = TaskManager.shared.getPendingTasks()
        let summaryText = TaskManager.shared.generateLocalSummary(for: tasks)

        return .result(
            dialog: IntentDialog(stringLiteral: summaryText),
            view: TaskSummarySnippetView(tasks: tasks)
        )
    }
}

Para registrar la semántica de tu app con el sistema, debes implementar un AppShortcutsProvider:

struct AppShortcuts: AppShortcutsProvider {
    static var appShortcuts: [AppShortcut] {
        AppShortcut(
            intent: SummarizeTasksIntent(),
            phrases: [
                "Resume mis tareas en \(.applicationName)",
                "¿Qué tengo pendiente hoy en \(.applicationName)?"
            ],
            shortTitle: "Resumen de Tareas",
            systemImageName: "checklist"
        )
    }
}

Con esta implementación, el usuario puede lanzar la acción desde Siri, Spotlight o la app Atajos con cualquiera de las frases definidas (sin configurar nada) y recibe la respuesta hablada junto con la vista de SwiftUI del snippet.

Generación de contenido visual con Image Playground API

Otra de las grandes novedades (desde iOS 18.1) es la API de Image Playground, que permite a los desarrolladores invocar la interfaz de generación de imágenes por difusión de Apple dentro de su propio flujo de trabajo.

Puedes invocar la hoja de generación usando el modificador .imagePlaygroundSheet:

import SwiftUI
import ImagePlayground

struct AvatarCreatorView: View {
    @State private var isShowingPlayground = false
    @State private var generatedImage: Image?
    @State private var imageConcept: String = "Un astronauta dibujado en estilo ilustración"

    var body: some View {
        VStack(spacing: 20) {
            if let generatedImage {
                generatedImage
                    .resizable()
                    .scaledToFit()
                    .frame(width: 200, height: 200)
                    .clipShape(Circle())
            } else {
                Image(systemName: "person.crop.circle.badge.plus")
                    .font(.system(size: 80))
                    .foregroundColor(.gray)
            }

            Button("Generar Avatar con IA") {
                isShowingPlayground = true
            }
            .buttonStyle(.borderedProminent)
        }
        .imagePlaygroundSheet(
            isPresented: $isShowingPlayground,
            concept: imageConcept
        ) { url in
            // La API devuelve la URL del archivo generado localmente
            if let data = try? Data(contentsOf: url),
               let uiImage = UIImage(data: data) {
                generatedImage = Image(uiImage: uiImage)
            }
        }
    }
}

La gran ventaja técnica aquí es que la generación corre a cargo del hardware del dispositivo mediante modelos de difusión optimizados, ahorrándote costes de infraestructura gráfica en la nube.

Novedad en iOS 26: el framework Foundation Models

Hasta iOS 18, los desarrolladores solo podían aprovechar Apple Intelligence de forma indirecta (Writing Tools, Image Playground o App Intents). Con iOS 26 Apple abrió por fin el acceso directo al modelo de lenguaje que se ejecuta en el dispositivo mediante el framework Foundation Models. Es gratuito, funciona sin conexión y los datos no salen del iPhone.

Lo primero es comprobar la disponibilidad, porque el modelo solo existe en dispositivos compatibles con Apple Intelligence activado:

import SwiftUI
import FoundationModels

struct ResumenView: View {
    @State private var resumen = ""
    private let model = SystemLanguageModel.default

    var body: some View {
        VStack(spacing: 16) {
            switch model.availability {
            case .available:
                Text(resumen)
                Button("Resumir notas") {
                    Task { await resumir() }
                }
            case .unavailable(let reason):
                Text("Apple Intelligence no está disponible: \(String(describing: reason))")
            }
        }
        .padding()
    }

    func resumir() async {
        let session = LanguageModelSession(
            instructions: "Eres un asistente que resume notas en español en tres frases."
        )
        do {
            let response = try await session.respond(to: "Resume estas notas: ...")
            resumen = response.content
        } catch {
            resumen = "Error: \(error.localizedDescription)"
        }
    }
}

Una LanguageModelSession conserva el contexto de la conversación, así que puedes encadenar varias peticiones. Y si en lugar de texto libre necesitas datos estructurados, la macro @Generable hace que el modelo devuelva directamente un tipo de Swift:

@Generable
struct TareaSugerida {
    @Guide(description: "Título breve de la tarea")
    var titulo: String

    @Guide(description: "Prioridad de 1 a 3", .range(1...3))
    var prioridad: Int
}

let session = LanguageModelSession()
let respuesta = try await session.respond(
    to: "Sugiere una tarea para preparar la reunión del lunes",
    generating: TareaSugerida.self
)
print(respuesta.content.titulo, respuesta.content.prioridad)

Ten en cuenta que es un modelo pequeño (unos 3.000 millones de parámetros): brilla resumiendo, clasificando, extrayendo datos o generando textos cortos, pero no está pensado para preguntas de conocimiento general ni para razonamientos largos.

Buenas prácticas para desarrolladores de SwiftUI

Integrar IA en aplicaciones móviles requiere prestar atención a patrones de rendimiento y experiencia de usuario que antes no eran tan críticos:

Manejo de estados de carga asíncronos: La inferencia local puede tomar desde unos cientos de milisegundos hasta un par de segundos dependiendo del chip. Utiliza ProgressView() y placeholders de SwiftUI para mantener la interfaz reactiva.
Degradación elegante (Graceful Degradation): No todos tus usuarios tendrán un iPhone 15 Pro o un Mac con chip M. Asegúrate de verificar la disponibilidad de las funciones mediante comprobaciones condicionales de API y ofrece alternativas estándar para dispositivos más antiguos.
Concurrencia bien hecha: Las llamadas al modelo son asíncronas (async/await), así que no bloquean la interfaz mientras esperas la respuesta. Actualiza el estado visual siempre en @MainActor.
Consumo de batería y memoria: Evita llamadas excesivas en bucles continuos. Permite que el sistema gestione la memoria del modelo y apóyate en el ciclo de vida de SwiftUI (.task y .onDisappear) para cancelar inferencias innecesarias si el usuario cambia de vista.

Conclusión

Apple Intelligence no busca competir directamente con plataformas de desarrollo de modelos en bruto como Hugging Face u OpenAI API; su objetivo es hacer que la inteligencia artificial sea invisible, segura y profundamente útil en el día a día del usuario.

Integrar estas tecnologías en tus aplicaciones de SwiftUI te permite ofrecer funciones inteligentes de primer nivel manteniendo la arquitectura limpia, la privacidad intacta y el coste de infraestructura en cero. La era de las aplicaciones que simplemente muestran datos ha terminado; el futuro pertenece a las apps contextuales, semánticas y proactivas impulsadas por Apple Intelligence.

Necsal

Desarrollo iOS, Swift y Tecnología

Apple Intelligence para Desarrolladores: Cómo integrar la API de Foundation Models en tu App de SwiftUI