We Built a Live French-to-English Translator That Runs Entirely on Your Machine

Construction companies work in a bilingual reality. Safety meetings in Quebec. Sub-trade crews that operate primarily in French. Regulatory documents from the CCQ, the CNESST, and municipal inspectors that arrive in French first — if they arrive in English at all. Even in US border states, Francophone crews and suppliers are a daily reality.

We kept running into the same problem: the existing translation tools all phone home. Google Translate, DeepL, even most "local" wrappers around Whisper — they send your audio or text to a cloud API. For a construction company handling project details, safety reports, and contract discussions, that's a non-starter. Your data ends up on someone else's server, in someone else's training set.

So we built our own. It runs entirely on a MacBook. No internet required after the initial model download. No API keys. No data ever leaves the machine.

What It Does

Speak French into your MacBook's microphone. Four seconds later, you see the English translation in your terminal. It's not perfect — no translation tool is — but it's fast, it's private, and it works on a job site with zero connectivity.

The Architecture

The translator is three components wired together in a single Python script. No microservices. No Docker containers. No cloud dependencies. Just a virtualenv and a shell script.

1. AudioCollector — The Microphone Layer

The first component grabs audio from your MacBook's built-in microphone using sounddevice, which wraps PortAudio. It runs a continuous input stream and feeds audio into a thread-safe queue.

Every 4 seconds, it pulls a chunk of audio from the queue, checks if it's above a silence threshold (RMS energy check — if the room is quiet, it skips the chunk entirely), and passes it to the next stage. The audio is boosted by 4x gain because MacBook built-in mics are quiet, and it's sampled at 16kHz — the rate Whisper expects.

The buffer uses a 50% overlap strategy: after pulling a 4-second chunk, it keeps the second half as the start of the next chunk. This prevents word boundaries from getting cut off mid-sentence.

2. WhisperMLX — The Transcriber

This is the core. We use mlx-whisper, a port of OpenAI's Whisper model that runs on Apple's Metal GPU framework. On an M-series MacBook, this is dramatically faster than CPU-based Whisper — we're talking real-time or better for the small model, and near-real-time for large-v3.

The transcription pipeline:

1. The 4-second audio chunk is passed to mlx-whisper with language="fr" — telling it to expect French specifically, which improves accuracy significantly over auto-detect.
2. It returns the transcribed French text.
3. If mlx-whisper isn't available (e.g., the model hasn't been downloaded yet), it falls back to faster-whisper running on CPU with INT8 quantization. Slower, but it works.

The model is loaded once at startup and kept in GPU memory. After the initial warm-up transcription (a silent clip, just to trigger model loading and caching), every subsequent 4-second chunk transcribes in under a second on Metal.

3. ArgosTranslator — The Offline Translation

Once we have French text, we pass it to Argos Translate — a completely offline, open-source translation engine. It uses a pre-trained French-to-English model that lives on disk. No API calls. No network. No data leaving the machine.

Argos isn't as polished as DeepL. It won't handle idiomatic expressions gracefully. But for the kind of practical, direct French that gets spoken on construction sites — scheduling updates, safety notes, material orders, inspection reports — it's accurate enough to be useful. And it's fast: translation takes under 100ms.

The Data Flow

Microphone
    │
    ▼
AudioCollector (sounddevice, 16kHz, 4s chunks)
    │  ← silence gate (RMS threshold)
    ▼
WhisperMLX (mlx-whisper on Metal GPU)
    │  ← French text
    ▼
ArgosTranslator (offline, on-disk model)
    │  ← English text
    ▼
Terminal output (timestamped, colour-coded)

The entire pipeline — from microphone input to translated text on screen — takes about 4–5 seconds. Most of that is the audio chunking window. The actual transcription plus translation happens in under 2 seconds on a MacBook with an M-series chip.

Why We Built This

This isn't a product. It's a tool we built because we needed it.

We were sitting in French-language meetings — project reviews, safety briefings, regulatory discussions — and the existing options were all the same: open a browser tab, send your audio to a server you don't control, and hope the transcription is accurate. For internal meetings with sensitive project details, that's not acceptable.

The construction industry operates in both official languages. If you're a GC working in Quebec, dealing with Francophone sub-trades in Ontario, managing crews in New Brunswick, or coordinating with French-speaking suppliers and inspectors, you need translation that works and that doesn't compromise your data.

This tool does both.

Running It

The whole thing is a single shell script. You need a MacBook with an M-series chip and a Python virtualenv with the dependencies installed.

# Clone the translator
cd ~/french-translator

# Run with the small model (fast, good accuracy)
./live-french.sh small

# Run with large-v3 (best accuracy, needs Metal GPU)
./live-french.sh large-v3

# Adjust the chunk interval (seconds)
./live-french.sh medium 6

The first run downloads the model from HuggingFace — about 3GB for large-v3. After that, everything runs offline. The models are cached locally and the script sets HF_HOME to a local directory so it never tries to reach the network again.

What It's Good At

• Safety meetings — follow along in real time when the meeting is in French
• Quick conversations — get the gist of what a Francophone sub-trade is telling you
• Document review — pair it with a French document reader to get rough translations of written content
• Privacy-sensitive discussions — project finances, contract disputes, incident reports

What It's Not Good At

• Idiomatic French — Argos will stumble on colloquial expressions and Quebec-specific slang
• Heavy accents — Whisper handles standard French well; strong regional accents reduce accuracy
• Noisy environments — the silence gate helps, but a loud job site will degrade transcription
• Legal precision — this is a comprehension tool, not a certified translation

The Code

The entire translator is under 260 lines of Python. No frameworks. No async runtimes. No external services. Just sounddevice for audio, mlx-whisper for transcription, and argostranslate for translation.

We built it because the alternative was sending construction project data to someone else's server. That was never going to be the answer.

This tool was built by the Jenga IT team for our own use on construction projects. It's not a product — it's a practical solution to a real problem we kept running into. If you're a GC working in bilingual environments and this sounds useful, get in touch.