Can a Mini PC Without a GPU Run Whisper Fast Enough for Everyday Transcription?
Marcus Feldmann
November 16, 2026
You have a small, quiet mini PC already running your home server, and you would like it to turn speech into text too: meeting recordings, voice memos from your phone, spoken commands for Home Assistant, maybe subtitles for a few films that never had them. There is no GPU in the box and no room to add one. Before installing anything, you want to know whether Whisper on that CPU will feel usable or whether you will be waiting all afternoon for a one-hour file.
For most everyday transcription, yes, a mini PC without a GPU is fast enough, as long as you pick the right engine and the right model size. With an optimized CPU runtime such as faster-whisper or whisper.cpp, the small and base models run comfortably faster than real time on modern desktop and laptop-class processors, and even low-power Intel N100-class chips can work through recordings in the background. Where a CPU-only box struggles is running the largest models live, or turning around long recordings in a hurry. The rest of this article explains why, and how to set things up so the hardware you have is enough.
Real-time factor: the number that tells you if transcription will keep up
Speech-to-text speed is usually described with the real-time factor, or RTF: processing time divided by audio length. An RTF of 1.0 means a 10-minute file takes 10 minutes to transcribe. An RTF of 0.25 means it takes 2.5 minutes, four times faster than real time. Anything below 1.0 can, in principle, keep up with live speech; anything above 1.0 can only work through recordings after the fact.
Two things make RTF less simple than it looks. First, it depends heavily on settings, not just hardware: beam size, model size, quantization and whether voice activity detection skips silence all move the number. Second, live transcription has a latency cost on top of throughput, because the model works on chunks of audio. A system with a good RTF can still feel sluggish if it waits for long chunks before answering. So treat any RTF you read as a rough guide to what the same settings will do on your machine.
What the faster-whisper benchmark shows about CPU-only speed
The most useful public CPU numbers come from the benchmark table in the faster-whisper README. It transcribes 13 minutes of audio with the small model, beam size 5, using 8 threads on an Intel Core i7-12700K. The reported times are:
| Implementation | Precision | Time for 13 min of audio | RAM |
|---|---|---|---|
| openai/whisper | fp32 | 6m58s | 2335 MB |
| whisper.cpp | fp32 | 2m05s | 1049 MB |
| whisper.cpp (OpenVINO) | fp32 | 1m45s | 1642 MB |
| faster-whisper | fp32 | 2m37s | 2257 MB |
| faster-whisper | int8 | 1m42s | 1477 MB |
| faster-whisper, batch_size=8 | int8 | 51s | 3608 MB |
Converted to real-time factor, the original OpenAI implementation runs at roughly 0.5, while faster-whisper with int8 sits around 0.13 and its batched mode around 0.07. In other words, the choice of runtime changes the speed by several times on the same chip, which matters more on a mini PC than almost anything else you can tweak.
Keep in mind what this hardware is: a 12th-gen desktop Core i7 with a high power budget, using 8 threads. A typical mini PC is slower. A Ryzen mini PC with a recent 8-core mobile chip will generally land somewhere below that desktop result but in the same broad class. An Intel N100 or N150 has four efficiency cores and a low power limit, so expect it to be clearly slower than the benchmark machine. There is no equally clean public benchmark for these chips, so the safe reading is relative: the gap between runtimes stays the same, but the headroom shrinks, and the larger models move from comfortable to slow. If you are still choosing hardware, the guide to the best mini PCs for a home server goes through when the N100 is enough and when a Ryzen box is worth the extra money.

whisper.cpp or faster-whisper on a CPU-only box
Both are reimplementations of OpenAI’s Whisper models, and both produce essentially the same transcripts from the same model. They differ in how they get there and what they connect to.
faster-whisper is a Python library built on CTranslate2, an inference engine for transformer models. On CPU its main advantage is int8 quantization: you load the model with compute_type="int8" and it uses less memory and runs faster with little accuracy loss. It also has a BatchedInferencePipeline that processes several segments of one file at once, which is where the fastest number in the table comes from, at the cost of more RAM. A minimal script looks like this:
from faster_whisper import WhisperModel
model = WhisperModel("small", device="cpu", compute_type="int8")
segments, info = model.transcribe("meeting.mp3", beam_size=5)
for s in segments:
print(f"[{s.start:.1f} -> {s.end:.1f}] {s.text}")
Most of the self-hosted Whisper servers you will meet, including the Home Assistant integration, are built on faster-whisper.
whisper.cpp is a C/C++ implementation from the ggml-org project, the same group behind llama.cpp. It has no Python dependency, uses less RAM in the benchmark above and supports integer quantization of its own model files. The command-line tool expects 16-bit WAV input, so you convert first:
ffmpeg -i input.mp3 -ar 16000 -ac 1 -c:a pcm_s16le output.wav
whisper-cli -m models/ggml-small.bin -f output.wav -t 4
It also includes whisper-server, an HTTP server with an OpenAI-like API, and a stream example for live microphone input. Its broad list of hardware backends, covered below, is its biggest advantage on a mini PC with integrated graphics.
On a pure CPU, the benchmark shows the two close together, with faster-whisper int8 slightly ahead and its batched mode well ahead for long files. In practice the choice usually comes down to the tool you want to run on top: Python projects and Home Assistant point to faster-whisper, while a lean binary or iGPU acceleration points to whisper.cpp.
Model sizes, from tiny to large-v3-turbo
OpenAI’s Whisper README lists these sizes, with English-only variants for the smaller ones:
- tiny (39M parameters) and base (74M): very fast, fine for short, clear commands, noticeably weaker on accents, names and noisy audio.
- small (244M): the usual sweet spot on a CPU. Good enough for clear meetings and voice notes.
- medium (769M): better on hard audio, but slow on low-power chips.
- large (1550M), including large-v3: the most accurate, and the slowest by a wide margin on CPU.
- turbo (809M), also known as large-v3-turbo: a pruned large-v3 with far fewer decoder layers. OpenAI’s table lists it as about 8x the speed of large on their GPU test, close to the base model’s relative speed. The README notes it is not trained for translation tasks, so use it for transcription only.
For English-only audio, the .en variants of tiny, base, small and medium tend to do a bit better than their multilingual equivalents. Distil-Whisper models such as distil-large-v3 are another option: faster-whisper supports them, and they trade a little accuracy for speed. The Wyoming faster-whisper README warns that distilled checkpoints do not work well with prompts, so avoid them if you rely on an initial prompt to get names right.
On a mini PC CPU, a reasonable starting point is small with int8 for recordings, and base or small for voice commands. Try turbo for recordings where accuracy matters and you can wait; it is far lighter than large-v3 while staying close in quality for many languages.
RAM: how much the models actually take
Memory is rarely the bottleneck for Whisper on a home server. The whisper.cpp README lists runtime memory of about 273 MB for tiny, 388 MB for base, 852 MB for small, 2.1 GB for medium and 3.9 GB for large. The faster-whisper CPU benchmark shows the small model using about 1.5 GB with int8 and 3.6 GB with batching enabled.
So a mini PC with 16 GB has plenty of room for Whisper alongside the usual containers. On an 8 GB machine, small or turbo still fits, but batched transcription with large models next to everything else may push you into swap. If you are deciding whether to share one box between services and AI workloads, the piece on running a home server and local AI on the same mini PC looks at CPU contention as well as memory.
Using the integrated GPU: Vulkan and OpenVINO
“No GPU” usually means “no discrete GPU.” Almost every mini PC has integrated graphics, and whisper.cpp can use it. Its README lists a Vulkan backend for any GPU with a Vulkan-capable driver, and an OpenVINO path that runs the encoder on OpenVINO-supported devices, which the README describes as x86 CPUs and Intel integrated and discrete GPUs. The project publishes a ghcr.io/ggml-org/whisper.cpp:main-vulkan Docker image, alongside the CPU :main image.
The faster-whisper benchmark already shows OpenVINO helping whisper.cpp on CPU alone (1m45s versus 2m05s). Whether moving work to an Intel UHD or Radeon iGPU helps further depends on the chip and driver, and there is no public benchmark table broad enough to quote here. Treat it as something to test: run the same file with the CPU build and the Vulkan build, and compare times. faster-whisper itself does not use iGPUs; its GPU support is through CUDA on NVIDIA cards.

Matching everyday jobs to model and mode
Meeting recordings and voice notes
This is the easiest case for a CPU. Nobody needs a one-hour meeting transcript within ten seconds of it ending. Drop files into a watched folder, transcribe with small or turbo in int8, and read the text when it is ready. On a slower chip the job simply takes longer; it still finishes without you watching it, and a batch that runs overnight is ready in the morning. If privacy is your reason for doing this locally, the comparison of a local speech-to-text model and a cloud meeting bot covers what still leaves the house either way.
Home Assistant voice commands
Voice commands are short, so throughput matters less than latency. Home Assistant’s official Whisper add-on uses faster-whisper and speaks the Wyoming protocol; outside Home Assistant OS you can run the same thing as a container:
docker run -it -p 10300:10300 -v /path/to/data:/data
rhasspy/wyoming-whisper --model tiny-int8 --language en
Then add a Wyoming integration in Home Assistant pointing at port 10300. When Home Assistant introduced the add-on in its 2023 voice update, it said voice commands on a Raspberry Pi 4 took around 7 seconds, while an Intel Core i5 or better could manage sub-second responses. A modern mini PC sits much closer to the second figure, which leaves room for base or small instead of tiny. If the same box also runs your Zigbee coordinator, see whether voice and Zigbee can share one machine before loading it up. Home Assistant also offers Speech-to-Phrase, a much lighter engine that only recognizes a fixed set of home control commands, if the hardware is very constrained.
Subtitles for a Jellyfin library
Generating subtitles for films is pure batch work and a good overnight job. Bazarr has a Whisper provider that talks to the whisper-asr-webservice project, which you can run as onerahmet/openai-whisper-asr-webservice:latest on port 9000 with ASR_ENGINE=faster_whisper and an ASR_MODEL such as small. Bazarr then writes subtitle files next to the media, and Jellyfin picks them up. A two-hour film is a long job on a CPU, so set generous timeouts in Bazarr and schedule it for when nobody is streaming.
Live captions and dictation
This is where a CPU-only box is weakest. Continuous live transcription needs a model that runs well under real time with short chunks, which in practice means tiny, base or small on a fast mobile CPU, and accepting some lag. whisper.cpp’s stream example is the simplest way to see what your machine can do. If live captions with large models are a hard requirement, a GPU is the honest answer.
Docker images worth starting from
rhasspy/wyoming-whisper: faster-whisper behind the Wyoming protocol, for Home Assistant voice.onerahmet/openai-whisper-asr-webservice: a REST API with a choice of OpenAI Whisper, faster-whisper or WhisperX engines; what Bazarr’s Whisper provider expects.ghcr.io/speaches-ai/speaches: an OpenAI-compatible speech server built on faster-whisper, formerly called faster-whisper-server, with alatest-cputag. Useful when other tools expect OpenAI’s transcription API.ghcr.io/ggml-org/whisper.cpp:mainfor CPU andmain-vulkanfor iGPU testing, with ffmpeg included.
Whichever you choose, pin the model explicitly instead of trusting a default, use int8 on CPU where the tool allows it, and limit threads if the box also serves other things. Leaving one or two cores free keeps Jellyfin, Home Assistant and the rest responsive while a long file grinds through overnight.