Pretext is a high-performance JavaScript/TypeScript library for text measurement and layout that operates entirely without DOM reflow. It accurately predicts line breaks, widths, and heights for any text, matching the behavior of Chrome (Blink), Firefox (Gecko), and Safari (WebKit) by porting each engine's line-breaking rules and embedding their ICU break tables. The library uses a two-phase architecture: a preparation phase that measures each character segment using Canvas `measureText()` and caches the results, followed by a pure-arithmetic layout phase that computes line breaks and positions with sub-millisecond performance. It supports plain text, rich inline spans (styled runs, atomic chips), and advanced features like letter spacing, soft hyphens, emoji handling, and CJK punctuation kerning. A comprehensive test harness records actual browser layouts of thousands of cases and scores predictions against them, with automated gates that block regressions. The repository also includes demos showing virtualized chat, editorial layouts with obstacles, justification comparison, and shrink-wrapping. While primarily an application/library, it contains significant data/research components—generated break tables from browser engines, multilingual corpora for testing, and offline invariants—making it a hybrid project with a strong research character in cross-browser text rendering.
opentype.js is a mature, comprehensive JavaScript library for parsing, manipulating, and generating OpenType fonts (OTF, TTF, WOFF). It runs in both browser and Node.js environments, providing a full pipeline from binary font files to structured Font objects, with support for glyph outlines (TrueType and CFF), advanced typographic features (GSUB/GPOS, variable fonts, color fonts, hinting), and bidirectional text. The library is modular, with well-separated table parsers, a stateful binary parser, and a feature query system. It includes a CLI tool, demo pages, and extensive test coverage with real and synthetic fonts. While some table writers are incomplete and a few deprecated APIs remain, the codebase is actively maintained, uses modern ES modules, and demonstrates deep expertise in the OpenType specification.
pangu.js is a TypeScript text-spacing library that automatically inserts whitespace between CJK (Chinese, Japanese, Korean) characters and half-width letters, numbers, and symbols for improved readability. It ships as an npm package (ESM/CommonJS/UMD) with a Node.js API, a CLI tool, and a Chrome Manifest V3 browser extension. The core spacing engine in `src/shared/index.ts` implements the Paranoid Text Spacing algorithm with dozens of regex rules handling operators, brackets, quotes, punctuation, file paths, HTML tags, and per-line readings for slashes, pipes, and plus signs. The browser layer adds DOM-aware features: `spacingNode()` processes individual elements, `autoSpacingPage()` uses MutationObserver and requestIdleCallback for dynamic content, and boundary-spacing logic decides where to insert spaces between adjacent text runs across markup boundaries. The Chrome extension registers content scripts dynamically based on user settings (blacklist/whitelist, auto vs manual mode) and supports native `text-autospace` CSS as a visual-only layer. The architecture is modular with three build targets: a shared platform-agnostic engine, a Node.js entry with file I/O, and a browser entry with DOM traversal. The build uses Vite with multiple environments to produce self-contained ESM, UMD, and CJS bundles. The project has zero runtime dependencies, extensive test coverage (Vitest for shared/Node logic, Playwright for browser behavior), and a comprehensive set of Architecture Decision Records (ADRs) documenting every significant design choice. The Chrome extension is fully localized in Traditional Chinese and includes sound effects, a popup UI, and an options page for configuring spacing mode, site filters, and native autospacing. Key entry points: `pangu.spacingText()` for plain text, `pangu.spacingNode()` for DOM elements, `pangu.autoSpacingPage()` for live page monitoring, and the CLI (`pangu` command) for file/stdin processing. External dependencies are limited to Node.js built-in modules (`node:fs`, `node:path`) for the Node build; the browser build and shared engine have no dependencies at all. The Chrome extension uses only Chrome extension APIs (`chrome.storage`, `chrome.scripting`, `chrome.tabs`).
Typo.css is a mature, single-file CSS library that provides a comprehensive reset and typography system optimized for Chinese (CJK) web content. It normalizes browser defaults and exposes a `.typo` class container that applies advanced typographic features: CJK-optimized font stacks (sans, serif, mono, kai, fangsong) via CSS custom properties, proper line-height, line-break strictness, Han-Western spacing via `text-autospace`, punctuation trimming via `text-spacing-trim`, hanging punctuation, native emphasis marks with fallback, ruby annotation support, vertical writing mode helper, and readable line-length constraints. The library is dependency-free, uses progressive enhancement (e.g., `@supports` for native emphasis and script-specific generics), and includes a suite of modifier classes for common typographic needs. A comprehensive test suite (Node.js assertion-based) verifies the CSS contract, and detailed documentation explains the design rationale based on W3C CLReq and other standards. The demo page demonstrates real-world usage with SEO metadata. This is a production-ready library for any project requiring high-quality Chinese text rendering, and it is actively maintained with modern CSS best practices.
fontspec is a mature LaTeX package that provides an automatic and unified interface for font selection in XeLaTeX and LuaLaTeX. It allows users to load OpenType, AAT, and Graphite fonts by name or filename, with full control over features such as ligatures, small caps, numerals, script/language selection, colour, scaling, and more. The architecture is modular: a core LaTeX3 (expl3) implementation wraps engine-specific code (XeTeX primitives or luaotfload) behind a consistent key-value interface, and provides both user commands (`\setmainfont`, `\fontspec`) and a programmable API (`\fontspec_*` conditionals) for other packages. The codebase is structured as literate `.dtx` files, generating both the package `.sty` files and comprehensive documentation. It includes an extensive test suite with over 100 test files that run on both XeTeX and LuaTeX, a fully automated CI/CD pipeline (testing, documentation, release), and is distributed on CTAN under the LPPL 1.3c license. The package is actively maintained by the LaTeX3 Project team, tracking OpenType specification updates and TeX engine changes, though its dual-engine support and large static data tables (language/script mappings) introduce some maintenance overhead.
FiraCode is a monospaced programming font with extensive programming ligatures, built and maintained primarily by Nikita Prokopov. The repository contains the source design file (FiraCode.glyphs, Glyphs.app format), a Clojure-based pipeline that programmatically generates OpenType contextual alternates (calt) substitution rules from a list of ligature sequences, and a comprehensive build system (Makefile, shell scripts, Dockerfile) that orchestrates font production (OTF, TTF, variable, WOFF2, WOFF) using modern font tooling (fontmake, glyphsLib, gftools, fontbakery). The project also includes extensive OpenType feature files (stylistic sets, character variants), a Google Fonts QA workflow, and distribution packages for npm, Homebrew, and direct download. The architecture is a font development pipeline: source → Clojure ligature generator → fontmake compilation → hinting → packaging. It does not run as a service; its production output is the font files delivered to users via package managers or CDN. External dependencies include Python font libraries, a Clojure runtime, and Glyphs.app (proprietary) for editing the source file. The repository is actively maintained with recent commits and an extensive changelog, though some Google Fonts compliance items remain unresolved and the build chain is sensitive to upstream library changes.
Maple Mono is an open-source monospace programming font with an extensive build system. The repository is primarily a font engineering toolchain: it takes Glyphs source files, generates variable and static TTF/OTF/WOFF2 fonts, auto-hints them, patches in Nerd Font icons, merges Chinese/Japanese base fonts, and produces dozens of variants (hinted/unhinted, ligature/no-ligature, narrow/slim, etc.). The build is orchestrated by Python scripts (`build.py`, `task.py`) and supports customization via CLI flags or a `config.json` file. A web playground service (`in_browser.py`) allows users to build custom fonts in-browser with selected OpenType features. The codebase is not a running service but a build toolchain with a strong focus on OpenType feature engineering—featuring a custom AST-based DSL for programmatically generating ligature, character variant, and stylistic set feature files. The repository is well-maintained with active GitHub Actions workflows, though the v7 branch is explicitly a frozen snapshot of the current stable release (development continues on the `variable` branch).
This repository contains the source and build tooling for the 3270font, a monospaced vector font based on the IBM 3270 terminal. The primary artifact is a FontForge SFD file (3270_HQ.sfd) which is processed by a FontForge script (generate_derived.pe) to produce OTF, TTF, WOFF, and other font formats. The build system is orchestrated by a Makefile that also generates sample images, runs tests (fontlint, Font Bakery), and can install the fonts. Supporting Python scripts include generate_grid.py for creating FontForge guide grids and generate_sample_image.py for rendering sample text. The project includes CI via Travis and GitHub Actions, a Dockerfile for reproducible builds, and a pre-commit hook for code quality. While primarily a font design project, it functions as a build pipeline for a digital asset, with well-structured scripts and automated testing.
Handwrite is a CLI application that converts a scanned handwriting sample into a TrueType font. The pipeline consists of three stages: SHEETtoPNG uses OpenCV to detect and extract individual character images from a grid-based form; PNGtoSVG uses Potrace to convert the PNG images to SVG vector outlines; and SVGtoTTF uses FontForge to compile the SVGs into a font file with configurable metrics, kerning, and bearings. The architecture is a simple sequential pipeline orchestrated by the CLI entry point. External dependencies include OpenCV, Pillow, Potrace, and FontForge. The codebase is well-structured with unit tests, CI, and modern Python packaging (uv, Python 3.14). The character detection module in `sheettopng.py` demonstrates reusable grid-based contour extraction logic.
This repository is a curated 'awesome' list of falsehoods programmers believe in. It is not a software application or data pipeline; it is a markdown-based collection of links to external articles, libraries, and resources organized by topic (dates, names, geography, etc.). The repository contains no executable code, no API endpoints, no CLI tools, and no data transformations. Its value lies in the curation and editorial quality of the links, along with a well-documented contribution guide and automated linting workflows (lychee for link checking, typos for spelling, awesome-lint for list formatting). The infrastructure includes GitHub Actions for autofix, autolock, docs, labels, and linting, all reused from a shared workflow repository (kdeldycke/repomatic). The pyproject.toml provides reusable configuration for link exclusion patterns and typo detection. While not a software project, the repository demonstrates high standards for maintaining a community-curated resource.
Hyperglot is a Python package and CLI tool that detects language support in font binaries (OTF/TTF). It parses a font's character coverage and compares it against a curated YAML database of language orthographies, where each language (keyed by ISO 639-3 code) defines required character sets: base, auxiliary, marks, and punctuation. The tool reports which languages a font supports, with configurable thresholds for auxiliary character coverage. The repository is hybrid: the dominant character is a data-driven application — the YAML orthography database is the core asset, but it is consumed by a tested Python library with CLI entry points (hyperglot, hyperglot-validate, hyperglot-save) and published on PyPI. The architecture is a classic library-plus-CLI design: YAML data files are loaded and validated by Python modules; font binaries are parsed (via fontTools) and compared against the orthography model; results are aggregated and reported. The test suite (pytest, tox across Python 3.10–3.14) includes pinned test fonts (Eczar, Roboto, Plex) to verify correctness. The database itself follows a strict schema documented in README_database.md, with validation enforced by the hyperglot-validate command. Maintenance is healthy but not hyperactive: the last commit was 2026-09-03, 46 open issues remain, and the CLDR data is pinned to v36 — a version that is several years old by 2026, creating drift risk for locale data. Provisional-draft markers in some YAML entries and a pickle cache that relies on manual version bumps are the main technical debt items. Overall, this is a well-crafted, domain-specific tool with a genuinely useful data model, though it is not architecturally exceptional.