FluentRead Translation Services: Complete Guide to Supported Providers and APIs

FluentRead supports over 30 translation backends, including traditional machine translation APIs (Google, DeepL, Microsoft) and modern LLM-based AI services (OpenAI, Gemini, Claude, DeepSeek), all managed through a centralized registry in src/entrypoints/utils/option.ts.

The bistutu/fluentread repository is an open-source browser extension that provides immersive bilingual reading experiences. Understanding which translation services are supported by FluentRead is essential for configuring the optimal backend for your specific language pairs and quality requirements.

Overview of FluentRead Translation Services

FluentRead implements a unified service architecture that abstracts the differences between traditional machine translation engines and generative AI models. The extension categorizes providers into two main groups: conventional MT services optimized for speed and cost, and large language model (LLM) services offering contextual, nuanced translations.

All service identifiers, human-readable names, and capability flags are defined in the centralized registry at src/entrypoints/utils/option.ts, while concrete implementations reside in src/entrypoints/service/_service.ts and individual service modules.

Complete List of Supported Translation Providers

Traditional Machine Translation Services

FluentRead integrates with established machine translation APIs that prioritize speed and affordability:

• Microsoft Translator (microsoft) – Enterprise-grade neural machine translation
• DeepL (deepL) – High-quality European language specialist
• DeepLX (deeplx) – Community alternative for DeepL API access
• Google Translate (google) – Broad language coverage and reliability
• Xiaoniu (xiaoniu) – 小牛翻译, Chinese MT specialist
• Youdao (youdao) – 有道翻译, popular Chinese-English translation
• Tencent Cloud (tencent) – 腾讯云翻译, enterprise Chinese MT
• Chrome Translator (chromeTranslator) – Chrome内置 AI 翻译, leveraging browser-native capabilities

AI and Large Language Model Translation Services

For context-aware, high-quality translations, FluentRead supports major LLM providers:

• OpenAI (openai) – GPT-4, GPT-3.5-turbo models
• Azure OpenAI (azureOpenai) – Enterprise OpenAI deployment
• Gemini (gemini) – Google's multimodal AI models
• Wenxin Yiyan (yiyan) – 文心一言, Baidu's LLM
• Tongyi (tongyi) – 阿里通义, Alibaba's Qwen models
• Zhipu (zhipu) – 智谱清言, ChatGLM models
• Moonshot (moonshot) – Kimi AI assistant
• Claude (claude) – Anthropic's Claude models
• DeepSeek (deepseek) – DeepSeek's cost-effective LLMs
• Grok (grok) – X.AI's Grok models
• Custom (custom) – User-defined OpenAI-compatible endpoints
• Additional providers: Infini (无向芯穹), Baichuan (百川智能), Lingyi (零一万物), MiniMax, Jieyue (阶跃星辰), Groq, Coze (国际/国内), HuanYuan (腾讯混元), Doubao (字节豆包), SiliconCloud (硅基流动), OpenRouter, NewAPI

How FluentRead Manages Translation Services

Centralized Service Registry

The extension uses a single source of truth for all supported backends. In src/entrypoints/utils/option.ts, the services constant enumerates every available provider:

import { services } from '@/entrypoints/utils/option';

// Access service identifiers
console.log(services.google);    // 'google'
console.log(services.openai);  // 'openai'

This registry includes human-readable labels, default configurations, and feature classifications that the UI consumes to render service selection dropdowns.

Dynamic Service Dispatch

Concrete implementations are mapped to identifiers in src/entrypoints/service/_service.ts. The _service object acts as a dispatcher:

import { _service } from '@/entrypoints/service/_service';
import { services } from '@/entrypoints/utils/option';

// Dynamic invocation
const translate = _service[services.deepL];
const result = await translate({ text: 'Hello', to: 'zh-Hans' });

This architecture decouples the UI and translation logic from specific provider implementations, allowing new services to be added by simply creating a handler module and registering it in the dispatcher.

Feature Flags and Service Classification

FluentRead categorizes services by capabilities using helper sets in option.ts:

• servicesType.useToken: Services requiring API keys (OpenAI, DeepL, etc.)
• servicesType.useProxy: Services requiring proxy configuration
• servicesType.useCustomUrl: Services supporting custom endpoints (Custom, DeepLX, etc.)

These classifications enable the settings UI to conditionally display configuration fields based on the selected service.

Configuring Translation Services in FluentRead

Selecting a Default Service

Configure the active translation backend by modifying the defaultOption object:

import { defaultOption, services } from '@/entrypoints/utils/option';

// Set Microsoft Translator as default
defaultOption.service = services.microsoft;

// Or use an AI model like Gemini
defaultOption.service = services.gemini;

Using the Translation Queue

FluentRead implements a concurrency-controlled queue to manage translation requests. Here's how to enqueue a translation task:

import { enqueueTranslation } from '@/entrypoints/utils/translateQueue';
import { _service } from '@/entrypoints/service/_service';
import { services } from '@/entrypoints/utils/option';

const text = 'Hello world';
const targetLang = 'zh-Hans';
const chosenService = services.google;

// Wrap the service call for queue management
const task = () => _service[chosenService]({ text, to: targetLang });

enqueueTranslation(task)
  .then(result => console.log('Translation:', result))
  .catch(err => console.error('Failed:', err));

The queue respects config.maxConcurrentTranslations (defaulting to 6) to prevent rate limiting.

Configuring Custom Endpoints

For OpenAI-compatible APIs or self-hosted solutions, use the custom service:

defaultOption.service = services.custom;
defaultOption.custom = 'https://my.custom.api/v1/translate';

The custom service is classified under servicesType.useCustomUrl, ensuring the UI exposes the custom URL input field when selected.

Key Implementation Files

File	Purpose
entrypoints/utils/option.ts	Defines the services registry, defaultOption, and capability classification sets
entrypoints/service/_service.ts	Maps service identifiers to concrete implementation functions
entrypoints/service/*.ts	Individual backend implementations (e.g., google.ts, openai.ts, deepl.ts)
entrypoints/utils/translateQueue.ts	Concurrency-controlled queue for managing translation requests
components/SelectionTranslator.vue	UI component for service selection dropdown

Summary

• FluentRead supports 30+ translation services ranging from traditional machine translation APIs to modern LLM providers.
• The centralized registry in entrypoints/utils/option.ts serves as the single source of truth for available backends.
• Dynamic dispatch through entrypoints/service/_service.ts decouples the UI from specific provider implementations.
• Services are classified by capabilities (token usage, proxy requirements, custom URL support) to drive UI configuration options.
• The translation queue manages concurrency to prevent rate limiting when using multiple services.

Frequently Asked Questions

How do I add a new translation service to FluentRead?

To add a new backend, create a TypeScript module in entrypoints/service/ that exports a translation function matching the signature (params: {text: string, to: string, ...}) => Promise<string>. Then register the service identifier in entrypoints/utils/option.ts under the services constant, and map the identifier to your implementation in entrypoints/service/_service.ts. The UI will automatically pick up the new service if you add it to the appropriate capability sets (e.g., useToken if it requires an API key).

Does FluentRead support local or self-hosted translation models?

Yes, FluentRead supports custom endpoints through the custom service identifier. Configure defaultOption.service = services.custom and set defaultOption.custom to your local API URL (e.g., http://localhost:5000/translate). The custom service expects an OpenAI-compatible interface, making it compatible with self-hosted solutions like Ollama, LocalAI, or vLLM.

What is the difference between DeepL and DeepLX in FluentRead?

DeepL (deepl) uses the official DeepL API with proper authentication and rate limits, requiring a valid API key. DeepLX (deeplx) is a community-maintained alternative that provides access to DeepL's translation capabilities without requiring an official API key, often used for personal or low-volume scenarios. DeepLX is classified under servicesType.useCustomUrl because it typically requires specifying a custom endpoint URL.

How does FluentRead handle rate limiting when using multiple translation services?

FluentRead implements a concurrency-controlled translation queue in entrypoints/utils/translateQueue.ts that limits simultaneous requests to config.maxConcurrentTranslations (defaulting to 6). When you trigger a translation, the service call is wrapped in a task function and enqueued. The queue ensures that even if you rapidly switch between services or translate large volumes of text, no more than 6 concurrent requests hit the APIs at once, preventing rate limit errors and respecting provider quotas.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}