Translation was among the first things machine learning got genuinely good at, and it improved again when general-purpose language models arrived. Three approaches now dominate — dedicated neural engines, Google's infrastructure, and asking a chatbot. They have different strengths, and more importantly, different failure modes.
The three contenders
DeepL
A neural machine translation specialist. It has consistently been rated highly by professional translators for European language pairs, particularly for producing natural-sounding prose rather than word-by-word output.
- Strength: fluency, sentence structure, idiomatic phrasing, tone control (formal/informal) in supported languages
- Strength: glossary and formality features, plus document translation that preserves formatting
- Limitation: narrower language coverage than Google
- Limitation: less strong on some non-European pairs
Google Translate
The incumbent, with the broadest language coverage and deepest integration — Chrome, Android, Lens (camera translation), live conversation mode, and the largest set of low-resource languages.
- Strength: language breadth, including many languages no competitor covers well
- Strength: integration everywhere, offline packs, instant camera and speech translation
- Strength: free tier is very generous
- Limitation: output is often more literal, especially for long or subtle text
- Limitation: a major language-model shift a few years ago introduced odd failures for a period; quality now varies noticeably by pair and by text type
General-purpose LLMs (ChatGPT, Claude, Gemini)
Not translation engines, but they translate well — and uniquely, they can take instructions about the translation itself.
- Strength: instructions — "translate this as a formal product description for a German audience", "keep the humor", "keep it under 100 characters"
- Strength: context — you can provide a style guide, glossary, or the preceding paragraphs
- Strength: explaining choices, offering alternatives, flagging ambiguity in the source
- Limitation: slower and more expensive for bulk, often API-metered
- Limitation: can over-translate — smoothing out hesitation or ambiguity that was deliberate in the original
- Limitation: more prone to adding or dropping content on long documents
How they fail
- Hallucinated content — LLMs and, less often, NMT engines can invent a sentence that has no counterpart in the source. Rarest in short text; more likely in long documents.
- Dropped content — silently omitting a clause. This is the dangerous one, because no error is visible in the output.
- False fluency — output reads beautifully and means something else. Native-sounding text gets trusted more than it deserves.
- Register errors — wrong formality level is professionally embarrassing and culturally asymmetric across languages.
- Numbers, dates and units — format conventions differ (decimal separators, date order, large-number naming). Check these specifically.
- Negation and hedging — "may not", "unlikely", "not excluded" are systematically mishandled, and these carry disproportionate weight in technical, legal and medical text.
- Terminology drift — inconsistent translation of domain terms across a document set.
Where each one belongs
- Reading a foreign-language page: Google Translate or a browser extension. Breadth and integration win; accuracy only needs to be gist-level.
- Travel, menus, signs, conversation: Google Translate — camera, speech and offline modes are unmatched.
- Translating your outgoing message or document: DeepL for prose quality; an LLM if you need specific tone, brevity or audience control.
- Business copy you will publish: LLM with explicit instructions plus glossary, then human review. Machine output alone is not a professional deliverable.
- High-stakes documents: legal, medical, safety-critical, contractual. Use a qualified human translator. Machine translation may assist; it should not be final.
- Bulk or API batch: whichever engine benchmarks best for your specific language pair, with a glossary
Getting better output
- Write clearly in the source. Ambiguous, idiom-heavy or structurally convoluted input produces worse translation regardless of tool.
- Avoid idioms if the text will be machine translated.
- Give the LLM context — who the reader is, the register, the purpose, the length limit.
- Provide a glossary for domain terms and product names.
- Back-translate to check. Translate the result back into the source; divergence reveals problems, though it won't catch everything.
- Review numbers, names and negations manually. That's where the costly errors concentrate.
- Send shorter chunks for long documents — both omission and hallucination rates rise with length.
A privacy note
Whatever you paste goes somewhere. Confidential contracts, patient information (this is a real concern for the health-adjacent use cases covered on this site), unpublished research and proprietary source code should not be pasted into consumer tools without checking: whether the provider uses input for training, what the retention policy is, and whether an enterprise tier with stronger terms is required.
The bottom line
No single winner, because these aren't the same kind of tool. Google Translate is breadth and convenience; DeepL is prose fluency in its strongest pairs; LLMs are controllable and context-aware but need guardrails. For gist and travel, any of them. For anything you put your name on, machine output plus human review. For anything legally or medically binding, a qualified human translator — with machine assistance, not machine authorship.