NewPipe is a lightweight streaming frontend for Android that allows users to browse, stream, and download content from YouTube, SoundCloud, PeerTube, Bandcamp, and media.ccc.de without using official APIs or requiring a Google account. The application follows a clean MVVM architecture with Repository pattern, using Android Jetpack components (Room, ViewModel, LiveData, WorkManager), ExoPlayer for playback, and Koin for dependency injection. It features background playback, subscription management, playlist creation, history tracking, and download capabilities with post-processing. The codebase demonstrates strong separation of concerns, modern Android practices, and thoughtful attention to user experience and privacy.
i18next is a mature, full-featured internationalization (i18n) library for JavaScript and TypeScript, used in production by thousands of projects across web (browser), Node.js, and Deno environments. It provides a complete translation pipeline: key-based lookup with namespaces, interpolation of variables ({{var}}), nesting of translations ($t(...)), pluralization via Intl.PluralRules (with ordinal support), context variants, and rich formatting (number, currency, datetime, relative time, list) using Intl APIs. The library is backend-agnostic: resources can be loaded synchronously or asynchronously from any source (files, HTTP, databases) via a plugin system, with built-in retry logic and parallel-read throttling. It also includes language detection, fallback chains, post-processing, and an event system for lifecycle hooks. The architecture is modular and event-driven. The core I18n class orchestrates initialization, plugin registration (via .use()), and delegates translation to the Translator. The Translator resolves keys using LanguageUtils (hierarchy/fallback), PluralResolver, and Interpolator, then looks up strings in the in-memory ResourceStore. The BackendConnector manages async loading from backends. The library exposes a selector API (keyFromSelector) that uses a revocable Proxy to collect property paths, enabling type-safe key construction in TypeScript. TypeScript support is extensive: users can augment CustomTypeOptions or ResourceNamespaceMap to get compile-time validation of translation keys, interpolation variables, and return types. Key entry points are the default instance (i18next.t(), i18next.init()) and factory methods (createInstance, getFixedT). The library has zero runtime dependencies; all external integrations (React, filesystem backends, language detectors) are separate packages. The codebase demonstrates high craftsmanship: performance-critical paths are optimized (caching of plural rules, language hierarchies, compiled regexps), security issues (ReDoS, prototype pollution, log injection) have been systematically addressed, and the type system is one of the most sophisticated in the JavaScript i18n ecosystem.
NextAI Translator is a multi-platform translation application that provides text translation, polishing, summarization, and OCR capabilities using various LLM providers. It operates as a browser extension (Chrome/Firefox), desktop application (Windows/macOS/Linux via Tauri), userscript, and Safari extension. The application features a modular architecture with shared core logic and platform-specific implementations, supporting real-time text selection translation, translation history, vocabulary management, customizable actions, and text-to-speech functionality. Built with React, TypeScript, and Vite, it employs sophisticated cross-platform abstractions for fetch operations, settings management, and AI provider integration.
This repository is the core library for @ngx-translate/core, a mature and widely-used internationalization (i18n) solution for Angular applications. It provides a comprehensive set of tools including a translation service, pipe, directive, and structural directive, all built on Angular's dependency injection and signal-based reactivity. The architecture follows a plugin pattern with injectable abstractions for loaders, compilers, parsers, and missing translation handlers, allowing users to customize behavior. Key features include hierarchical scoping (parent-child fallback and isolated subtrees), support for multiple translation loaders (including an HTTP loader in a companion package), and a signal-based `translate()` function that reactively updates when keys, parameters, or languages change. The library is thoroughly tested with over 30 spec files and maintains compatibility across Angular 16–21 via a compatibility matrix. The codebase demonstrates strong engineering practices: clean separation of concerns, well-defined interfaces, and extensive use of Angular's provider functions for configuration. While the library is feature-rich and production-ready, it carries some legacy patterns (deprecated content-as-key directive) and a large monolithic test file that could benefit from refactoring.
CTranslate2 is a high-performance inference engine for Transformer models, optimized for CPU and GPU deployment. It supports a wide range of architectures including encoder-decoder (BART, T5, NLLB, M2M-100, Whisper), decoder-only (LLaMA, GPT-2, Mistral, Gemma, Qwen), and encoder-only (BERT, DistilBERT, XLM-RoBERTa) models. The system provides a C++ library with Python bindings, a command-line tool (ct2-translator), and converters from popular frameworks like HuggingFace Transformers, Fairseq, Marian, OpenNMT-py/tf, and OPUS-MT. Key features include quantized inference (INT8/INT16/FP16/BF16/AWQ), flash attention, multi-GPU tensor parallelism, streaming generation, and token-level penalties. The architecture follows a modular design with device-agnostic operations, layer abstractions, and a model registry that allows plugging in new architectures without modifying the core engine. The codebase is actively maintained with frequent releases, extensive test coverage (C++ and Python), and CI pipelines for multiple platforms and backends.
PDFMathTranslate is a production-grade CLI and GUI application for translating PDF documents while preserving scientific formatting (formulas, charts, tables, and fonts). It uses an ONNX-based layout detection model (DocLayout-YOLO) to understand document structure, supports OCR for scanned PDFs, and integrates with numerous translation services (Google, DeepL, OpenAI, Ollama, etc.). The system operates as a monolithic package with multiple entry points: a command-line tool, a Gradio web interface, a Flask+ Celery HTTP API, and an MCP server for AI assistant integration. Internally, it follows a pipeline architecture: input PDF → optional OCR → layout analysis → text extraction → translation (with caching) → typesetting → bilingual output PDF. Notable engineering patterns include a pluggable translation backend via a kernel registry, a configurable translator base class with retry and caching, and a singleton configuration manager. The code is well-structured with test coverage and CI/CD pipelines, though the dependency on a Git submodule for the 'precise' kernel introduces minor coupling risk.
This repository contains the source code for Comprehensive Rust, a multi-day Rust course developed by the Android team at Google. It is structured as an mdBook with slides, speaker notes, interactive code examples, and exercises. The course covers Rust fundamentals, Android and Chromium integration, bare-metal development, concurrency, async, unsafe Rust, and idiomatic patterns. The codebase includes custom mdBook preprocessors (mdbook-course for structured course scheduling, mdbook-exerciser for extracting exercise starter files), a developer automation tool (xtask), and a comprehensive CI/CD pipeline that builds the book in multiple languages, runs Rust tests via Bazel and Cargo, and performs browser-based WebDriverIO tests. While the primary output is educational content, the tooling infrastructure is well-engineered and demonstrates reusable patterns for structured documentation and exercise management. The repository is actively maintained with frequent commits, issue triage, and translation support for over 17 languages.
Gettext is an internationalization (i18n) and localization (l10n) library for Elixir applications. It provides macros for marking strings in source code that need translation, extracts these strings into POT (Portable Object Template) files, and merges them with PO (Portable Object) files for different locales. At runtime, it looks up translations based on the current locale and supports features like pluralization, context-based translations, domain-specific messages, and string interpolation with compile-time optimization. The architecture follows a library pattern with clear separation between the API (Gettext module), backend behavior (Gettext.Backend), compilation (Gettext.Compiler), extraction (Gettext.Extractor), merging (Gettext.Merger), and specialized components for interpolation, pluralization, and fuzzy matching.
The intl-t repository is a fully-typed, object-based internationalization (i18n) library for TypeScript, React, and Next.js applications. It provides a translation engine that allows developers to access nested translation objects via property traversal (e.g., `t.page.section.title`) with full TypeScript safety. The library supports ICU message formatting for plurals, selections, and variable injection, including the ability to embed React components within translated strings. Architecturally, the library is structured as a monorepo with separate packages for core logic, framework integrations (React and Next.js), utilities, formatting, type declaration generation, and locale definitions. The core package is framework-agnostic and uses proxies to enable lazy loading of locale-specific translation trees for code splitting. Framework-specific packages provide hooks, context providers, middleware, and routing helpers tailored to React and Next.js, including Next.js App Router support for server components and static rendering. The library emphasizes zero external dependencies, modern JavaScript features, and type safety. It includes a CLI tool for generating TypeScript definitions from JSON translation files, ensuring that translation keys are fully typed and IDE-friendly. The Next.js integration offers automatic locale detection, URL localization, and caching mechanisms optimized for server-side rendering and edge environments.
TranslateBooksWithLLMs is a full-stack web application for translating eBooks (EPUB, DOCX, TXT, SRT) using multiple LLM providers (Ollama, OpenAI, Gemini, Mistral, DeepSeek, Poe, OpenRouter, NVIDIA NIM, LiteLLM). The architecture is a Flask server with Socket.IO for real-time progress streaming, a JavaScript SPA frontend with i18n support across 7 locales, and a SQLite-based checkpoint/resume system for interrupted translations. The core pipeline extracts content with HTML/XML placeholder preservation, chunks text using tiktoken-aware splitting, translates via configurable LLM providers with multi-phase fallback (LLM → token alignment → original), and reconstructs the output file. Additional features include glossary management with NER-based term suggestion, style extraction from source text, TTS generation via Edge-TTS and Chatterbox, and a comprehensive benchmark framework for evaluating translation quality across 35+ languages. The codebase demonstrates strong engineering with clean abstractions (adapter pattern for formats, factory pattern for LLM providers, generic orchestrator for translation pipeline), extensive testing (unit, integration, characterization with golden snapshots, e2e), and several genuinely reusable components. Notable patterns include a token-aware chunker with exact reassembly, an API key pool with round-robin rotation on 429 responses, an ordered concurrent executor that preserves chunk ordering, a retry manager with exponential backoff and circuit breaker, and a placeholder system for preserving HTML/XML structure during LLM translation. The benchmark subsystem and prompt optimization tool are supporting features that add research value but are secondary to the core application purpose.
This is a monorepo for General Translation (GT), a comprehensive internationalization (i18n) and localization (l10n) platform. It provides runtime libraries for React, Next.js, Vue, React Native, Node.js, and Python frameworks, enabling developers to translate entire React components—not just strings—using a simple `<T>` wrapper. The platform includes a CLI for extracting translatable strings from source code, uploading them to a translation service, and downloading completed translations. A Babel/SWC compiler injects translation hashes at build time, and a Sanity CMS plugin manages document-level translations. The architecture is a multi-package monorepo with shared core types, a compiler pipeline, framework-specific adapters, and a cloud API client. The codebase demonstrates high craftsmanship with clean abstractions like condition stores, singleton caches, batch processing utilities, and a step-based workflow pattern. It is actively maintained with extensive test coverage and modern tooling (pnpm, Turborepo, TypeScript, Vitest).
Read Frog is a browser extension for AI-assisted language learning. It provides in-page translation, video subtitle translation, text-to-speech, and a selection toolbar with custom AI actions. The extension supports over 30 language model and translation providers, configurable via a unified provider interface, with features like automatic page translation, hover translation, and AI-powered note suggestions. The architecture is built on the WXT framework (MV3) for cross-browser compatibility, with a background service worker orchestrating translation queues, caching, and state management. The frontend uses React 19, Jotai for state, TanStack Query for data fetching, and a custom Base UI component library. The codebase is highly modular with extensive test coverage, a versioned configuration migration system (100+ schema versions), and sophisticated DOM manipulation for in-place translation.
EinkBro is a full-featured Android WebView-based browser specifically optimized for e-ink displays. It provides a rich reading experience with features like ad blocking (via a native C++ engine forked from Brave), paragraph-level translation (Google/DeepL/OpenAI/Gemini), text-to-speech (Edge TTS, system TTS, Web Speech polyfill), reader mode, EPUB reading, user script support, and AI agent capabilities (chat-with-web, multi-step browsing tasks). The architecture is a monolith Android app with three Gradle modules (app, ad-filter, adblock-client) using Kotlin, Jetpack Compose, Koin DI, Room database, and OkHttp. Key entry points include BrowserActivity (main browser), EBWebView (custom WebView wrapper), and various delegate classes for tab management, translation, AI chat, and gesture handling. The codebase demonstrates strong engineering practices with extensive unit tests, a well-structured delegate pattern, and several reusable components such as type-safe SharedPreferences delegates, a standalone PDF parser, and a jsdom-based test harness for WebView-injected JavaScript.
C2Rust is a compiler toolchain that translates C99 code into unsafe Rust, then applies static analysis and refactoring to produce safer, more idiomatic Rust. The pipeline consists of four main stages: transpilation (c2rust-transpile) using a Clang-based AST exporter to produce initial Rust code; static analysis (c2rust-analyze) that infers pointer permissions and rewrites raw pointers to safe references using a Polonius-based borrow checker; refactoring (c2rust-refactor) which applies dozens of AST transformations (e.g., ownership splitting, macro collapsing, control flow reconstruction) to improve code quality; and postprocessing (c2rust-postprocess) that leverages large language models to transfer C comments and align definitions. The project also includes a cross-checking framework that instruments both C and Rust code to compare runtime behavior via hashing, a program dependence graph (PDG) builder for memory safety analysis, and dynamic instrumentation for event logging. It is primarily a CLI tool (c2rust) that orchestrates these components, with extensive integration tests on real-world C projects (nginx, curl, sqlite, ruby, python2, libxml2, zstd, lua). The codebase is substantial and actively maintained, but relies heavily on unstable rustc internal APIs and LLVM/Clang, introducing maintenance risk. Several components exhibit high craftsmanship and are reusable in isolation.
Koharu is a desktop application for manga/comic translation, built with Rust (Tauri) and a React/TypeScript frontend. It provides an end-to-end pipeline: page import, AI-based layout detection, speech bubble segmentation, OCR (multiple models including Manga OCR, PP-OCRv6, Baberu OCR), text translation (local LLMs via llama.cpp and 13+ remote providers), inpainting (LaMa, AOT, FLUX.2 Klein, RORem mixed), and typesetting with CJK/RTL support. The application features a WebGPU canvas editor, project management with undo/redo, PSD export, and an AI agent (Codex) for natural-language editing. The architecture is modular: a scene graph document model (koharu-scene), content-addressed blob storage (koharu-storage), a pipeline orchestrator (koharu-pipeline), and a hardware abstraction layer (koharu-runtime) for CUDA/ROCm/Vulkan/Metal. The frontend uses a custom UI component library (packages/ui) built on @base-ui/react. While the codebase is well-structured and actively maintained, it has technical drift risks from pinned git dependencies, multiple ML model ports that must stay synchronized with upstream, and platform-specific runtime packages.
This repository contains a PotPlayer subtitle translation plugin written in AngleScript. It provides real-time subtitle translation by sending subtitle text to OpenAI-compatible chat completion APIs. Two variants are included: one with context (sends recent subtitles for better accuracy) and one without (faster, no context). The plugin handles configuration via a dual-layer system: installer-injected defaults that can be overridden by PotPlayer's settings panel. It supports retry logic, request delays, hallucination detection, small model mode, and context caching (including OpenAI prompt caching and Gemini cached content). The installer is a separate component built with Inno Setup that provides a GUI for selecting variant, configuring API settings, and injecting defaults into the script files. The code demonstrates solid engineering with careful error handling, configuration precedence, and extensibility for multi-provider support.
This repository is a userscript/browser extension that provides real-time Japanese-to-Chinese translation for the Granblue Fantasy game website. It intercepts XHR requests to the game's API and modifies JSON responses to replace Japanese text with translations, while also translating HTML content on the page. The application uses a modular architecture with separate translation modules for different game systems (battle, scenario, skills, etc.) and includes a data processing pipeline that converts CSV translation files into JSON format for efficient lookup. Key features include configurable settings, voice subtitles, translator attribution, and optional AI translation fallback.
This repository hosts a Chinese translation of the Software Foundations textbook series, providing an interactive web-based platform for learning formal methods and programming language theory using the Coq proof assistant. The architecture consists of volume-specific directories (LF, PLF, QC, SECF, SLF, VC, VFA) containing Coq source files, generated HTML, and shared interactive components. Key features include in-browser Coq proof checking via jsCoq, proof visibility toggling, bilingual term highlighting, and slide presentation mode. The system relies on external dependencies like jsCoq, jQuery, and jQuery UI for its interactive functionality.
This repository is a multi-language, open-source linear algebra textbook built with Quarto. It is not a software application or a data research pipeline; it is a documentation project that produces static HTML, PDF, EPUB, and LaTeX outputs. The core code consists of a Makefile for build automation, Python scripts for machine translation of the book content into six languages (Chinese, Vietnamese, Japanese, Korean, Spanish, German), and GitHub Actions workflows for CI/CD and deployment to GitHub Pages. The translation pipeline is the most sophisticated software component, featuring chunking with math/protection, SHA-256 checkpointing for resumability, parallel workers, and verification of translation completeness. The book content itself is extensive (100+ labs) but is structured as Quarto markdown files. The repository is actively maintained with recent commits, a changelog, and issue tracking. The primary value is educational, but the translation infrastructure and Quarto multi-language book pattern are reusable assets for other documentation projects.
BLURR is a library that integrates Hugging Face transformers with fastai for NLP tasks. It provides high-level, mid-level, and low-level APIs to train and deploy transformer models for text classification, token classification, question answering, summarization, translation, and language modeling. The library leverages fastai's data block API and learner system, wrapping Hugging Face models to work seamlessly within the fastai training loop. Key components include custom data blocks for text processing, model wrappers for Hugging Face integration, specialized loss functions, and callbacks for optimization. The repository includes extensive examples and notebooks demonstrating usage with standard datasets like GLUE, SQuAD, and CNN/DailyMail.