How does rustybuzz compare to harfbuzz_rs?

rustybuzz is a pure Rust reimplementation, avoiding C++ dependencies, while harfbuzz_rs is a binding to the C++ library with FFI overhead. rustybuzz is safer and easier to integrate in Rust projects but may lack some features like subsetting that harfbuzz_rs might expose in future versions.

How to handle font scaling with rustybuzz since it has no font size property?

After shaping, you must manually scale the positioned glyphs based on the desired font size and the font's UnitsPerEm. This involves multiplying glyph positions and advances by a scale factor, which adds complexity compared to harfbuzz's built-in scaling.

Is rustybuzz safe to use in production?

Yes, it's designed for safety with almost entirely safe Rust code and minimal unsafe usage. However, it's still catching up on edge-cases and performance, so test thoroughly for your specific fonts and scripts.

What font formats does rustybuzz support?

rustybuzz uses ttf-parser for TrueType and OpenType font parsing, supporting common formats like .ttf and .otf. It doesn't integrate with system libraries for other formats, so font loading is limited to what ttf-parser can handle.

Can rustybuzz shape complex scripts like Arabic?

Yes, it supports complex script shaping including Arabic, but lacks an Arabic fallback shaper for edge cases, as mentioned in the 'Major changes'. This might cause issues with malformed fonts or specific ligatures.

What are the main limitations of rustybuzz vs harfbuzz?

Key limitations include no subsetting, slower performance, missing support for some font tables (e.g., mort, avar2), and no integration with external libraries like ICU or FreeType, making it less feature-complete for advanced use.

Open-Awesome

rustybuzz

MITRustv0.20.1

A complete HarfBuzz text shaping algorithm port to Rust, enabling font shaping without C++ dependencies.

GitHub

659 stars42 forks0 contributors

What is rustybuzz?

rustybuzz is a Rust port of the HarfBuzz text shaping algorithm, which processes Unicode text and font data to produce positioned glyphs for rendering. It solves the problem of complex text layout (e.g., for scripts like Arabic or Devanagari) without requiring C++ dependencies or system libraries. The library is designed as a drop-in alternative for HarfBuzz in Rust projects.

Target Audience

Rust developers working on text rendering, font tools, or GUI frameworks who need a reliable, safe, and dependency-free text shaping solution. It's also suitable for projects aiming to avoid C++ toolchains.

Value Proposition

Developers choose rustybuzz for its pure Rust implementation, which simplifies builds and enhances safety, while maintaining high compatibility with HarfBuzz. It offers a self-contained, no-fuss alternative without sacrificing core shaping functionality.

Overview

A complete harfbuzz's shaping algorithm port to Rust

Use Cases

Best For

Building Rust-based text rendering engines without C++ dependencies
Embedding text shaping in cross-platform applications with simplified toolchains
Developing font tools or typography libraries in safe Rust
Educational projects exploring text shaping algorithms in Rust
Replacing HarfBuzz in Rust projects to avoid FFI overhead
Shaping complex scripts (e.g., Arabic, Indic) in pure Rust environments

Not Ideal For

Projects requiring font subsetting capabilities (removed in rustybuzz)
Applications tightly integrated with system font libraries like FreeType or CoreText
Performance-critical text rendering where harfbuzz's 1.5-2x speed advantage is crucial
Typography tools needing support for deprecated tables (e.g., 'mort') or advanced features like 'avar2'

Pros & Cons

Pros

Pure Rust Implementation

Eliminates the need for a C++ compiler and system library linking, simplifying dependency management as highlighted in the README's 'Why?' section.

High HarfBuzz Compatibility

Passes 2221 out of 2252 harfbuzz shaping tests, ensuring near-identical output for most use cases, as stated in the 'Conformance' section.

Safety-First Design

The library is almost entirely safe Rust with minimal unsafe usage, enhancing reliability and security, as noted in the 'Safety' section.

Self-Contained and Dependency-Free

Avoids external dependencies on libraries like FreeType or ICU, making integration straightforward without external toolchains, per the 'Key Features'.

Cons

Slower Performance

Benchmarks show rustybuzz is 1.5-2x slower than harfbuzz, as admitted in the 'Performance' section, which could impact real-time rendering.

Missing Key Features

Subsetting is removed, and there's no Arabic fallback shaper or support for tables like 'mort' and 'avar2', limiting functionality for advanced typography.

Limited Font Integration

Lacks integration with system font libraries (e.g., FreeType, CoreText), requiring manual font handling, which complicates applications relying on native services.

Manual Scaling Required

Shaping always uses UnitsPerEm without a font size property, so users must scale glyphs manually, adding extra steps post-shaping.

Open Source Alternative To

rustybuzz is an open-source alternative to the following products:

harfbuzz

HarfBuzz is an open-source text shaping engine that processes Unicode text for proper glyph positioning and rendering in various languages and scripts.

Frequently Asked Questions

Related Projects

wgpu

A cross-platform, safe, pure-Rust graphics API.

Stars17,146

Forks1,297

Last commit2 days ago

rnote

Sketch and take handwritten notes.

Stars11,223

Forks466

Last commit4 days ago

gfx

[maintenance mode] A low-overhead Vulkan-like GPU API for Rust.

Stars5,399

Forks532

Last commit3 years ago

Vulkano

Safe and rich Rust wrapper around the Vulkan API

Stars5,070

Forks470