PLaMo 3 Translate: Japan's open translation model runs offline, even on an iPhone
Japanese AI company Preferred Networks has released its translation model PLaMo 3 Translate as a free download in four sizes, from 0.8 to 31 billion parameters. The company says even the smallest version beats much larger translation models from Google and Tencent. In a hands-on test, it ran on a smartphone with no internet connection.

What's going on
Preferred Networks (PFN), one of Japan's best-known AI companies, released PLaMo 3 Translate as an open-weight model on November 5, 2026. The language model is built specifically for translation. You can download the weights from Hugging Face in four sizes: 0.8B, 2B, 8B and 31B (0.8 to 31 billion parameters). PFN calls its translation quality "world-class". The same model also powers PFN's paid "PLaMo Translation" service, which moved to the third model generation on October 7, 2026.
What sets it apart: the model does translation and nothing else. It's not built for chatting. The small versions are compact enough to run on smartphones and laptops without an internet connection, so your text never has to go to a cloud service.
What the model can do
PLaMo 3 Translate supports 53 languages. PFN's multilingual tests include German, English, French, Spanish, Italian, Dutch, Russian, Chinese (Simplified and Traditional), Korean, Arabic, Thai, Vietnamese and Indonesian. Japanese and English are clearly the focus, though.
It also has some practical options:
- Surrounding context: You can pass in the text around the passage you want translated, so the model gets references right.
- Glossary: You can specify how proper names and technical terms should be translated.
- Japanese style: You can pick the polite "desu/masu" form or the neutral "da/de aru" form.
- In PFN's own web page translation test, HTML tags stay intact. That matters if you translate whole pages with a browser extension, for example.
PFN says the model cards on Hugging Face explain how to use these options.
The four sizes and a hands-on test
| Model | Intended for | Vendor's performance claim |
|---|---|---|
| 0.8B | Smartphones, low-end hardware | beats translation models with more than 30x the parameters on Japanese–English and Japanese–multilingual |
| 2B | Laptops, small computers | outperforms the comparison models on Japanese–English and on Japanese and English to 14 languages each |
| 8B | PCs with a GPU, company servers | higher quality; according to PFN's October figures, better than Google's TranslateGemma 27B |
| 31B | Servers, best quality | flagship of the lineup |
Japanese tech outlet Gigazine tried out the small variants right away. The 0.8B model ran on an iPhone 17 Pro in the PocketPal AI app with Q4_K_M quantization. Quantization shrinks a model by storing its numbers at lower precision. It translated the opening of Jane Austen's "Pride and Prejudice" (about 280 words) into Japanese in 0.515 seconds, and the first chapter of Einstein's book on relativity in 0.387 seconds. Gigazine described the output as very natural Japanese with no broken grammar, and called the offline speed "pretty shocking". The team also tested the 2B model in LM Studio on a laptop without a dedicated GPU, using the abstract of the famous Transformer paper "Attention Is All You Need". It was also fast and highly accurate.
PFN itself shows an internal demo of the 0.8B model translating on a smartphone in airplane mode. According to its tech blog, though, PFN doesn't currently offer a dedicated app.
How PFN trained the model
In its tech blog, PFN explains that the key wasn't new training methods so much as better data. The starting point is a third-generation PLaMo base model. According to an explainer on note.com, it's "PLaMo 3 NICT", developed together with Japan's NICT research institute, with about 30 percent Japanese training data.
Here's how the training pairs (source text plus translation) were created:
- Collecting source texts: PFN filtered large web datasets for diverse text written by native speakers. That meant removing spam pages, already machine-translated text and mixed-language text. There are even dedicated filters, for example to keep Malay out of Indonesian text or to catch Traditional Chinese text that was auto-converted from Simplified Chinese.
- Tournament data synthesis: Google's open model Gemma 4 31B IT produced several translations per text. These went head to head in pairs. The winner advanced but borrowed good phrasings from the loser. Round by round, the translation got better.
- Back-translation: The model also learns the reverse direction, from the AI translation back to the human-written original. That teaches it to write fluent, natural sentences instead of just imitating translationese.
- Iterative self-distillation: Interim versions of PLaMo 3 Translate produced new translations themselves. Whenever these beat the existing training data, they replaced it, and the model was retrained.
All told, this added up to about 37.3 billion tokens (chunks of text): 33.9 billion for base training, followed by 3.4 billion especially high-quality tokens from academic papers, news, technical documents and web pages. Next came DPO (Direct Preference Optimization), where the model learns from pairs of "better vs. worse translation". For the 31B model, this step ran in two stages. Gigazine gives an example: after this fine-tuning, "seeing happy customers made it all worth it" came out as noticeably more natural Japanese. The models up to 8B also learned from the 31B model through distillation, with the big model acting as teacher for the small ones.
PFN measured performance with two in-house benchmarks (PFTB for long, demanding Japanese–English texts; SaaS for web pages with HTML) plus the public WMT24++ and FLORES+ tests. PFN says it prefers its own benchmarks because WMT24++ consists of short sentences with some questionable reference translations.
Formats and license
Every size comes in several formats. PFN used AutoRound, among other tools, for quantization and says the quality loss compared with the uncompressed BF16 version is minimal across all formats.
| Format | Target hardware | Software |
|---|---|---|
| BF16 | GPUs with BF16 support | Transformers, vLLM |
| FP8 | Nvidia Ada Lovelace, Hopper, Blackwell | vLLM |
| W4A16 | Nvidia Ampere and newer | vLLM |
| W4AFP8 | Nvidia Hopper | vLLM |
| NVFP4 | Nvidia Blackwell | vLLM |
| GGUF | CPU and various GPUs | llama.cpp (also LM Studio, PocketPal) |
| MLX-4bit | Apple Silicon | mlx-lm |
The model is released under the PLaMo Community License. Personal, hobby, learning and research use is free, with no registration required. Companies and individuals can use it commercially for free after registering through a form, as long as their revenue in the last fiscal year was no more than 1 billion yen (ITmedia says "under" 1 billion yen). Larger companies need a separate license agreement. So this isn't a classic open-source license.
What you need to try it
- 0.8B: runs on current smartphones (tested: iPhone 17 Pro with PocketPal AI, Q4_K_M) and on practically any PC or Mac, even CPU-only. The 4-bit file is under 1 GB.
- 2B: according to Gigazine, runs smoothly in LM Studio on a laptop without a GPU; about 2–3 GB of RAM is enough.
- 8B: best with a GPU with roughly 6–8 GB of VRAM or more (4-bit); on a Mac, 16 GB of unified memory or more using the MLX version. It works on a CPU, just slower.
- 31B: in 4-bit, roughly 20 GB of VRAM (e.g. RTX 3090/4090) or a Mac with 32 GB or more. The FP8 and NVFP4 variants need newer Nvidia cards.
You can also test the small and mid-sized variants on Google Colab's free GPU.
Our take
PLaMo 3 Translate is one of the strongest cases yet for local translation. A 0.8B model that produces natural Japanese on a phone in a fraction of a second makes offline translation realistic for travel, disaster response and confidential company documents. Those are exactly the use cases PFN itself names. Its direct competitors are Google's TranslateGemma and Tencent's Hy-MT2, both also openly available.
There are still caveats. All the performance comparisons come from PFN itself, mostly on in-house benchmarks; independent measurements are still missing. The focus is clearly on Japanese. The sources don't show how pairs like German–French or German–English stack up against DeepL or large chat models. Gigazine's positive hands-on tests covered English–Japanese. And the license is generous but comes with a revenue cap and mandatory registration for commercial use. Still, if you work a lot with Japanese or want a fast, private translation model for low-end hardware, it's worth a try.
Related videos
Sources
- Google News (JP) news.infoseek.co.jp
- Gigazine (JP) gigazine.net
- Hatena Bookmark IT (JP) preferred.jp
- note.com note.com
- Google News (US) news.google.com
- Google News (IN) news.google.com
- Bing News (en-GB) note.com
- Bing News (ja-JP) news.infoseek.co.jp
Try it yourself: PLaMo 3 Translate 8B
Explained step by step, no prior knowledge needed – on your own computer or free in your browser.
What can I do with it?
PLaMo 3 Translate is a pure translation model. You give it text and get it back in one of the 53 supported languages, and nothing goes to the internet. Its biggest strength is Japanese and English: according to the vendor, even the 0.8B version beats larger translation models from Google (TranslateGemma) and Tencent (Hy-MT2). It understands extra context, sticks to a glossary for technical terms, and can write Japanese in a deliberately polite or neutral style. It also translates web page text containing HTML tags without breaking the tags. The small versions are extremely fast: in Gigazine's test, the 0.8B model translated 280 words on an iPhone in about half a second. Limits: it's not a chatbot, so it won't answer questions or summarize. How well it handles language pairs without Japanese or English, such as German–French, hasn't been independently verified.
Who is it worth it for?
Worth it if you work a lot with Japanese or English, want to translate confidential text locally, or need a fast offline translation model for your phone, laptop or your own software. If you only translate occasionally between, say, English and German and you're happy with DeepL or a chatbot, you won't gain much.
Ideas: What you can do with it
Load the 0.8B model onto your smartphone with PocketPal AI and translate menus, signs or messages from your hosts without roaming or Wi-Fi. In testing, results came back in under a second.
Run the 8B or 31B model on your own machine or a company server and translate contracts, internal reports or customer correspondence. The text never leaves the building, which helps with data protection rules.
Paste the abstract of an English or Japanese paper into LM Studio with the 2B model and have it translated into your language. A glossary keeps technical terms consistent.
Translate HTML snippets or UI strings for your website or app. The model leaves the tags intact, so you can use the output directly.
Translate Japanese text section by section and set character names and terms in the glossary. That keeps the translation consistent across many chapters, so all that's left is polishing the style.
Write your message in English and have it translated into Japanese in the polite desu/masu form. For important emails, it's worth double-checking with a back-translation.
What your computer needs
0.8B for smartphones and very weak computers (according to Gigazine, GGUF Q4_K_M is a good balance between size and accuracy). 2B for ordinary laptops without a GPU; it runs smoothly in LM Studio. 8B for PCs with a GPU with roughly 6–8 GB of VRAM or more, or Macs with 16 GB or more, when quality matters more. 31B for the best quality; in 4-bit it needs roughly 20 GB of VRAM or a Mac with plenty of memory. On Nvidia servers with vLLM: FP8 (Ada/Hopper/Blackwell), W4A16 (Ampere and newer) or NVFP4 (Blackwell); on a Mac, the MLX-4bit version.
- In testing, the 0.8B model ran fully offline on an iPhone 17 Pro using the PocketPal AI app (Q4_K_M quantization).
- The 2B model ran fast in LM Studio on a laptop without a dedicated GPU.
- For 8B in 4-bit, roughly 6–8 GB of VRAM makes sense; for 31B in 4-bit, about 20 GB of VRAM or an Apple Silicon Mac with 32 GB or more.
- GGUF files run via llama.cpp on CPU and GPU, or a mix of both; MLX-4bit is meant for Apple Silicon.
- FP8 needs Nvidia Ada Lovelace, Hopper or Blackwell, NVFP4 only Blackwell, W4AFP8 only Hopper, each with vLLM.
- Long texts with lots of context take up extra memory, so if VRAM is tight, translate in sections.
How do I find out what my computer has?
- Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
- Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
- Linux: Type
nvidia-smiin the terminal (shows your graphics card and its memory) andfree -hfor system memory.
Guide
This model runs with its developers' own program. The commands below come from the Model Card and the developers' instructions.
Windows 10 / 11
Windows 10 / 11: not officially tested. The Model Card doesn't mention an operating system. The Transformers instructions should also work on Windows with an NVIDIA GPU that has enough memory, but according to the source this hasn't been tested. With less VRAM (video memory) or CPU only, you're better off using the GGUF variant (pfnet/plamo-3-translate-8b-GGUF, about 5.3 GB as Q4_K_M) with llama.cpp. WSL2 is another option.
- Check the prerequisites. You need Python 3 (ideally 3.10 or newer) and Git. When installing Python, tick "Add Python to PATH". You also need an NVIDIA GPU with about 22 GB of VRAM (video memory) and a current NVIDIA driver. Plan for about 20 GB of free disk space. Check that everything is in place by running the commands below in PowerShell.
python --version git --version nvidia-smi - Create a working folder. Create a dedicated folder for the project and change into it. Everything else happens in this folder.
mkdir plamo cd plamo - Create a virtual environment. A virtual environment (venv) is a separate space for Python packages, so they don't interfere with the rest of your system. If activation works, the prompt starts with "(.venv)". If PowerShell says scripts are blocked, run "Set-ExecutionPolicy -Scope CurrentUser RemoteSigned" first.
python -m venv .venv .venv\Scripts\Activate.ps1 - Download the model. First, install the Hugging Face download tool. Then download the model into the plamo-3-translate-8b folder. It's about 17 GB, so the download may take a while. Afterwards, change into that folder.
pip install -U huggingface_hub hf download pfnet/plamo-3-translate-8b --local-dir plamo-3-translate-8b cd plamo-3-translate-8b - Install the packages. Now install PyTorch (the compute library), Transformers and a few helper packages. Then check whether PyTorch detects your GPU. If it says "False", you got the CPU-only version of PyTorch. In that case, install the CUDA version following the instructions on the PyTorch website.
pip install -U torch transformers accelerate numba python -c "import torch; print(torch.cuda.is_available())" - Save the test script. Use a text editor to save the following code as demo.py in the plamo-3-translate-8b folder. It translates the Japanese example sentence from the Model Card into English.
from transformers import AutoModelForCausalLM, AutoTokenizer tokenizer = AutoTokenizer.from_pretrained(".", trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained( ".", trust_remote_code=True, dtype="bfloat16", device_map="auto", ) inputs = tokenizer.apply_chat_template( [{"role": "user", "content": "会議は来週の月曜日に変更されました。"}], target_lang="en", add_generation_prompt=True, return_dict=True, return_tensors="pt", ).to(model.device) output = model.generate(**inputs, do_sample=False, max_new_tokens=512) text = tokenizer.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True) print(text) - Run your first translation. Run the script. Loading the model takes a bit the first time. If everything works, you'll see "The meeting has been rescheduled for next Monday." at the end.
python demo.py - Result. The terminal shows the English translation "The meeting has been rescheduled for next Monday."
macOS
macOS: not officially tested. The BF16 version with Transformers hasn't been tested on a Mac, and it would need an Apple Silicon Mac with at least 32 GB of memory. For Macs, the vendor recommends its own pfnet/plamo-3-translate-8b-MLX-4bit variant (about 6 GB) with mlx-lm. The steps below show the untested Transformers route.
- Check the prerequisites. You need a Mac with an Apple chip (M1 or newer), ideally with 32 GB of memory or more. You also need Python 3 (ideally 3.10 or newer), about 20 GB of free space and the Xcode command line tools, which include Git. Install the tools in Terminal with the first command below.
xcode-select --install python3 --version git --version - Create a working folder. Create a dedicated folder for the project and change into it.
mkdir plamo cd plamo - Create a virtual environment. A virtual environment (venv) keeps this project's Python packages separate from the rest of your system. If activation works, the prompt starts with "(.venv)".
python3 -m venv .venv source .venv/bin/activate - Download the model. First, install the Hugging Face download tool. Then download the model (about 17 GB) and change into the new folder.
pip install -U huggingface_hub hf download pfnet/plamo-3-translate-8b --local-dir plamo-3-translate-8b cd plamo-3-translate-8b - Install the packages. Now install PyTorch (the compute library), Transformers and a few helper packages the model needs.
pip install -U torch transformers accelerate numba - Create the test script. This command creates demo.py with the example from the Model Card. The script translates a Japanese sentence into English.
cat > demo.py << 'EOF' from transformers import AutoModelForCausalLM, AutoTokenizer tokenizer = AutoTokenizer.from_pretrained(".", trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained( ".", trust_remote_code=True, dtype="bfloat16", device_map="auto", ) inputs = tokenizer.apply_chat_template( [{"role": "user", "content": "会議は来週の月曜日に変更されました。"}], target_lang="en", add_generation_prompt=True, return_dict=True, return_tensors="pt", ).to(model.device) output = model.generate(**inputs, do_sample=False, max_new_tokens=512) text = tokenizer.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True) print(text) EOF - Run your first translation. Run the script. If everything works, you'll see "The meeting has been rescheduled for next Monday." at the end in Terminal. If it's very slow or crashes from running out of memory, use the MLX-4bit variant.
python3 demo.py - Result. The terminal shows the English translation "The meeting has been rescheduled for next Monday."
Linux
Linux: supported. Linux with an NVIDIA GPU is the usual route for the BF16 version with Transformers or vLLM. The source doesn't name a specific tested GPU. If you have less VRAM, there are variants that need less memory: FP8, W4A16 (about 5.7 GB, with vLLM) or GGUF with llama.cpp.
- Check the prerequisites. You need Python 3 (ideally 3.10 or newer), Git, a current NVIDIA driver and a GPU with about 22 GB of VRAM (video memory). Plan for about 20 GB of free disk space. Check everything with the commands below. nvidia-smi shows your GPU and its memory.
python3 --version git --version nvidia-smi - Create a working folder. Create a dedicated folder for the project and change into it.
mkdir plamo cd plamo - Create a virtual environment. A virtual environment (venv) keeps this project's Python packages separate from the rest of your system. If activation works, the prompt starts with "(.venv)".
python3 -m venv .venv source .venv/bin/activate - Download the model. First, install the Hugging Face download tool. Then download the model into the plamo-3-translate-8b folder (about 17 GB) and change into it.
pip install -U huggingface_hub hf download pfnet/plamo-3-translate-8b --local-dir plamo-3-translate-8b cd plamo-3-translate-8b - Install the packages. Now install PyTorch (the compute library), Transformers, accelerate (which places the model on your GPU) and numba. Then check whether PyTorch sees your GPU. It should say "True".
pip install -U torch transformers accelerate numba python -c "import torch; print(torch.cuda.is_available())" - Create the test script. This command creates demo.py with the example from the Model Card. The script translates a Japanese sentence into English.
cat > demo.py << 'EOF' from transformers import AutoModelForCausalLM, AutoTokenizer tokenizer = AutoTokenizer.from_pretrained(".", trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained( ".", trust_remote_code=True, dtype="bfloat16", device_map="auto", ) inputs = tokenizer.apply_chat_template( [{"role": "user", "content": "会議は来週の月曜日に変更されました。"}], target_lang="en", add_generation_prompt=True, return_dict=True, return_tensors="pt", ).to(model.device) output = model.generate(**inputs, do_sample=False, max_new_tokens=512) text = tokenizer.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True) print(text) EOF - Run your first translation. Run the script. Loading takes a bit the first time. If everything works, you'll see "The meeting has been rescheduled for next Monday." at the end in the terminal.
python demo.py - Result. The terminal shows the English translation "The meeting has been rescheduled for next Monday."
What to do after your first result
- In demo.py, replace the Japanese sentence with your own text. Set the target language with target_lang, for example "en" for English. The model handles 53 languages.
- For long texts, increase max_new_tokens. Input and output combined should stay under 32,768 tokens (word pieces); otherwise, split the text up.
- For applications and production use, the vendor recommends using the PFML3 prompt format directly and running vLLM. That also lets you specify context, a glossary and the style (polite or plain) for Japanese.
- License: under the PLaMo Community License, the model is free for personal, learning and research use. Separate terms apply to commercial use.
Try it
Translate into French: Tomorrow's 10 a.m. meeting is cancelled; we're moving it to Thursday.Translate into Japanese, polite form (desu/masu): Thank you very much for your quick reply. I look forward to our meeting in Tokyo.Translate this paragraph into German: Tokugawa Ieyasu was the founder and first shōgun of the Tokugawa shogunate of Japan, which ruled from 1603 until the Meiji Restoration in 1868.Translate into German and keep all HTML tags: <p>Click <a href="0">Settings</a> to change your <b>password</b>.</p>Translate into Japanese and, per the glossary, keep 'Tokenstrom' unchanged and render 'graphics card' as 'GPU': Tokenstrom explains which graphics card you need for local AI models.
Tips for better results
- For longer documents, pass in the surrounding text as context so references and pronouns are translated correctly.
- Set up a glossary for proper names, product names and technical terms to avoid inconsistent translations.
- When translating into Japanese, specify the style (polite or neutral) explicitly. PFN does this in its own tests, because otherwise the results vary.
- If the quality isn't good enough, move up a size (0.8B to 2B to 8B) instead of fiddling with settings. According to PFN, the quantized versions lose only minimal quality compared with BF16.
If something goes wrong
The model expects a specific input format for source language, target language, context and glossary. If that's wrong in the prompt, the results get worse. The correct format is in the model card on Hugging Face.
It's a translation model, not a chatbot. Questions or instructions like 'Summarize this' usually just get translated rather than answered.
Commercial use under the PLaMo Community License requires prior registration via a PFN form; at 1 billion yen in annual revenue or more, you need a separate license agreement.
The FP8, W4AFP8 and NVFP4 variants only work on specific newer Nvidia generations with vLLM. On older cards or a regular PC, stick with GGUF.
In the PocketPal AI smartphone app, you find the model by searching for 'plamo'. Then pick a quantization, download it and tap 'Load' before translating.
“out of memory,” a crash, or your computer freezes
The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.
It runs, but extremely slowly
Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).
“ollama” or “python” is not found
Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.
Windows: "Running scripts is disabled on this system"
Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.
Error message when loading the model (version, "trust_remote_code", unknown architecture)
Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.
Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: custom license (see Model Card).
Ask the AI assistant
Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.
The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.
Comments
What do you think? Already tried it? Write it here, no sign-up needed.
Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.