TitanF

The font rasterizer that doesn't slow down

Quick Start

use titanf::TrueTypeFont;

fn main() {
    let font_data = include_bytes!("Roboto-Medium.ttf");
    let mut font = TrueTypeFont::load_font(font_data);
    
    // Render a character!
    let (metrics, bitmap) = font.get_char::<false>('A', 16);
    
    //Enable built-in glyph caching
    let (metrics, bitmap) = font.get_char::<true>('B', 16);
    //                                      ^^^^
}

Add to your Cargo.toml:

[dependencies]

titanf = { git = "https://github.com/Hoteira/titan-f/" }



//It's not on crates.io as of yet so you cannot just add it as:

//titanf = "0.1.0"

Batch Rendering: 1000 Characters (CJK + L)

Criterion benchmark rendering with NotoSansSC-Medium:

The performance gap widens with batch size. While competitors slow down exponentially, TitanF maintains near-constant per-character performance up until 1-10 million glyphs.

Why TitanF Is Fast

1. Smart Buffer Reuse

• Buffers allocated once per font instance
• Same-sized glyphs: just memset and reuse (near-zero cost)
• Larger glyphs: grow buffer once, never shrink
• Result: Zero allocation overhead after warmup

2. Cache-Optimal Memory Layout

• Sequential memory access patterns
• No pointer chasing or indirection
• CPU prefetcher works perfectly
• Data stays hot in L1/L2 cache

3. Simple, Predictable Algorithm

• Winding number algorithm with single-pass filling
• No complex data structures
• Branch predictor loves it
• Compiler can optimize aggressively

Features

• 🚀 Blazingly Fast
• 📈 Linear Scaling — Performance doesn't "blow up" whether rendering 10 or 10 million glyphs
• 🦀 Zero Dependencies — Pure Rust, no external crates
• 📦 no_std Compatible — Originally built for my own OS, it works fine in baremetal environments (just needs alloc)
• 🎨 Subpixel Anti-aliasing — Smooth, high-quality glyph rendering
• 💯 Stable Rust — No nightly features, no unsafe code
• 🔧 Built-in TrueType Parser — Handles CMAP, GLYF, HEAD, HHEA, HMTX, KERN, LOCA, MAXP and keeps it dependency free

Benchmarking Notes

Hardware: All benchmarks run on the same machine with consistent methodology.

Methodology:

• Each rasterizer called with identical parameters
• Results wrapped in black_box() to prevent optimization
• Multiple runs averaged for consistency
• No caching enabled

Reproducibility: Benchmark code available in the repo. Run it yourself:

cargo bench

License

Licensed under the MIT License.

Contributing

Found a bug? Have a performance improvement? Contributions are welcome!

Please open an issue or PR on GitHub.