TiTanF

High-Performance, Zero-Dependency TrueType Font Rasterizer

Pure Rust • SIMD Accelerated • Memory Safe • Bare-Metal Ready

📖 Overview

TiTanF is a production-grade TrueType font rasterizer implemented entirely in Rust without any external dependencies (libc, freetype, etc.). It was engineered to explore high-performance vector graphics rendering techniques suitable for embedded systems and OS development.

The library features a hand-written parser for the TrueType format, a robust geometry processing pipeline, and a custom anti-aliased rasterizer accelerated by SIMD instructions (SSE2 on x86_64, NEON on AArch64).

✨ Key Features

• ⚡ SIMD Accelerated: Leveraging hand-written intrinsics for x86_64 (SSE2) and aarch64 (NEON) to optimize the pixel coverage accumulation stage.
• 📦 Zero Dependencies: A strictly dependency-free library. No C bindings, no system libraries—just pure Rust.
• ⚙️ Embedded Ready: Fully no_std compatible (requires alloc), making it ideal for kernels, bootloaders, and embedded graphical interfaces.
• 🛡️ Memory Safe: Utilizes safe Rust for 99% of the codebase, with unsafe limited strictly to SIMD optimizations.
• 🔧 Robust Parsing: Zero-copy parsing of complex TrueType tables (glyf, cmap (Format 0, 4, 6, 12), kern, hmtx, etc.).

🏗️ Architecture

The rendering pipeline is architected into three distinct stages to maximize modularity and performance:

1. Parsing (src/tables): Raw binary data is parsed into strongly-typed Rust structures. Complex tables like glyf (glyph data) are lazy-loaded to minimize initial memory footprint.
2. Geometry (src/geometry):
   • Contour Extraction: Bezier curves (quadratic) are extracted from the glyph data.
   • ** flattening:** Curves are recursively subdivided into monotonic line segments for rasterization.
3. Rasterization (src/rasterizer):
   • Analytic Area: Uses an analytic coverage-based anti-aliasing algorithm (DDA) to calculate exact pixel coverage.
   • Accumulation: A SIMD-optimized parallel prefix sum converts edge deltas into the final alpha map.

🚀 Quick Start

Add this to your Cargo.toml:

[dependencies]
titanf = "2.1.0"

Rendering a Character:

use titanf::TrueTypeFont;

fn main() {
    // 1. Load font bytes (e.g., from a file or include_bytes!)
    let font_data = include_bytes!("../assets/Roboto-Regular.ttf");
    let mut font = TrueTypeFont::load_font(font_data).expect("Failed to parse font");

    // 2. Configure render settings
    font.set_dpi(72.0);

    // 3. Rasterize 'A' at 24px
    // Returns metrics and a linear alpha buffer (Vec<u8>)
    let (metrics, bitmap) = font.get_char::<true>('A', 24.0);

    println!("Rendered 'A': {}x{} pixels", metrics.width, metrics.height);
}

📊 Performance

Benchmarks performed on an AMD Ryzen 9 5900X rendering 1,000 characters (Mixed CJK & Latin).

TiTanF scales significantly better than other pure-Rust alternatives at larger sizes due to its O(1) memory allocation strategy and SIMD optimizations.

📜 License

Distributed under the MIT license.