G4

Guía Móvil

Gemma 4 en iPhone

Ejecuta Gemma 4 de Google directamente en tu iPhone — sin nube, sin suscripción, privacidad total. El modelo edge E2B ocupa menos de 5 GB y ofrece inferencia en tiempo real en cualquier iPhone 15 Pro o posterior.

iOS Swift Metal GPU On-Device Offline

¿Por qué ejecutar Gemma 4 en iPhone?

  • Privacidad total — tus datos nunca salen del dispositivo
  • Funciona completamente sin conexión, sin internet
  • Cero costos de API — gratis una vez descargado
  • Respuesta sub-segundo en chips A17 Pro / A18

Qué Modelo Usar

ModelDownloadActive RAMSpeed (A17 Pro)Recommendation
Gemma 4 E2B Q4_K_M~2.4 GB~2.5 GB12–18 tok/sBest for iPhone
Gemma 4 E2B BF16~4.6 GB~4.8 GB6–10 tok/sMax quality
Gemma 4 E4B Q4_K_M~4.2 GB~4.5 GB7–11 tok/sHigher quality

El modelo E2B es la recomendación principal para iPhone. Con ~4.6 GB de descarga cabe cómodamente en el almacenamiento del iPhone, y la cuantización de 4 bits reduce la RAM activa a ~2.5 GB — dentro del presupuesto de memoria de los iPhone 15/16.

Método 1 — Google AI Edge SDK (Swift)

La ruta oficial. Google AI Edge proporciona un paquete Swift nativo que ejecuta Gemma 4 con aceleración Metal GPU.

  • Añade el paquete Swift de Google AI Edge a tu proyecto Xcode
  • Descarga los pesos del modelo E2B en formato TensorFlow Lite / LiteRT
  • Inicializa la sesión y llama a generate()

Package.swift

// Package.swift
dependencies: [
    .package(
        url: "https://github.com/google/generative-ai-swift",
        from: "0.5.0"
    )
]

Swift Inference

import GoogleAIEdge

// Load E2B model (place .task file in app bundle)
let modelPath = Bundle.main.path(forResource: "gemma4-e2b-it-q4", ofType: "task")!
let session = try LlmInference(modelPath: modelPath)

// Generate response
let response = try await session.generateResponse(
    inputText: "Explain quantum computing in simple terms."
)
print(response)

Método 2 — GGUF vía llama.cpp (LLM Farm / Offline Chat)

Para usuarios que prefieren una app iOS ya hecha. LLM Farm y Offline Chat en la App Store usan llama.cpp internamente y soportan modelos Gemma GGUF. Descarga el GGUF cuantizado Q4_K_M de Hugging Face, impórtalo en la app y empieza a chatear. Sin código.

LLM Farm

Free, open-source, supports custom GGUF import. Available on App Store.

Offline Chat

Simple UI, built-in model browser, supports Gemma GGUF natively.

Método 3 — Ollama en Mac, acceso desde iPhone

¿Ya ejecutas Ollama en Mac? Expón la API en tu red local y conéctate desde el iPhone con cualquier app compatible con OpenAI (p. ej. Enchanted, OllamaChat). Configura OLLAMA_HOST=0.0.0.0 en el Mac y apunta la app a http://tu-mac-ip:11434.

# On your Mac — allow LAN access
export OLLAMA_HOST=0.0.0.0
ollama serve

# Pull Gemma 4 E2B if not already done
ollama pull gemma4:e2b

# iPhone app settings:
# Base URL: http://192.168.x.x:11434  (your Mac's local IP)
# Model: gemma4:e2b

Requisitos de Hardware del iPhone

iPhoneChipGPU AccelerationE2B Q4 Speed
iPhone 16 Pro / MaxA18 ProMetal — Full18–24 tok/s
iPhone 16 / PlusA18Metal — Full15–20 tok/s
iPhone 15 Pro / MaxA17 ProMetal — Full12–18 tok/s
iPhone 15 / PlusA16Metal — Partial6–10 tok/s
iPhone 14 seriesA15CPU fallback3–5 tok/s
iPhone 13 and olderA15 / A14CPU only2–3 tok/s

Los iPhones más antiguos pueden ejecutar el modelo E2B con inferencia por CPU pero serán lentos (2–4 tokens/seg). El iPhone 15 Pro y posteriores con chip A17 Pro tienen aceleración Metal GPU y ofrecen velocidad real en tiempo real.

Benchmarks de Rendimiento

TaskiPhone 15 Pro (A17)iPhone 16 Pro (A18 Pro)
Text generation (tok/s)1421
First token latency~0.4s~0.25s
512→512 token throughput11 tok/s17 tok/s
RAM usage (peak)2.8 GB2.6 GB
Battery drain (per hour)~18%~14%

Tokens/seg medidos con Gemma 4 E2B Q4_K_M, prompt de 512 tokens, usando Metal GPU. El fallback solo por CPU es 3–5× más lento.

Consejos para el Mejor Rendimiento

  • Usa cuantización Q4_K_M — mejor relación calidad/velocidad en móvil
  • Cierra otras apps antes de inferir para liberar RAM
  • Mantén los prompts bajo 2K tokens para la respuesta más rápida
  • Conecta el cargador en sesiones largas — la inferencia es intensiva en GPU

Relacionado