Whisper.cpp vs faster-whisper 2026: Benchmarks STT local, configuración y aceleración GPU

Datos rápidos

• Ambas herramientas: basadas en el modelo Whisper de código abierto de OpenAI (licencia MIT). Misma precisión — runtimes diferentes.
• whisper.cpp: escrito en C/C++ por Georgi Gerganov. Admite CPU (AVX2/NEON), CUDA, Metal (Apple), Vulkan. No requiere Python.
• faster-whisper: librería Python usando CTranslate2. Admite CPU (int8) y CUDA. Sin soporte para Apple Metal.
• Tamaños del modelo Whisper: tiny (39M), base (74M), small (244M), medium (769M), large-v3 (1,55B). Todos en formato ggml / CTranslate2.
• Mejor modelo para la mayoría de casos: Whisper small — 3,4% WER, funciona en 2 GB de RAM, 6× tiempo real en CPU moderno.
• Benchmark RTX 4070 (large-v3): faster-whisper ~12× tiempo real; whisper.cpp CUDA ~8× tiempo real. faster-whisper gana en NVIDIA.
• Benchmark M5 Pro (large-v3): whisper.cpp Metal ~10× tiempo real; faster-whisper solo-CPU ~3× tiempo real. whisper.cpp gana en Apple.

¿Por qué reconocimiento de voz local?

• Privacidad: el audio nunca sale de tu equipo, así que ningún proveedor cloud interviene en la transcripción. Las obligaciones de protección de datos, como la base legal y el almacenamiento seguro, siguen siendo tuyas.
• Costo: sin tarifas por minuto. Un desarrollador que transcribe 8 horas de reuniones por semana ahorra $120–480/mes respecto a precios STT en la nube.
• Offline: funciona en aviones, instalaciones seguras y zonas sin internet estable. Sin gestión de API keys.
• Latencia: sin ida y vuelta de subida/descarga. Para interfaces de voz en tiempo real, el procesamiento local reduce la latencia STT de 300–800 ms (nube) a 50–300 ms.
• Personalización: ajusta el modelo con vocabulario específico del dominio. Ejecuta el tamaño de modelo que quepa en tu hardware.
• Integración con Home Assistant: Whisper en local significa que las palabras de activación y los comandos de voz nunca salen de tu red doméstica. Ver Whisper local en Home Assistant → para la configuración del complemento que reemplaza completamente el STT en la nube.

Tamaños del modelo Whisper — base de ambas herramientas

Distil-Whisper: la alternativa más rápida

• Parámetros: ~756M — aproximadamente la mitad de los 1,55B de large-v3, cabe en ~4 GB de VRAM en lugar de ~10 GB.
• Velocidad: ~6× tiempo real en RTX 4070 (vs. 1× de referencia para large-v3) — comparable al modelo medium en velocidad, con precisión cercana a large-v3.
• WER: ~2,6% en inglés — solo ~0,1% superior al 2,5% de large-v3. En la práctica, la diferencia es imperceptible en habla típica.
• Compatibilidad: funciona con faster-whisper de forma nativa (WhisperModel("distil-large-v3", device="cuda", compute_type="int8")). Para whisper.cpp, convierte al formato GGML usando el script de conversión GGML de distil-whisper.
• Mejor para: trabajos de transcripción por lotes, despliegues en servidor con VRAM limitada y cualquier caso de uso donde quieras calidad de large-v3 a velocidad del modelo medium.
• No recomendado para: transcripción multilingüe — distil-large-v3 es solo inglés. Para otros idiomas, usa large-v3 o medium.

whisper.cpp — el port C/C++

• Soporte de plataformas: CPU (AVX2, AVX512, ARM NEON), Apple Metal (Core ML), CUDA (NVIDIA), Vulkan (GPU AMD/Intel), OpenCL.
• Ventaja en Apple Silicon: whisper.cpp exporta modelos al formato Core ML, habilitando inferencia en el Apple Neural Engine. Large-v3 funciona a ~10× tiempo real en M5 Pro mediante Metal — más rápido que cualquier ida y vuelta a la nube.
• Instalación: clona el repositorio, ejecuta make (o cmake). Binarios precompilados disponibles para plataformas comunes. Sin dependencia de Python.
• Descarga de modelo: bash ./models/download-ggml-model.sh base.en — descarga el archivo de modelo en formato GGML (~142 MB para base).
• Ejemplo de CLI: ./main -m models/ggml-base.bin -f audio.wav — transcribe un archivo WAV a la salida estándar. Añade -l es para español.
• Modo stream en tiempo real: ./stream -m models/ggml-base.bin --step 3000 --length 10000 — transcribe desde el micrófono en chunks de 3 segundos.
• Wrapper Python: pywhispercpp proporciona un binding Python para whisper.cpp, permitiendo su uso en pipelines Python sin sacrificar la aceleración Metal.
• Limitación: sin VAD (detección de actividad de voz) nativo. El modo stream requiere ajustar los parámetros --step y --length según el caso de uso.

# Build from source (macOS / Linux)
git clone https://github.com/ggerganov/whisper.cpp
cd whisper.cpp
make -j4

# Download a model
bash ./models/download-ggml-model.sh large-v3

# Transcribe a file
./main -m models/ggml-large-v3.bin -f recording.wav

# Enable Metal on Apple Silicon (Core ML)
make -j4 WHISPER_COREML=1
./main -m models/ggml-large-v3-encoder.mlmodelc -f recording.wav

whisper.cpp: última versión y novedades

• whisper.cpp v1.9.5 (6 de octubre de 2026): sincroniza ggml con la v0.26.0 (actualizaciones de kernels CUDA, Vulkan, Metal, SYCL, OpenCL, WebGPU y CPU), añade un callback de aborto durante la detección de idioma, corrige un desbordamiento de enteros en los desplazamientos de chunks paralelos y hace que la CLI devuelva el código de error correcto cuando falla un archivo.
• whisper.cpp v1.9.4 (11 de septiembre de 2026): el servidor ahora devuelve el idioma detectado, el callback del encoder se ejecuta antes de la detección automática de idioma y se añadió Windows on ARM al job de publicación.
• whisper.cpp v1.9.3 (20 de agosto de 2026): sincronización de ggml con v0.20.2, mejoras de rendimiento en todos los backends, cuantización Metal TQ2_0, kernels CUDA/SYCL fusionados y correcciones ARM/WASI.
• whisper.cpp v1.9.0-v1.9.2 (junio-agosto de 2026): versiones intermedias de la misma línea de sincronización de ggml antes de la v1.9.3.
• whisper.cpp v1.8.6 (2 de junio de 2026): reimplementación de ffmpeg-transcode para una decodificación opcional con FFmpeg más clara de audio comprimido (MP3, M4A), además de una corrección de la ruta de ejemplos en CI.
• whisper.cpp v1.8.5 (mayo de 2026): mejoras en el VAD por streaming (detección de actividad de voz), correcciones de fugas de parámetros del servidor y de marcas de tiempo de tokens, y correcciones de fugas de memoria en los bindings de Ruby y VAD.
• whisper.cpp v1.8.4 (19 de marzo de 2026): última sincronización de ggml con amplias mejoras de rendimiento, un nuevo flag -g / --gpu-device (y selección de dispositivo GGML_CUDA) para elegir una GPU, y correcciones del ajuste de segmentos UTF-8.
• El VAD nativo ya está integrado en whisper.cpp. Las versiones recientes añadieron una ruta nativa de detección de actividad de voz, reduciendo una ventaja de larga data de faster-whisper — aunque la integración de Silero VAD de faster-whisper sigue siendo más lista para usar.
• faster-whisper v1.2.1 (31 de octubre de 2025): última versión etiquetada; pip install faster-whisper la instala. No hay versión etiquetada en 2026, pero la rama principal está activa: los commits del 16 de octubre de 2026 añaden validaciones de entrada, como un error para idiomas que un modelo no admite. La v1.2.0 (agosto de 2025) añadió compatibilidad con distil-large-v3.5.
• CTranslate2 v4.8.3 (13 de octubre de 2026): el motor de inferencia bajo faster-whisper sigue publicándose. La serie v4.8 añadió correcciones de ROCm en Windows, endurecimiento de la carga de modelos y una corrección de una división por cero en Whisper align() cuando una ventana no tiene fotogramas.
• Ningún modelo Whisper nuevo de clase superior en 2026. Los pesos multilingües más recientes de OpenAI siguen siendo large-v3-turbo (octubre de 2024; 809M de parámetros, decoder reducido de 32 a 4 capas, licencia MIT), que cambia una pequeña pérdida de calidad por mucha más velocidad y funciona en ambas herramientas. distil-large-v3 sigue siendo la opción rápida solo para inglés. Las actualizaciones de ambos runtimes son cambios de runtime y herramientas, no de precisión.

faster-whisper — el port CTranslate2

• Soporte de plataformas: CPU (cuantización int8) y GPU NVIDIA CUDA. Sin soporte para Apple Metal — funciona solo en CPU en Mac.
• Ventaja de int8: la cuantización int8 de CTranslate2 reduce el VRAM en ~40% y aumenta la velocidad de inferencia ~2× respecto a float16, con impacto WER negligible (< 0,1% absoluto).
• Instalación: pip install faster-whisper — sin compilación necesaria (Python 3.9+). El uso de GPU requiere NVIDIA cuBLAS para CUDA 12 y cuDNN 9; las configuraciones antiguas con CUDA 11 / cuDNN 8 deben fijar un ctranslate2 anterior (3.24.0).
• VAD integrado: faster-whisper incluye integración con Silero VAD, que omite automáticamente segmentos de audio silencioso — crítico para pipelines de transcripción en tiempo real.
• Python nativo: la API Python directa facilita la integración con LLMs, librerías de procesamiento de audio y frameworks web.
• Velocidad: large-v3 int8 en RTX 4070 funciona a ~12× tiempo real usando ~2,5 GB de VRAM. CPU int8 alcanza ~20× tiempo real para el modelo tiny.
• Procesamiento por lotes: faster-whisper admite inferencia en lotes para procesar grandes archivos de audio de forma eficiente.
• Limitación: sin soporte Metal en Mac — funciona solo en CPU en Apple Silicon, logrando ~3× tiempo real con large-v3 vs. ~10× de whisper.cpp con Metal.

from faster_whisper import WhisperModel

# Load model (downloads automatically on first run)
model = WhisperModel("large-v3", device="cuda", compute_type="int8")

# Transcribe
segments, info = model.transcribe("audio.wav", beam_size=5)

print(f"Detected language: {info.language} (probability: {info.language_probability:.2f})")
for segment in segments:
    print(f"[{segment.start:.2f}s → {segment.end:.2f}s] {segment.text}")

Obtén ggml-base.bin con pip (configuración Python)

• Instala el binding: pip install pywhispercpp. Para aceleración NVIDIA CUDA, compila con GGML_CUDA=1 pip install git+https://github.com/absadiki/pywhispercpp.
• Descarga automática de ggml-base.bin: from pywhispercpp.model import Model y luego model = Model("base") descarga ggml-base.bin desde Hugging Face (ggerganov/whisper.cpp) en la primera ejecución y lo cachea. Usa "base.en" para la variante solo en inglés.
• Descarga manual (vía CLI, sin pip): desde un repo whisper.cpp clonado, bash ./models/download-ggml-model.sh base guarda el archivo en models/ggml-base.bin — el mismo archivo que obtiene pywhispercpp.
• Descarga directa: curl -L -o ggml-base.bin https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin obtiene el modelo sin script. Cambia base por tiny, small, medium o large-v3.
• No confundas los paquetes: pip install openai-whisper instala el Whisper PyTorch original de OpenAI (usa checkpoints .pt, no ggml-base.bin). pip install faster-whisper usa el formato CTranslate2. Solo pywhispercpp consume archivos GGML ggml-*.bin.
• Dónde queda el archivo: pywhispercpp almacena los modelos GGML descargados en su caché de módulo (o en una ruta que pases con Model("base", models_dir="...")), de modo que el mismo ggml-base.bin se reutiliza entre ejecuciones — sin volver a descargar.

# 1. Install the pip binding for whisper.cpp
pip install pywhispercpp

# 2. ggml-base.bin downloads automatically on first use
#    from pywhispercpp.model import Model
#    model = Model("base")          # fetches & caches ggml-base.bin (~142 MB)
#    for seg in model.transcribe("audio.wav"):
#        print(seg.text)

# --- Or get ggml-base.bin manually (no pip) ---
# From a cloned whisper.cpp checkout:
bash ./models/download-ggml-model.sh base       # -> models/ggml-base.bin

# Or download the file directly from Hugging Face:
curl -L -o ggml-base.bin \
  https://huggingface.co/ggerganov/whisper.cpp/resolve/main/ggml-base.bin

Comparativa directa: tabla de benchmarks

Benchmark de referencia: tiempos de GPU vs CPU de faster-whisper

Configuración de transcripción en tiempo real

• Modo stream de whisper.cpp: ejecuta ./stream -m models/ggml-small.bin --step 3000 --length 10000 -t 4. Procesa chunks de 3 segundos; latencia ~0,5–1,5 segundos con el modelo small. Sin Python necesario.
• Pipeline VAD de faster-whisper: usa vad_filter=True en model.transcribe(). Silero VAD segmenta el audio automáticamente en los límites de silencio — chunks más naturales que ventanas de longitud fija.
• Latencia práctica: 0,5–2 segundos detrás del habla en vivo con modelos small o medium. Usa tiny para la menor latencia (< 0,5 segundos, pero mayor WER).
• Selección de modelo para tiempo real: small o base es el punto óptimo práctico — suficientemente rápido para seguir el habla, suficientemente preciso para audio limpio. Evita large-v3 en tiempo real salvo que tengas una GPU dedicada.
• Entrada de micrófono: whisper.cpp lee audio raw mediante SDL2 o portaudio. faster-whisper lee arrays de audio desde cualquier librería Python de audio (sounddevice, pyaudio, soundfile).
• Estabilidad: el modo stream de whisper.cpp puede producir tokens repetidos ("alucinaciones" de rellenos cortos) en silencio. Suprime con --suppress-blank y --no-speech-threshold.

Apple Silicon: gana whisper.cpp

• Exportación a Core ML: ejecuta ./models/generate-coreml-model.sh large-v3 para exportar el encoder al formato Core ML. Esto descarga la inferencia del encoder al Apple Neural Engine.
• Benchmark M5 Pro (large-v3, Metal): ~10× tiempo real. 60 minutos de audio transcritos en ~6 minutos. Nota: el M5 Pro salió en marzo de 2026 — estos son benchmarks tempranos de la comunidad. El rendimiento puede mejorar con actualizaciones de whisper.cpp optimizando el M5 Neural Engine.
• Benchmark M3 MacBook Air (large-v3, Metal): ~7× tiempo real. 60 minutos en ~8,5 minutos.
• Memoria: la memoria unificada significa que no hay VRAM separada — un M5 Pro de 16 GB puede ejecutar large-v3 (~3 GB) cómodamente junto a otros procesos.
• faster-whisper en Mac: solo CPU, int8. Large-v3 a ~3× tiempo real. Usable para transcripción por lotes nocturna, pero no para tiempo real o flujos de trabajo sensibles al tiempo.
• Recomendación: usa whisper.cpp para todo el trabajo STT en Mac. Añade pywhispercpp si necesitas integración Python manteniendo la aceleración Metal.

GPU NVIDIA: gana faster-whisper

• Benchmark RTX 4070 (12 GB) (large-v3 int8): ~12× tiempo real, ~2,5 GB VRAM.
• Benchmark RTX 3060 (12 GB) (large-v3 int8): ~8× tiempo real, ~2,5 GB VRAM.
• Benchmark RTX 4060 (8 GB) (large-v3 int8): ~7× tiempo real, ~2,5 GB VRAM — cabe con margen.
• int8 vs float16: int8 es ~2× más rápido y usa ~40% menos VRAM con pérdida de precisión negligible. Usa siempre compute_type="int8" en NVIDIA.
• Procesamiento por lotes: el parámetro batched=True de faster-whisper permite el procesamiento paralelo de múltiples archivos de audio, maximizando la utilización GPU en trabajos grandes de transcripción.
• Integración en pipeline Python: faster-whisper se integra directamente en LangChain, Haystack y pipelines Python personalizados. Sin overhead de subproceso comparado con envolver whisper.cpp.

GPU NVIDIA antiguas (GTX 970): int8 retrocede a float32

• Lo que sigue funcionando: los binarios precompilados de CTranslate2 admiten GPU NVIDIA con compute capability 3.5 o superior, por lo que una GTX 970 (5.2) puede ejecutar faster-whisper en CUDA, siempre que tus bibliotecas CUDA y cuDNN instaladas coincidan con la versión (ver Problemas comunes).
• Dónde funciona int8 en GPU: int8 necesita compute capability 7.0 o superior (Volta y serie RTX 20 en adelante) o exactamente 6.1 (GTX 1050 a 1080 Ti, int8_float32). Las compute capability 6.0, 6.2 e inferiores retroceden a float32; float16 necesita 7.0 o superior.
• Consecuencia en memoria: float32 usa 4 bytes por parámetro frente a 1 byte de int8; por número de parámetros, large-v3 (1,55B) necesita unos 6 GB solo para los pesos, más que los 4 GB de la GTX 970. Small (244M, ~1 GB en float32) cabe sin problemas; medium (769M, ~3 GB) está al límite.
• Velocidad: no hemos medido una GTX 970, así que aquí no hay cifra medida. Espera un rendimiento float32 muy inferior a las cifras RTX 4070 int8 de esta guía y prueba tiny, base y small con tu propio audio.
• Comprueba qué admite tu GPU: ctranslate2.get_supported_compute_types("cuda") lista los tipos de cómputo que CTranslate2 acepta en tu tarjeta.
• Alternativas: int8 en CPU (device="cpu", compute_type="int8") funciona en cualquier CPU x86 moderna, y los modelos GGML cuantizados de whisper.cpp (por ejemplo ggml-large-v3-q5_0.bin, unos 3–4 GB) son la forma habitual de encajar modelos mayores en 4 GB; verifica la compilación CUDA o Vulkan en tu tarjeta.

import ctranslate2
from faster_whisper import WhisperModel

# Which compute types does this GPU accept?
print(ctranslate2.get_supported_compute_types("cuda"))

# On compute capability < 6.1 (e.g. GTX 970), request float32 explicitly so nothing is converted silently
model = WhisperModel("small", device="cuda", compute_type="float32")

Whisper en Raspberry Pi 5: tiny, base y small

• Whisper small en Pi 5: aproximadamente 0,4–0,6× tiempo real en CPU (un clip de 10 minutos tarda ~17–25 minutos). Preciso con 3,4% WER pero demasiado lento para subtitulado en vivo — úsalo para transcripción nocturna/por lotes.
• Whisper base en Pi 5: en torno al tiempo real hasta ~2× con multihilo (-t 4). El punto óptimo práctico para transcripción en vivo en el Pi, con un WER aceptable de 5,0%.
• Whisper tiny en Pi 5: la opción más rápida, cómodamente más rápida que el tiempo real para uso en vivo, a costa de un WER más alto de 7,6%. Ideal para reconocimiento de palabra de activación y comandos cortos.
• Usa modelos cuantizados: bash ./models/download-ggml-model.sh small-q5_0 recorta la RAM y acelera la inferencia con una pérdida de precisión mínima — importante en la memoria compartida del Pi 5.
• faster-whisper en Pi 5: instalable (pip install faster-whisper, CPU int8) y competitivo para trabajos por lotes, pero el binario C más ligero de whisper.cpp es la opción embebida más común.
• Térmica: la transcripción sostenida exige mucho a la CPU del Pi 5 — usa refrigeración activa para evitar el throttling térmico que degrada estas cifras.

Cuándo usar cuál

Más allá de whisper.cpp y faster-whisper

• WhisperX: construido sobre faster-whisper, WhisperX añade marcas de tiempo a nivel de palabra y diarización de hablantes — identificando qué hablante dijo qué palabras. Mejor para: transcripción de reuniones con etiquetas de hablante, edición de podcasts y transcripción de entrevistas. Instala con pip install whisperx y proporciona un token de Hugging Face para el modelo de diarización.
• insanely-fast-whisper: un wrapper de pipeline Hugging Face Transformers que añade soporte de Flash Attention 2 para inferencia GPU significativamente más rápida que faster-whisper estándar en hardware NVIDIA. Mejor para: procesamiento por lotes de grandes archivos de audio en GPUs NVIDIA. Requiere una GPU compatible con Flash Attention 2 (Ampere o más reciente: RTX 3000+, A100, H100).

Problemas comunes y soluciones

• Incompatibilidad de versión CUDA: las versiones actuales de faster-whisper requieren cuBLAS para CUDA 12 y cuDNN 9. Si estás atascado con bibliotecas antiguas, fija ctranslate2: pip install --force-reinstall ctranslate2==4.4.0 (CUDA 12 con cuDNN 8) o 3.24.0 (CUDA 11 con cuDNN 8). Verifica la versión de CUDA con nvcc --version.
• Falla la exportación del modelo Metal: asegúrate de tener instaladas las Xcode Command Line Tools — ejecuta xcode-select --install. El script de exportación Core ML requiere el paquete Python coremltools: pip install coremltools.
• Alucinaciones en el silencio: ambas herramientas pueden producir tokens de relleno repetidos en segmentos de audio silencioso. Usa --no-speech-threshold 0.6 en el modo stream de whisper.cpp, o vad_filter=True en model.transcribe() de faster-whisper para omitir automáticamente los segmentos silenciosos.
• Sin memoria con large-v3: cambia a cuantización int8 en faster-whisper (compute_type="int8") — reduce el VRAM de ~5 GB (float16) a ~2,5 GB. En whisper.cpp, usa la variante GGML cuantizada (p. ej., ggml-large-v3-q5_0.bin) que reduce la memoria a ~3–4 GB.
• Salida ilegible en audio no inglés: no uses variantes .en del modelo (tiny.en, base.en) para habla no inglesa — son solo inglés. Usa los modelos multilingüe (base, small, medium, large-v3) y especifica el idioma explícitamente: -l es en whisper.cpp o language="es" en faster-whisper.
• Inferencia CPU lenta: verifica que tu CPU admita instrucciones AVX2 (necesarias para inferencia CPU optimizada). Comprueba con grep avx2 /proc/cpuinfo en Linux o sysctl machdep.cpu.features en Mac. Las CPUs sin AVX2 recurren a SIMD genérico y serán 2–3× más lentas.

Preguntas frecuentes

Fuentes

• whisper.cpp en GitHub — Código fuente, instrucciones de compilación, scripts de descarga de modelos y guía de configuración Metal/Core ML.
• faster-whisper en GitHub — Código fuente, documentación de la API Python y resultados de benchmarks.
• distil-whisper/distil-large-v3 en Hugging Face — Ficha del modelo, resultados de benchmarks e instrucciones de uso de la variante destilada de Whisper.
• WhisperX en GitHub — Marcas de tiempo a nivel de palabra y diarización de hablantes construidas sobre faster-whisper.
• insanely-fast-whisper en GitHub — Pipeline Whisper Flash Attention 2 para máximo rendimiento en GPU NVIDIA.
• OpenAI Whisper en GitHub — Modelo Whisper original, paper y fichas de modelo para todos los tamaños.
• Paper de OpenAI Whisper (Radford et al., 2022) — "Robust Speech Recognition via Large-Scale Weak Supervision". Fuente de los valores WER.
• Documentación de CTranslate2 — Detalles de cuantización, soporte de hardware y fundamentos de optimización int8.
• Documentación de cuantización de CTranslate2 — Tipos de cómputo que admite cada compute capability de GPU (base de la sección sobre la GTX 970).
• Benchmarks del README de faster-whisper — Tiempos de GPU y CPU sobre 13 minutos usados en el benchmark de referencia, y los requisitos actuales de CUDA 12 / cuDNN 9.
• openai/whisper-large-v3-turbo en Hugging Face — Ficha del modelo: 809M de parámetros, 4 capas de decoder, licencia MIT.
• Bill Mill: benchmark actualizado de mlx_whisper vs. whisper.cpp — Comparación independiente de tiempos de large-v3-turbo en Apple Silicon.
• Versiones de whisper.cpp — Notas de versión de v1.9.4 y v1.9.5.

Lectura relacionada

• TTS local y clonación de voz 2026: Piper vs Coqui vs XTTS v2 — El complemento TTS: convierte el texto transcrito de nuevo en voz, offline.
• Construye un asistente de voz completamente offline en 2026 — Conecta Whisper STT a un LLM local y Piper TTS en un pipeline de voz completo.
• Pipeline de IA multimodal local 2026 — Añade modelos de visión junto a STT y TTS para un stack local multimodal completo.
• Guía de hardware para LLM local — Requisitos de GPU y RAM para el pipeline completo de voz + LLM.
• Construye un asistente de voz local en tu teléfono — Versión móvil: WhisperKit en iPhone, Layla en Android.