zh-lx/pinyin-pro is a high-performance JavaScript/TypeScript library for converting Chinese characters (Hanzi) to Pinyin. It is used both in browsers and Node.js environments, supporting a wide range of output formats (tone marks, tone numbers, initials, finals, etc.) and advanced features like surname detection, tone sandhi, polyphonic character handling, word segmentation, and fuzzy text matching. The library is organized as a monorepo with three packages: the core `pinyin-pro` library, a `@pinyin-pro/data` package containing large curated dictionaries (modern, complete, traditional, buddhist), and documentation sites in Chinese and English. Architecturally, the core employs a middleware pipeline to process input text through sequential transformations (non-Chinese handling, pattern extraction, tone type conversion, etc.). It uses an Aho-Corasick automaton for efficient phrase matching against its multi-tier dictionaries (single characters to multi-word phrases). Multiple tokenization strategies (reverse max match, max probability, min tokenization) are implemented for word segmentation. The library has been heavily optimized for performance, achieving ~99.8% accuracy in benchmarks and competitive speed with native Rust-based alternatives. Key entry points are the `pinyin()` function for basic conversion, and additional functions for matching (`match`), segmentation (`segment`), HTML ruby annotation (`html`), polyphonic listing (`polyphonic`), custom dictionary management (`customPinyin`, `addDict`), and format conversion (`convert`). External dependencies are minimal: the library runs entirely on its built-in dictionaries and does not require any runtime dependencies. The codebase is well-tested (vitest) with a dedicated CI pipeline (GitHub Actions) for quality assurance, bundle size comparison, and automated release.
Kagome is a self-contained Japanese morphological analyzer written in pure Go. It provides tokenization with part-of-speech tagging, multiple segmentation modes (normal, search, extended), and dictionaries embedded in the binary for easy deployment. The system includes a CLI tool with subcommands (tokenize, server, lattice, sentence), a RESTful API server mode, WebAssembly support for browser use, and C library API for FFI integration with languages like Python and PHP. The architecture centers around a lattice-based Viterbi algorithm for tokenization, with clean separation between tokenizer logic, dictionary handling, filtering utilities, and interface layers.
Patina is a deterministic, pattern-based AI text detection and humanization tool, primarily targeting Korean but supporting English, Chinese, and Japanese. It operates as a Node.js CLI (`patina-cli`), a web API (Vercel serverless), and an agent skill (Claude Code, Codex, Cursor). The core workflow: analyze source text for AI-typical patterns (stylometry, lexicon, discourse tells), build a structured prompt, invoke an LLM backend (OpenAI, Claude, Gemini, Kimi, etc.), verify meaning preservation (MPS/fidelity), and output a humanized rewrite with a deterministic audit trail. It enforces strict meaning guards (number safety, polarity, causation) and provides scoring, diff, and verification modes. The architecture is modular: a shared deterministic analysis core (`src/features/`) runs identically in Node and browser; a prompt builder assembles context from pattern packs, document types, and personas; multiple backend adapters abstract LLM invocation; and a verification pipeline ensures fidelity. The project includes extensive research infrastructure (benchmarking, human evaluation panels, corpus management) and a commercial Pro tier with Polar license validation. It is well-tested with over 200 unit/e2e tests, CI/CD, and security hardening (SSRF guards, input fencing, atomic writes).
OneFileLLM is a versatile CLI tool and web application designed to process diverse inputs (local files, GitHub repositories, YouTube transcripts, arXiv papers, web pages, etc.) into a single structured XML-like output optimized for LLM consumption. The system features format-specific processors that extract and convert content (e.g., Excel to markdown, PDF text extraction, Jupyter notebook to code), token counting via tiktoken with optional NLTK-based compression, and metadata reporting. It includes a Rich-powered terminal interface with colored output and progress bars, a Flask-based web app with Server-Sent Events for real-time progress updates, and an alias system for JSON-stored shortcuts with placeholder substitution. Security is prioritized through SSRF protection, local path validation, and offline mode support. The architecture separates core processing logic (onefilellm.py), CLI handling (cli.py), utilities (utils.py), and web components (extras/web_app.py), enabling modular reuse.
Baleia.nvim is a Neovim plugin that colorizes text with ANSI escape sequences (8, 16, 256 or TrueColor). It processes buffers containing ANSI codes, strips them from the text while applying appropriate syntax highlighting, and supports both manual and automatic colorization modes. The architecture features modular Lua components handling ANSI parsing (ansi.lua), lexical analysis (lexer.py), asynchronous processing (scheduler.lua), and Neovim highlight rendering (renderer.lua). The plugin integrates with Neovim's buffer system through autocommands and API functions, efficiently handling large files via chunked processing.
This is a Blender add-on for renaming various types of data in 3D scenes, including objects, materials, bones, collections, and other data blocks. It provides a comprehensive set of renaming tools accessible through Blender's interface, allowing users to add prefixes/suffixes, perform search and replace operations, transform text case, apply sequential numbering, and trim strings from names. The add-on features a variable system that enables dynamic naming patterns using placeholders like @n for numbers, @f for the current filename, @d for date, and others. It includes intelligent conflict handling that detects when Blender would automatically modify a requested name due to existing duplicates, and either skips the renaming or finds an alternative name rather than accepting Blender's default behavior which could cause confusion in batch operations. Architecturally, the add-on follows Blender's standard extension structure with clearly separated modules for operators (the actual renaming functions), user interface components, preferences, and utilities. It employs performance optimizations such as caching collection membership and object ownership relationships to avoid repeated lookups during batch renaming operations. The tool provides real-time feedback through popup windows showing what was renamed, what was skipped due to conflicts, and any warnings. The project maintains active development with regular updates and testing across multiple Blender versions (from 4.2 to 5.1 as shown in CI workflows). It includes a comprehensive test suite that validates functionality and performance benchmarks to ensure operations scale efficiently with scene complexity. The combination of thoughtful design, attention to edge cases, and ongoing maintenance makes it a reliable tool for managing naming conventions in Blender projects.
This is an Obsidian plugin that provides a highly configurable markdown linter and formatter. It implements over 50 individual rules organized by type (YAML, headings, content, spacing, footnotes, paste) using a clean rule-builder pattern with decorators. The plugin integrates deeply with the Obsidian editor, supporting lint-on-save, paste transformations, custom commands, regex replacements, and a comprehensive settings UI with tabs and search. It includes an extensive test suite (unit and integration) and auto-generates documentation from rule definitions. The architecture is modular: each rule is a self-registering class with typed options, examples, and option builders that also drive the settings UI. Shared utilities for YAML manipulation, markdown AST transformations, and ignore-type masking are well-isolated and reusable. The codebase is actively maintained with frequent commits and responsive issue triage.
RE2 is a C++ regular expression library designed for safety and performance, guaranteeing linear-time matching to prevent ReDoS attacks. It provides a thread-safe, immutable API for compiling and executing regex patterns with full Unicode support. The library uses multiple matching engines (DFA, NFA, OnePass, BitState) with automatic fallback based on pattern complexity. Beyond the core C++ library, it includes Python bindings, a WebAssembly demo, and extensive test/fuzz suites. RE2 is used in production at Google and widely adopted for applications requiring reliable, high-performance regex matching.
This repository contains a mentions plugin for the Lexical text editor, along with a Next.js demo application. The plugin provides advanced mentions functionality including customizable triggers, multiple trigger support, automatic spacing, async query functions, customizable styling, and programmatic manipulation of mentions. The architecture consists of a core plugin implementation in the 'plugin' directory and a demonstration application in the 'www' directory. The plugin follows a modular design with separate concerns for UI components, state management, text processing, and editor integration. Key features include mention detection via regex, custom node implementation for Lexical, and hooks for managing asynchronous data fetching with proper loading states.
hotpdf is a Python library for fast and memory-efficient PDF text extraction and search. It wraps pdfminer.six to load PDF pages into memory using a sparse matrix representation, a trie for text search, and a span map for grouping characters. The library provides a HotPdf class with methods to find text (with options for case sensitivity and span extraction), extract text from bounding boxes, extract spans, and merge multiple PDF documents. The architecture separates concerns into processing (processor.py), memory mapping (memory_map.py), data structures (data/classes.py), and utilities (utils.py).
TextBlob is a Python library for processing textual data, providing a simple, intuitive API for common natural language processing (NLP) tasks such as sentiment analysis, part-of-speech tagging, noun phrase extraction, tokenization, spelling correction, and classification. It wraps NLTK and a vendorized subset of the pattern library, offering a unified interface that feels like working with Python strings. The library is designed as a monolithic package with a pluggable architecture: abstract base classes define interfaces for taggers, tokenizers, sentiment analyzers, and parsers, allowing users to swap implementations. Core classes include TextBlob, Word, Sentence, Blobber (a factory for sharing models), and WordList. The codebase is well-structured, employs lazy loading and caching for performance, and includes a format registry for reading data files (CSV, JSON, TSV). While primarily a library for application integration, it also bundles linguistic data files (lexicons, spelling frequencies, sentiment lexicons) that are used for research-oriented tasks. The project is actively maintained, supports Python 3.10–3.14, and uses modern tooling (GitHub Actions, renovate, pre-commit).
Ruplacer is a command-line tool written in Rust for finding and replacing text in files. It supports literal string, regex, and case-preserving replacements, and provides a diff-like output of changes. The tool respects .gitignore, allows filtering by file type, and can operate in a dry-run mode. The architecture is modular, with separate modules for argument parsing, console output, directory traversal, file processing, and the core replacement logic. The replacement logic is particularly notable for its use of the strategy pattern to handle different matching algorithms in a uniform way.