Whisper local en un Mac: qué necesita, qué cuesta y cómo ejecutarlo
Por Ryleigh Newman · Publicado el
Whisper local significa ejecutar el modelo de voz Whisper de OpenAI en tu propio Mac, de modo que tu audio se convierte en texto en la máquina y no en un servidor en algún sitio. En un Mac, el motor que hay que conocer es whisper.cpp, que trata el chip de Apple como un ciudadano de primera clase, y la decisión que importa es el archivo del modelo: los modelos más grandes oyen mejor y ocupan más disco y más memoria.
Explico cómo encajan las piezas, lo que cuesta cada tamaño de modelo según las cifras del propio whisper.cpp, los comandos para ejecutarlo tú mismo y dónde encaja YapToText. Creé YapToText, una app gratuita que ejecuta whisper.cpp con el archivo estándar de Whisper Large v3 Turbo (Q5), así que valora esa parte teniéndolo en cuenta. Si solo quieres saber si hay una app de Whisper para Mac, la página de la app Whisper para Mac lo responde.
Descarga gratuita. Sin cuenta y sin nada bloqueado, para macOS 14 o posterior en un Mac con chip de Apple. Código fuente en GitHub.
Esta guía en otros idiomas: English, العربية, Čeština, Dansk, Deutsch, Ελληνικά, Suomi, Français, עברית, हिन्दी, Magyar, Bahasa Indonesia, Italiano, 日本語, 한국어, Norsk, Nederlands, Polski, Português, Română, Русский, Slovenčina, Svenska, ไทย, Türkçe, Українська, Tiếng Việt, 简体中文, 繁體中文
En esta página: 12 secciones
Pasos
- Clona el repositorio de whisper.cpp de GitHub y abre su carpeta en Terminal.
- Descarga un modelo con el script download-ggml-model.sh del proyecto, como large-v3-turbo-q5_0.
- Compila el proyecto con CMake, con los dos comandos cmake de su README.
- Convierte tu grabación a un archivo WAV de 16 bits, por ejemplo con ffmpeg.
- Ejecuta whisper-cli con tu archivo de modelo y tu archivo WAV, y lee la transcripción en Terminal.
Las tres piezas de Whisper local
Whisper local tiene tres piezas, y las tres están en tu Mac. El modelo es un archivo, el motor lo ejecuta y tu audio nunca tiene que salir de la máquina.
- El modelo. Whisper es el modelo de reconocimiento de voz de OpenAI, y OpenAI publicó su código y los pesos del modelo bajo la licencia MIT. Descargas un archivo de modelo una vez, y ese archivo hace la escucha.
- El motor. whisper.cpp es una implementación de Whisper en C y C++ simple, también bajo la licencia MIT. Su README llama al chip de Apple un ciudadano de primera clase, optimizado mediante ARM NEON, Accelerate, Metal y Core ML, y dice que en el chip de Apple la inferencia se ejecuta por completo en la GPU mediante Metal. El paquete propio de OpenAI ejecuta Whisper desde Python.
- Tu audio. Entra una grabación o tu micrófono y sale texto. Solo hace falta internet para descargar el archivo del modelo la primera vez.
Eso es lo que lo distingue de un servicio en la nube: no se sube nada para transcribirlo. También significa que tu Mac hace el trabajo, así que el modelo que elijas decide cuánta memoria y cuánto disco necesita ese trabajo.
Elige un modelo según el disco y la memoria
whisper.cpp publica lo que ocupa cada modelo en disco y en memoria, y OpenAI publica cuántos parámetros tiene cada uno. Turbo es la versión más rápida de large-v3 de OpenAI, y su archivo de 5 bits ocupa más o menos una quinta parte del disco que ocupa large.
Comprobado el 3 de octubre de 2026 en el README y la lista de modelos de whisper.cpp y en el README de Whisper de OpenAI.
| Modelo | Parámetros (OpenAI) | Archivo en disco (whisper.cpp) | Memoria (whisper.cpp) |
|---|---|---|---|
| tiny | 39 M | 75 MiB | Unos 273 MB |
| base | 74 M | 142 MiB | Unos 388 MB |
| small | 244 M | 466 MiB | Unos 852 MB |
| medium | 769 M | 1,5 GiB | Unos 2,1 GB |
| large (v1, v2 o v3) | 1550 M | 2,9 GiB | Unos 3,9 GB |
| large-v3, 5 bits (q5_0) | large-v3 cuantizado | 1,1 GiB | No figura |
| large-v3-turbo | 809 M | 1,5 GiB | No figura |
| large-v3-turbo, 5 bits (q5_0) | turbo cuantizado | 547 MiB | No figura |
MiB y GiB cuentan en múltiplos de 1024, así que el archivo turbo de 547 MiB de la lista de whisper.cpp es el mismo que YapToText muestra como 574 MB. Así es como dos páginas honestas pueden indicar un mismo archivo como 547 y 574 y tener razón las dos. La tabla de memoria de whisper.cpp cubre los cinco tamaños originales y no da ninguna cifra para turbo ni para los archivos cuantizados.
Algunas notas más de los dos proyectos:
- Modelos solo en inglés. tiny, base, small y medium también existen como archivos .en del mismo tamaño que solo oyen inglés. OpenAI dice que suelen rendir mejor en inglés, sobre todo tiny.en y base.en, y que la diferencia se reduce con small.en y medium.en.
- Modelos cuantizados. Los archivos que terminan en q5_0 están cuantizados. whisper.cpp dice que los modelos cuantizados necesitan menos memoria y espacio en disco y, según el hardware, pueden procesarse con más eficiencia.
- Turbo. OpenAI lo llama una versión optimizada de large-v3 con una transcripción más rápida y una degradación mínima de la precisión, y lo valora en unas 8 veces la velocidad de large. Esa proporción se midió en una A100, no en un Mac, y OpenAI dice que turbo no está entrenado para traducir.
- Idiomas. OpenAI dice que el rendimiento de Whisper varía mucho según el idioma.
- La columna de memoria de OpenAI. El README de OpenAI indica en cambio la VRAM necesaria para su paquete de Python: alrededor de 1 GB para tiny y base, alrededor de 6 GB para turbo y alrededor de 10 GB para large. Esas no son cifras de whisper.cpp.
Elegí el archivo turbo de 5 bits para YapToText porque, en mis propios dictados, oyó casi exactamente lo que oyó el modelo completo, con un tercio de la memoria. Eso son los dictados de una sola persona, no una prueba comparativa, así que prueba dos tamaños con tu propia voz antes de decidirte.
Ejecutar Whisper tú mismo con whisper.cpp
Ejecutar whisper.cpp tú mismo requiere Terminal y las dos herramientas que dan por hechas los comandos de su README, Git y CMake. Estos son los comandos del propio README, con el modelo cambiado por el archivo turbo de 5 bits. Lo que obtienes es la transcripción de un archivo de audio en Terminal, no palabras escritas en tus apps.
Paso 1: Consigue el código y un modelo
Terminal: Clona whisper.cpp y descarga el modelo turbo de 5 bits.
git clone https://github.com/ggml-org/whisper.cpp.git
cd whisper.cpp
sh ./models/download-ggml-model.sh large-v3-turbo-q5_0Qué ocurre: El proyecto queda en una carpeta whisper.cpp, y el script descarga ggml-large-v3-turbo-q5_0.bin desde Hugging Face a su carpeta models. Cambia por base.en o small para una descarga más pequeña.
Paso 2: Compílalo y transcribe la muestra
Terminal: Compila whisper-cli y ejecútalo sobre la grabación de muestra que viene con el proyecto.
cmake -B build
cmake --build build -j --config Release
./build/bin/whisper-cli -m models/ggml-large-v3-turbo-q5_0.bin -f samples/jfk.wavQué ocurre: CMake compila el proyecto, y whisper-cli transcribe la muestra con el modelo que descargaste y muestra el texto en Terminal.
Paso 3: Convierte primero tu propio audio
El README dice que whisper-cli por ahora solo funciona con archivos WAV de 16 bits, y da un comando de ffmpeg para convertir cualquier otro. ffmpeg es una instalación aparte.
Terminal: Convierte un MP3 al formato WAV que lee whisper-cli.
ffmpeg -i input.mp3 -ar 16000 -ac 1 -c:a pcm_s16le output.wavQué ocurre: ffmpeg escribe output.wav como audio de 16 kHz, mono y de 16 bits, que luego le pasas a whisper-cli después de -f.
O usa el paquete de Python de OpenAI
Terminal: Instala el paquete propio de OpenAI, si prefieres trabajar en Python.
pip install -U openai-whisperQué ocurre: pip instala el comando whisper. El README de OpenAI dice que se espera que el código funcione con Python 3.8 a 3.11, que necesita ffmpeg y que su modelo por defecto es turbo.
Para voz en directo, whisper.cpp incluye whisper-stream, que toma muestras de tu micrófono cada medio segundo y transcribe de forma continua. Necesita SDL2, y el README lo llama un ejemplo ingenuo. Llevar las palabras a Mail, Slack o tu editor es la parte que añade una app.
Usar el mismo modelo en YapToText sin Terminal
YapToText ejecuta el mismo motor y el mismo archivo sin ninguna ventana de Terminal: una copia de whisper.cpp integrada en la app con Metal y Accelerate, y ggml-large-v3-turbo-q5_0.bin dentro de la descarga del App Store. Su SHA-256 coincide con el del archivo de Hugging Face, así que es el modelo estándar, no uno ajustado ni reentrenado. Creé la app porque me cuesta escribir con las manos, y quería que Whisper escribiera en todas las apps en lugar de imprimir en una ventana de Terminal. Es el archivo que descarga el script. Lo que cambia es todo lo que lo rodea.
Esto es lo que añade la app alrededor del modelo:
- Memoria que devuelve. En la página Energy, Keep models in memory decide cuánto tiempo sigue cargado un modelo después de un dictado: 2 minutos después de usarlo por defecto, con opciones desde Only while dictating hasta Until quit. Descargarlo antes ahorra energía y memoria, y el siguiente dictado tras una descarga tarda unos segundos más.
- Espacio para macOS. Cuando a macOS se le acaba la memoria, YapToText descarga a la vez sus modelos cargados y espera cinco minutos antes de volver a calentarlos.
- Un modelo más ligero con batería. Switch models with the power source, desactivado por defecto, da al modelo de dictado y al modelo de limpieza una opción cada uno para cuando están enchufados y otra para cuando van con batería.
- Tu propio archivo. En Your own models, en la página AI Models, Add Model acepta cualquier .bin GGML de whisper.cpp, así que un modelo que descargaste con el script también sirve. La app lee el archivo para saber qué es y rechaza cualquier otra cosa.
- Las cifras de tu Mac. La tarjeta This Mac de la página Energy muestra tu chip y tu memoria, que es el número que hay que comparar con la tabla de arriba.
La Dictation Model Library de la página AI Models tiene diez modelos Whisper más, de Tiny a Large v3, cada uno con el tamaño que muestra la app. La guía de modelos de IA los enumera, y la guía de energía explica los ajustes de memoria. La descarga del App Store ocupa unos 2,9 GB porque los dos modelos de la app van dentro. La versión de Homebrew ocupa unos 12 MB y necesita la descarga de un modelo de voz antes de su primer dictado.
Si Whisper local va lento o te entiende mal
Empieza por las soluciones baratas antes de descargar un modelo más grande. Arregla el micrófono y las palabras antes de cambiar el modelo.
- Espera a que pase la primera ejecución. Un modelo tiene que cargarse antes de poder transcribir. En YapToText, el primer dictado tras abrir la app tarda un momento. Si compilaste whisper.cpp con Core ML, su README dice que la primera ejecución en un dispositivo es lenta mientras el servicio del Neural Engine compila el modelo.
- Fija el idioma que hablas. El selector Language de la página AI Models de YapToText empieza en el idioma del sistema de tu Mac, y un idioma que Whisper no puede usar pasa a la detección automática. La página de idiomas enumera los 29.
- Arregla el micrófono. Los micrófonos Bluetooth tienen calidad de teléfono, así que el micrófono del propio Mac oye mejor. En YapToText, elígelo en el selector Input del panel de la barra de menús.
- Enséñale tus palabras. La página Dictionaries de YapToText prepara a Whisper con tus nombres y términos, y no solo corrige lo que escribe. La guía de diccionarios muestra cómo.
- Usa un modelo solo en inglés para el inglés. Si la memoria va justa y solo hablas inglés, OpenAI dice que las versiones .en suelen rendir mejor, sobre todo en tiny y base.
- Cambia el tamaño del modelo. Sube de tamaño si te entiende mal y tu memoria lo permite, o bájalo si va lento. En YapToText, las estrellas de la página AI Models muestran el compromiso, y cada dictado de History muestra su propio tiempo entre parar y obtener el texto.
Lo que Whisper local no cambia
Ejecutar Whisper en local traslada el trabajo a tu Mac, y eso es todo lo que traslada. Lo local cambia adónde va tu voz, no lo bien que se oye.
- Errores. El modelo decide lo bien que oye, se ejecute donde se ejecute, así que un nombre que oye mal necesita una entrada de diccionario o un mejor micrófono, no otro lugar.
- Traducción. OpenAI dice que turbo no está entrenado para traducir, y YapToText solo le pide a Whisper que transcriba, nunca que traduzca.
- Una descarga. Un modelo local todavía tiene que llegar una vez. El script de whisper.cpp lo descarga de Hugging Face, la versión del App Store de YapToText lo trae dentro y la versión de Homebrew lo descarga desde la página AI Models.
- Mac con Intel. whisper.cpp indica que admite Mac con Intel y con Arm. YapToText necesita chip de Apple y macOS 14 o posterior, y no se afirma nada sobre los Mac con Intel.
- Cifras de precisión. No publico porcentajes de precisión de ningún modelo. Las estrellas y tu propio History son la guía.
Para demostrar que una configuración es de verdad local, la página del dictado sin conexión tiene una prueba de un minuto: apaga el Wi-Fi y dicta.
En resumen
- Whisper local. Es un archivo de modelo y un motor en tu Mac, sin subir nada.
- El modelo. El archivo turbo de 5 bits, 547 MiB en la lista de whisper.cpp, es el que incluye YapToText.
- Hazlo tú mismo. Clona whisper.cpp, descarga un modelo, compila con CMake y ejecuta whisper-cli sobre un archivo WAV de 16 bits.
- O sáltate Terminal. YapToText ejecuta el mismo archivo y escribe en cualquier app, gratis.
Elige el modelo según la memoria de tu Mac y después según tu propia voz. Si algo de aquí no coincide con lo que ves, abre un issue en GitHub. Leo todos.
Descarga gratuita. Sin cuenta y sin nada bloqueado, para macOS 14 o posterior en un Mac con chip de Apple. Código fuente en GitHub.
Guías
Más guías, en inglés
Fuentes
- https://github.com/ggml-org/whisper.cpp (consultado el 3 de octubre de 2026)
- https://github.com/ggml-org/whisper.cpp/blob/master/models/README.md (consultado el 3 de octubre de 2026)
- https://github.com/openai/whisper (consultado el 3 de octubre de 2026)
- https://huggingface.co/ggerganov/whisper.cpp/blob/main/ggml-large-v3-turbo-q5_0.bin (consultado el 3 de octubre de 2026)
- https://github.com/ryleighnewman/YapToText (consultado el 3 de octubre de 2026)
- https://apps.apple.com/us/app/yaptotext/id6786382289 (consultado el 3 de octubre de 2026)
Preguntas
¿Cómo ejecuto Whisper en local en un Mac?
Usa whisper.cpp: clona el repositorio, descarga un modelo con su script download-ggml-model.sh, compílalo con CMake y ejecuta whisper-cli sobre un archivo WAV de 16 bits. O instala una app que lo incluya, como YapToText, que ejecuta Whisper Large v3 Turbo sin configuración.
¿Cuánta memoria necesita Whisper?
Depende del modelo. whisper.cpp indica unos 273 MB para tiny, 852 MB para small, 2,1 GB para medium y 3,9 GB para large, y dice que los cuantizados necesitan menos. No da ninguna cifra de memoria para turbo.
¿Cuál es el mejor modelo de Whisper local?
Large v3 Turbo es por donde yo empezaría, y su archivo de 5 bits es el que incluye YapToText: 547 MiB en la lista de whisper.cpp. Si la memoria va justa, small o base usan mucho menos, y OpenAI dice que las versiones solo en inglés suelen rendir mejor en inglés en los tamaños más pequeños.
¿Cuánto ocupa el modelo Whisper Large v3 Turbo?
1,5 GiB en la lista de modelos de whisper.cpp, o 547 MiB como archivo q5_0 de 5 bits, que son 574 MB contados en unidades decimales. OpenAI indica turbo con 809 millones de parámetros.
¿Whisper local necesita internet?
Solo para descargar el modelo una vez. Después, whisper.cpp y YapToText transcriben sin conexión, y la versión del App Store de YapToText trae el modelo dentro, así que se salta incluso esa descarga.
¿Puedo usar un modelo de whisper.cpp en YapToText?
Sí. En Your own models, en la página AI Models, Add Model acepta cualquier archivo .bin GGML de whisper.cpp, y la app sabe qué es por el propio archivo.