Live audio transcription with a local open-source stack

Transcribing a meeting while it is happening — from your laptop, a small server under the desk or a headless mini-PC plugged into a USB microphone — used to require a paid cloud service. In 2026, the same workflow runs entirely locally with open-source models and a few Python packages, no quota, no per-minute fee, no audio sent to a third-party server.

This use case focuses on live audio capture from a microphone: meeting notes, interviews, lectures, podcast-style recording, accessibility for hearing-impaired users, voice journaling. The pipeline is straightforward — read audio from the mic, run speech-to-text locally, optionally identify speakers, then optionally hand the transcript to a local LLM for a summary.

Recommended tools in 2026

For a microphone-driven use case, the practical recommendation is Faster-Whisper. It is an open-source reimplementation of OpenAI's Whisper model, built by Guillaume Klein (the author of the CTranslate2 inference engine) to deliver a 4 to 5× speedup and a much lower memory footprint, without changing transcription quality.

For French specifically, Faster-Whisper large-v3 is still the safe choice in 2026. Moonshine is the right pick if you need true streaming, that is, a model that produces the transcript live, word by word or phrase by phrase, with under a second of latency, rather than waiting for the end of a 5-second chunk before showing anything. In practice, Moonshine shines in three cases:

• Live subtitling of a video call or presentation : you want the text to appear on screen while someone is speaking, with no noticeable delay.
• Interactive voice dictation : you dictate and the text appears in your text editor in real time, like a professional dictation tool.
• Accessibility for hearing-impaired users : the transcript has to follow speech at conversation speed, otherwise it loses its usefulness.

In all three cases, Moonshine also uses very little RAM (245 M parameters, runs on a laptop with 8 GB), while Faster-Whisper large-v3 needs 3 to 4 GB of RAM on its own.

Setting up your machine from microphone to text in 15 minutes

The shortest path to a working live-transcription tool is Faster-Whisper feeding off the system microphone.

Prerequisites

You need Python 3.9 or newer installed on your system. If you do not have it yet, grab it from the official download page: python.org/downloads. On GNU/Linux it is usually already installed; on macOS and Windows follow the installer.

You also need a working folder to keep the project isolated. The whole tutorial assumes you create a dedicated folder and run every command from inside it.

Disk space wise, plan for the following downloads:

In total, expect about 4 GB of disk for the full setup with large-v3 (2.5 GB if you go with distil-large-v3), with 3 to 4 GB of free RAM during transcription — 6 to 8 GB if transcription runs on CPU only. CUDA acceleration requires an NVIDIA GPU with the cuDNN and cuBLAS libraries (already bundled with your drivers); without an NVIDIA card, the script automatically falls back to the CPU and still works (see the "Without an NVIDIA GPU" section below).

Set up an isolated Python environment

Once inside your working folder, create a virtual environment so the packages we install do not leak into the rest of your system:

python3 -m venv venv
source venv/bin/activate

From this point on, every pip install you run lives inside this folder. Re-run source venv/bin/activate whenever you open a new terminal and want to come back to the project.

Install the dependencies

# Faster-Whisper for transcription
pip install faster-whisper

# sounddevice + soundfile for microphone I/O
pip install sounddevice soundfile numpy

Minimal live transcription script

The ready-to-use script is available for download here: transcript-audio.py. It handles CUDA/CPU detection, progress bars and only prints the transcript. Save it into your working folder then run it once the dependencies are installed:

python transcript-audio.py

The logic boils down to three points:

• The model is loaded once, with automatic device detection (ctranslate2.get_cuda_device_count(): CUDA in float16 if a usable NVIDIA GPU is found, otherwise CPU in int8).
• A sounddevice InputStream feeds a callback with 5-second blocks of float32 mono 16 kHz audio.
• Each block goes through model.transcribe() with vad_filter=True (voice activity detection: silence is skipped, which improves accuracy and roughly halves the compute) and detected segments are printed as they come.

To target a specific microphone (a USB conference mic rather than the built-in one), list devices with python -m sounddevice and pass the index:

sd.InputStream(device=2, ...)

Without an NVIDIA GPU: Whisper runs fine in other ways

The script above does not require CUDA: it is the inference engine that decides which accelerators are available, and Faster-Whisper (built on CTranslate2) automatically falls back to the CPU with int8 quantization when no NVIDIA GPU is detected — transcription then works everywhere, just slower. But CPU is not the only CUDA-free option:

The practical choice: Faster-Whisper if you have an NVIDIA GPU or a decent CPU (recent laptop), whisper.cpp if you want to leverage an AMD GPU through ROCm or Vulkan, an Intel iGPU through SYCL, or simply a standalone binary without the Python ecosystem. On Apple Silicon, mlx-whisper taps the unified memory and remains the reference. Note that Moonshine (recommended above for true streaming) runs on the CPU through ONNX Runtime, which also supports CUDA, TensorRT, CoreML and DirectML — so without an NVIDIA card, the reference stack stays viable.

Hardware requirements (2026)

The microphone itself matters more than people expect. A USB condenser mic with a cardioid pickup (a Blue Yeti, a Røde NT-USB Mini, a Elgato Wave:1) gives clean signal. The built-in laptop mic picks up the fan and the keyboard and the transcript accuracy drops noticeably.

Microphone-specific tips

A few practical lessons that show up the first time you transcribe a meeting:

• Use a headset or a close-range USB mic. A microphone 50 cm from the speaker gives a much better transcription accuracy than the laptop's built-in mic 1 m away on the desk.
• Enable voice activity detection. vad_filter=True in Faster-Whisper skips non-speech segments, so the model only sees actual words. It also cuts compute roughly in half on a typical meeting.
• Denoise if needed. RNNoise (pip install rnnoise) is a small pre-filter that removes background hiss and fan noise. Run it on the audio buffer before feeding it to Whisper and accuracy climbs another notch on noisy recordings.
• Match the sample rate. Whisper expects 16 kHz mono PCM. Most microphones default to 44.1 or 48 kHz; resample in NumPy before calling transcribe.
• Pick the language explicitly. Pass language="fr" (or "en") instead of letting Whisper auto-detect. Auto-detection eats latency on the first chunk; pinning the language saves a beat on every block.
• Chunk length is a latency knob. 3-second blocks feel almost real-time. 5-second blocks are more accurate. 10-second blocks are best for accuracy but introduce a noticeable delay. Start at 5 and tune.

The verdict

Live audio transcription from a microphone is one of the use cases where local AI is strictly better than the cloud equivalent. Faster-Whisper on a single GPU gives real-time transcription in French and English with the same accuracy as a commercial API, pyannote handles the "who said what" part and a small local LLM turns the transcript into structured meeting notes. The whole stack is MIT or Apache, fits on a mid-range laptop and keeps the audio — which often contains the most sensitive content your business handles — on hardware you control.

For a one-off test, the 15-minute setup above is enough. For a real workflow that runs every week, set up the live script as a systemd service on an always-on mini-PC, point it at a USB mic on your desk and pipe the Markdown log to a local LLM at the end of each meeting.