Argos Translate 1.11: Self-Host AI Translation Open Source

Sending sensitive documents to Google Translate or DeepL means handing strangers your data. For legal teams, internal wikis, or anything air-gapped, that’s a non-starter. Argos Translate is the Python-native option that actually ships as pip install – no API key, no cloud calls, no telemetry. Version 1.11.0 landed on PyPI on Feb 2, 2026 and that’s what this guide covers.

What you’re actually deploying

CTranslate2 does the heavy lifting – it’s the inference engine that makes Argos fast on CPU and optionally GPU. Around it sits a stack: OpenNMT for translation, SentencePiece for tokenization, Stanza for sentence boundary detection, and PyQt for the desktop GUI (per the official wiki). One pip install, three interfaces: Python library, CLI, and optional GUI.

Language models ship as .argosmodel files – each one a self-contained neural network you download separately. Nothing is bundled at install time. This is why a fresh pip install can’t translate anything yet.

System requirements – practical estimates

The official docs don’t publish minimum specs, so these are community-derived estimates:

Language pairs are on average 100MB each (per the official readthedocs). Install several and the disk adds up fast. Windows installs work – but two Windows-specific failure modes are covered in the errors section below.

Install Argos Translate 1.11.0 with pip

Use a virtualenv. Every time you skip this step, someone’s system Python breaks.

python3 -m venv argos-env
source argos-env/bin/activate # Windows: argos-envScriptsactivate
python3 -m pip install --upgrade pip
python3 -m pip install argostranslate==1.11.0

That single pip command pulls argostranslate, ctranslate2, sentencepiece, stanza, and sacremoses. The CTranslate2 wheel alone is ~180MB and torch is ~780MB (per GitHub issue #417) – expect a several-minute download on first run.

On Linux, Snap is an alternative. Per the PyPI readme, sudo snap install argos-translate auto-connects a content snap with Arabic, Chinese, English, French, Russian, and Spanish packs included. No separate model download needed for those six languages.

There’s also a v2 beta on the GitHub v2 branch – multilingual model architecture, more experimental. Stick with 1.11 for anything production-facing.

First-time configuration: install a language pack

Two paths. CLI is faster for sysadmin work:

argospm update
argospm search --from-lang en --to-lang de
argospm install translate-en_de
argos-translate --from en --to de "Hello World!"
# Hallo Welt!

Python is better if you’re embedding this in an app:

import argostranslate.package, argostranslate.translate

argostranslate.package.update_package_index()
available = argostranslate.package.get_available_packages()
pkg = next(p for p in available if p.from_code == "en" and p.to_code == "de")
argostranslate.package.install_from_path(pkg.download())

print(argostranslate.translate.translate("Hello World", "en", "de"))

Packages land in ~/.argos-translate/local/share/packages by default. Override with ARGOS_PACKAGE_DIR if you want models on a separate volume (per the readthedocs API reference).

The pivot trick: No direct model for your language pair? Install both pl→en and en→ja. Argos chains them automatically – no config. The catch: each hop costs accuracy. For a pair where a direct model exists, use that instead.

How good does the translation actually need to be? For internal tooling and gisting, chained models are usually fine. For anything customer-facing, test on a representative sample first – quality varies a lot by language pair, and there’s no automatic way to know which pairs have strong models without trying them.

Verify the install

1. Package import:python3 -c "import argostranslate; print(argostranslate.__version__)" – should print 1.11.0.
2. CTranslate2 binding:python3 -c "import ctranslate2; print(ctranslate2.__version__)" – if this fails, the shared library didn’t link correctly (see error #3 below).
3. End-to-end CLI:argos-translate --from en --to de "test" – any non-error output means you’re done.

GPU mode: set ARGOS_DEVICE_TYPE=cuda before running. Per the PyPI readme, this tells CTranslate2 to use CUDA. Skip it for one-off sentences – the overhead isn’t worth it unless you’re processing batches.

Common install errors and what fixes them

1. Windows: command not recognized after pip install. Turns out pip on Windows doesn’t add the .py extension to entry-point scripts. Per a LibreTranslate community thread, the fix is renaming argospm → argospm.py and argos-translate → argos-translate.py inside your Python Scripts directory. One-time fix, annoying but quick.

2. Python 3.12: sentencepiece build crash. Older argostranslate versions pinned sentencepiece==0.1.99, which hits a FileNotFoundError [WinError 2] on Python 3.12 because pip tries to build the wheel from source (GitHub issue #395). Fix: pin argostranslate ≥1.9.6 – they bumped to sentencepiece 0.2.0, which ships prebuilt wheels for 3.12. Version 1.11.0 is fine.

3. libctranslate2-*.so: cannot open shared object file. The docs don’t mention this one. Cause: ctranslate2 ends up installed in both site-packages and ~/.local, and they conflict. Fix: pip uninstall ctranslate2 -y in both locations, then reinstall fresh inside your venv.

4. Pip keeps restarting the CTranslate2 download. The ~180MB CTranslate2 wheel and ~780MB torch wheel are large enough that a flaky connection causes pip to restart from zero each attempt – it can’t resume partial files (per GitHub issue #417). Workaround: pip download argostranslate -d ./wheels somewhere stable, then pip install --no-index --find-links=./wheels argostranslate on the target machine.

The 150-token limit

Drop a 2,000-word document into Argos. Output looks coherent. But not because the model read the whole thing – it didn’t.

The seq2seq model caps at ~150 tokens of input at a time (per the official readthedocs settings section). Before your text hits the model, Stanza’s sentence boundary detection (SBD) chops it into chunks. If Stanza splits badly – lots of abbreviations, inline code, weird punctuation – each fragment gets translated in isolation and loses cross-sentence context. The docs mention ARGOS_CHUNK_TYPE as configurable, though the variable isn’t prominently documented in the main README. Worth setting if you’re processing technical content.

Upgrade and uninstall

Upgrade: pip install --upgrade argostranslate. Installed language packs survive – they live outside site-packages. Exception: jumping to the v2 beta may break model compatibility. Back up ~/.argos-translate/ first.

Uninstall:

pip uninstall argostranslate ctranslate2 sentencepiece stanza
rm -rf ~/.argos-translate

Snap users: sudo snap remove argos-translate argos-translate-base-langs (per the PyPI readme). The rm -rf line wipes installed models – skip it if you’re just upgrading.

FAQ

How does Argos Translate compare to LibreTranslate?

LibreTranslate wraps Argos Translate in an HTTP server and web UI – same underlying models, different interface layer (per LibreTranslate’s own documentation, relationship confirmed as of early 2026). Embed Argos directly in Python or a CLI pipeline; reach for LibreTranslate when you need a REST endpoint or multi-user access.

Can I run it on Windows without WSL?

Yes. Use Python 3.11 + venv + argostranslate 1.11.0. If the script PATH bug or sentencepiece crash still hits you, WSL2 with Ubuntu removes both problems.

Is the translation quality good enough for production?

For high-resource pairs like en↔es, en↔de, en↔fr – good. Closer to Google Translate than you’d expect for an offline model. For low-resource pairs or anything pivoting through English, quality drops measurably. There’s no shortcut here: test on a representative sample of your actual content before committing. A 10-sentence spot check on the domain you care about tells you more than any benchmark.

Next step: install 1.11.0 in a venv, add the en→de pack, run argos-translate --from en --to de "test". If you get output instead of an error, the stack is wired up correctly – go from there.