EVERY QUESTION.
UNCOMPROMISING ANSWERS.

Pick the pipeline that matches your priority — all three translate the same detected bubbles:

• Easiest to run — Local pipeline. Install the extension, let the models download once, translate offline. No keys, no server, no account.
• Best quality, least friction — Gemini mode. Paste a free AI Studio key and the cloud pipeline handles OCR plus translation in one pass. Hard to beat on accuracy — the trade-off is your annotated pages go to Google.
• Full control — API Mode. Point LMT at a local server (llama.cpp, Ollama, LM Studio, Jan, KoboldCpp) and you unlock the whole GGUF ecosystem. The trade-off is yours to manage: finding the best model and fine-tuning your own server configuration.

No — no account, no registration, no sign-in. "You decide where your data goes" is literal: we collect nothing, there is no telemetry, and no LMT-operated server or proxy exists. Every request — Gemini or your own server — goes directly from your device to that endpoint.

Debug logs exist only to help you trace errors: the last 50 attempts stay on your device and we have no access to them. They may contain sensitive page text (source and translated strings), so share them only if you choose to — paste them into a Gitlab issue when reporting a bug.

In Local Mode and API Mode: ABSOLUTELY NOT. All image decoding, RT-DETR bubble detection, PaddleOCR text extraction, and canvas inpainting run 100% locally on your machine in an isolated browser offscreen document.

In API Mode, only extracted text strings (no pixel data) are transmitted to your configured endpoint (such as your local Ollama or LM Studio instance). In Gemini Mode, the annotated manga page is sent directly from your browser to Google AI Studio using your personal API key — with zero proxy server or middleman in between.

No — there is no telemetry at all. The old opt-in bbox-correction upload was permanently removed in v1.0.0 Stable: no toggle exists, no endpoint exists, and Local mode transmits zero bytes anywhere.

Outbound requests happen only when you explicitly enable Gemini Mode (annotated image to Google with your key) or API Mode (extracted text to your server). See privacy.md in the repo.

Yes. Once you select Local Mode and allow the initial model download (Llama-3.2-1B / Qwen3.5-0.8B / Qwen3.5-2B / Qwen3.5-4B, RT-DETR bubble detector ONNX weights, and PaddleOCR language packs) to complete, all weights are cached permanently in browser Cache Storage and IndexedDB. Model downloads are completely opt-in with pause and resume support across the setup wizard, sidebar, and popup.

You can disconnect your network, enable airplane mode, and translate chapters offline without contacting any server.

API Mode works offline too when you point it at an OpenAI-compatible / LM Studio server on the same machine (e.g. Ollama at http://127.0.0.1:11434/v1 or LM Studio at http://127.0.0.1:1234/api/v1) — localhost traffic never needs the internet after setup. Remote LAN / VPS / cloud hosts still need connectivity.

Local mode requires a Chromium browser (Chrome 113+, Edge 113+, Brave). On Firefox, local in-browser translation runs on wllama (llama.cpp compiled to WASM) instead of WebLLM — see DOC #19. Gemini Mode and API Mode work identically on both browsers.

• Llama-3.2-1B-Instruct-q4f16_1-MLC (Compact, ~880 MB): Requires ~0.8 GB available VRAM / unified memory. Replaced Gemma3-1B to avoid sliding-window configuration crashes. Fastest, low footprint for dialogue.
• Qwen3.5-0.8B-q4f16_1-MLC (Ultra-compact, ~1.6 GB): Very low resource requirement, ideal for systems with minimal memory.
• Qwen3.5-2B-q4f16_1-MLC (Balanced, ~2.3 GB): Recommended balance of speed and translation quality for modern laptops and GPUs.
• Qwen3.5-4B-q4f16_1-MLC (Good, ~3.9 GB): High translation reasoning for complex dialogue and idioms.

If your machine lacks a dedicated GPU or has insufficient VRAM, Local mode will notify you and recommend switching to API Mode or Gemini Mode.

Ollama provides an OpenAI-compatible endpoint at port 11434. Follow these steps:

# 1. Pull the recommended translation model
ollama pull qwen3.5:4b

# 2. Start the Ollama server
ollama serve

Then open LMT Settings › Backend and set:

• Backend Kind: API Mode
• Host URL: http://127.0.0.1:11434/v1
• Schema: OpenAI
• Model Name: qwen3.5:4b

Click Test Connection to verify communication.

In LM Studio, navigate to the Developer / Local Server tab, select your preferred model (e.g. tiny-aya-global), and click Start Server on port 1234.

In LMT Settings › Backend:

• Host URL: http://127.0.0.1:1234/api/v1
• Schema: LM Studio (Experimental)
• Model Name: Match the exact model identifier loaded in LM Studio

The experimental schema uses native prompt arrays (input + system_prompt) and parses JSON responses directly without forcing OpenAI-style wrapper envelopes.

For API Mode we recommend a model that was built for translation rather than general chat: Tiny Aya Global for general multilingual translation, or Tiny Aya Fire when your reading is CJK-focused (Chinese / Japanese / Korean). Because they are purpose-trained for translation, they tend to produce cleaner, more consistent manga dialogue than a general-purpose model of the same size. Both are distributed as GGUF, so you can load either one in Ollama, LM Studio or llama.cpp and point LMT at your local host URL as usual.

Google provides free tier API keys through Google AI Studio.

1. Sign in with your Google account at aistudio.google.com.
2. Click Get API key and copy your key.
3. In LMT, open Settings › Backend, select Gemini Mode, and paste the key.

Gemini 3.8 Flash, 3.7 Flash, 3.6 Flash and 3.5 Flash handle both OCR and translation in a single pass with high speed. Your key is stored in browser local storage and never leaves your device except to authenticate directly with Google's API endpoints.

Manga is traditionally read from right to left, top to bottom. LMT builds deterministic regions (refineDetections: centre-in-box merge, speckle drop, overlap merge) then applies agglomerative horizontal band clustering (applyBboxesSort):

1. Calculates vertical centers for all bounding boxes and sorts strictly top-to-bottom.
2. Groups dialogue into horizontal panel bands using a gutter threshold (80% of average bubble height).
3. Sorts bubbles within each panel band using Japanese manga diagonal flow (Right-to-Left).

In the bubble editor overlay, you can manually reorder or refine any box before translation.

Yes. On the results view, click the Edit button in the toolbar. This opens Typeset Mode displaying the raw OCR source text alongside the translated output for each numbered bubble.

When you tweak the wording, style, color and click Apply, LMT repaints the typography directly on top of the cached inpainted canvas. Inpainting is skipped entirely, delivering an instantaneous re-render.

Traditional extensions run heavy blur or Fast Marching across the entire bounding box, leaving ugly rectangular gray patches and halo artifacts over screentones.

LMT solves this with a multi-stage engine ladder using text-shaped contour masks:

• Rung 0 (Planar Fill): For flat white or uniform speech bubbles, samples the paper border and executes a smooth gradient fill. Zero noise.
• Rung 1 (Bilateral Denoise): For grainy or JPEG-compressed scans, applies edge-preserving bilateral filtering to prevent ringing.
• Rung 2 (Pure-JS Telea Fast-Marching): Real rebuilds where fill/denoise fail. MV3-safe, no unsafe-eval.

LaMa Redraw (Quality mode): For complex screentone, halftone and art behind text. One-time ~207 MB download, ~500 MB RAM/VRAM, ~7–20s per complex region on GPU (512² tiles, 128px overlap).

Every stage is evaluated against an image quality metric; if a rung degrades the page, it escalates to the next engine. Pick Fast (model-free ladder, default) or Quality (LaMa-first pass, strict superset of Fast) under Render › Inpainting. In v1.0.2, if Quality is selected without downloaded weights, translation skips the neural pass and automatically flips back to Fast without throwing errors or initiating unexpected downloads.

LMT ships with 3 bundled font families: Noto Sans, Bangers, and Comic Neue.

To use your own font:

1. Open extension Settings › Typography.
2. Drag-and-drop any .ttf, .otf, or .woff file into the dropzone.
3. Select your font from the active dropdown.

The font is parsed into browser font storage and dynamically rendered with automatic bubble fit scaling and high-contrast text outlines.

LMT extracts the series title, chapter number, and page index using regex site rules:

• AI Rule Generator: Open the manga chapter in your browser, click the LMT icon › Settings › Site Rules, and click Generate with AI. The active LLM will analyze the page title and URL structure to propose a working rule.
• Submit a Pull Request: Copy src/lib/adapters/_example.ts to src/lib/adapters/<domain>.ts, fill in the 3 regex fields, and submit a PR on Gitlab. It bundles into the next release automatically.

v1.0.2 ships two selectable on-device detectors (Vision › Detection via the shared ModelSelect picker with Cached badges and inline pause/resume downloads, Min Confidence 0.5, manual update checks in System › Model Storage). Popup Home quick-toggles are gated so you cannot switch to an uncached detector until its weights are downloaded:

• Comic Bubble Detector RT-DETR-v2 (default, 11.1 MB, Apache-2.0): Good at bubbles and free-floating text (bubble, text_bubble, text_free).
• Comic Text Detector (94.7 MB, GPL-3.0): Text boxes plus a per-pixel segmentation mask ([1, 1, 1024, 1024]) that seeds fitMask() directly — best for dense vertical Japanese. Never bundled; downloads to your local browser cache only when you select it.

Pick in Vision › Text Recognition (OCR). PaddleOCR (~90 MB, default) is the fast multilingual generalist with 11 per-language packs (Latin + Chinese/Japanese ship at setup, the rest download on first use). PP-OCRv6 Manga (~21 MB) is a Japanese-only manga fine-tune between the two. Manga-OCR (~460 MB, opt-in) is the Japanese manga specialist (ViT encoder + BERT decoder) for vertical text and stylized lettering. Pororo OCR (~74 MB) is the Korean specialist (TPS-VGG-BiLSTM, 2,589 Hangul classes, WASM CPU) for manhwa / webtoon.

OCR Min Confidence defaults to 0.7 with a retry pass at 0.7× on failed crops; single characters demand ≥ max(minConfidence, 0.75) to suppress noise. Held-back regions keep their recognized text so you can still view and edit it.

Switch to Quality for complex screentone, halftone and artwork behind text — where pure-JS fill / denoise / Telea would leave flat patches or smudges. One-time ~207 MB download, ~500 MB RAM/VRAM, ~30–60s per complex region on CPU (512² tiled inference, 128px overlap).

Quality runs LaMa first per region and falls back into Fast wherever LaMa declines — a strict superset of Fast. Per-region provenance ({method, deviation, thickness, ms}) and per-rung counts surface in the debug panel.

System › Model Storage lists every downloaded weight with its size and language badge, plus per-model delete and full cache clear. Deleting a cached model also wipes any retained partial download chunks so the next fetch starts fresh. Detection, OCR and backend pickers share a ModelSelect dropdown with Cached badges and inline download progress with pause/resume support. Onboarding ships Latin + Chinese/Japanese packs; background prefetch warms the cache.

Translation results are keyed by series + chapter + resolved page index (resolveImagePageIndex) + image hash (quickHash), so re-opening a translated chapter is instant.

Run llama.cpp directly as your local server. Both Ollama and LM Studio build on llama.cpp under the hood — going straight to the source drops the extra GUI layers while staying fully OpenAI-compatible for LMT's API Mode.

Start it with llama-server -m <model>.gguf, then in LMT Settings › Backend set Host to http://127.0.0.1:8080/v1, Schema to OpenAI, and click Test Connection as usual.

The payoff is freshness: new model architectures and GGUF quant releases land in llama.cpp first, so same-day model drops work without waiting for the wrappers to catch up.

System › GPU Acceleration holds one master WebGPU switch plus per-area overrides (llm, inpaint, ocr), backed by a shared high-performance adapter probe with automatic WASM fallback. Re-check anytime with the probe button.

Detection, OCR and backend pickers share a ModelSelect dropdown: cached weights show a Cached badge, missing ones offer a single Download ⇄ Pause / Resume toggle with live streaming progress and SHA-256 integrity verification. Downloads are centralized in the background worker: pause in the setup wizard, resume in the sidebar or popup, and starting a new download automatically pauses the active one.

If you can run a server on your own machine, we recommend API Mode with a local LLM server over Local mode. Run llama.cpp, Ollama, LM Studio, Jan, KoboldCpp, or any other OpenAI-compatible server on your device and point LMT at it — you unlock the full GGUF ecosystem instead of the handful of WebGPU builds, and larger translation-tuned models generally produce better manga dialogue.

If you are comfortable with your data reaching Google, the Gemini pipeline is the quality pick: one multimodal pass handles OCR and translation together with excellent results.

Either way, LMT collects nothing. Every API call — Gemini or your own server — goes directly from your device to the target endpoint, with no proxy or middleman in between.

After translation, open the editor to switch between Raw Scan (original page), Cleaned Scan (inpainted background), and Result Scan (final typeset composite) — switching is instant, no re-translation.

On the cleaned layer, draw add-inpaint boxes to clean missed text or stray SFX, or restore-raw boxes to bring back original art. Selecting a bubble shows ContextualStyleBar (font, size, alignment, color) and FloatingRawTextPill (raw OCR transcript). Export saves the active layer to JPEG.

Always Inpaint (sync:always-inpaint in popup and Render › Inpainting) bypasses decline rollbacks so every detected region is cleaned instead of left pixel-identical. The cleanedSrc cache (in-memory + page storage) removes redundant inpaint passes when re-styling text.

Translation is also more resilient: empty OCR boxes are filtered before prompting, bbox-count mismatches self-heal instead of failing the page, overlay geometry tracks reader layout shifts, and editor inputs stay isolated from host-page shortcuts.