Swash is a pure Rust, cross-platform crate that provides font introspection,
complex text shaping and glyph rendering.
This crate aims to lay the foundation for a cross-platform, high performance set
of components for beautiful typography. In particular, this library focuses on
fonts and operations that are directly applicable to them. For the most part, the
desire is to be unopinionated with respect to resource management, higher level
layout and lower level rendering.
Due to the intention of being generally useful and easy to integrate, the following
areas of related interest are specifically avoided:
Text layout. This is highly application specific and the requirements for both
features and performance differ greatly among web browsers, word processors,
text editors, game engines, etc. There is a sibling crate in development that
does provide general purpose text layout based on this library and will be
Composition. Like layout, this is also application specific in addition to being
hardware dependent. Glyph catching, geometry batching and rendering all belong
here and should integrate well with the application and the hardware environment.
There is also a sibling crate that attempts to provide these services that will
be released in the future.
- Simple borrowed font representation that imposes no requirements on resource
management leading to...
- Thread friendly architecture. Acceleration structures are completely separate from
font data and can be retained per thread, thrown away and rematerialized at any
- Zero transient heap allocations. All scratch buffers and caches are maintained by
contexts. Resources belonging to evicted cache entries are immediately reused
- Enumerating font collections (ttc/otc)
- Localized strings including names and other metadata
- Font variation axes and named instances
- Comprehensive font and per-glyph metrics (with synthesized vertical metrics if not provided)
- Primary attributes (stretch, weight, style) with support for synthesis suggestions
based on available variations and scaler transforms (faux bold and oblique)
- Color palettes
- Embedded color and alpha bitmap strikes
- Character to nominal glyph identifier mapping with support for enumerating all pairs
- Writing systems: provides a list of all supported script/language pairs
and their associated typographic features
- All introspection is zero allocation and zero copy
Complex text shaping
- Full support for OpenType advanced typography (GSUB/GPOS)
- Partial support for Apple advanced typography: glyph metamorphosis (morx) is fully
supported while the current extended kerning support (kerx) covers most common
cases (kerning and mark positioning)
- Full support for variable fonts including positioning and feature substitutions
- Implementation of the Universal Shaping Engine for complex scripts such as Devanagari, Malayalam, etc.
- Arabic joining including Urdu style climbing runs
- Basic shaping support: ligatures, marks, kerning, etc.
- Enable/disable individual features with argument support for activating alternates
such as swashes...
- Pre-shaping cluster parsing with an iterative mapping technique (including normalization) allowing for
sophisticated font fallback mechanisms without the expense of heuristically shaping runs
- Shaper output is structured by cluster including original source ranges and provides simple
identification of ligatures and complex multi-glyph clusters
- Pass-through per character user data (a single u32) for accurate association of style
properties with glyphs
- Pass-through per cluster information for retaining text analysis results such as word
and line boundaries, whitespace identification and emoji presentation modes
- Shaping of vertical runs is not yet provided but a prototype exists and will be released soon
- Scalable outlines with full variation support (TrueType and Postscript)
- Asymmetric vertical hinting (TrueType and Postscript)
- Horizontal subpixel rendering and fractional positioning
- Full emoji support for Apple (sbix), Google (CBLC/CBDT) and Microsoft (COLR/CPAL)
- Path effects (stroking and dashing)
- Transforms including synthetic emboldening and affine transformations
- Customizable glyph source prioritization (best fit color bitmap -> exact size alpha bitmap -> outline)
- Unicode character properties related to layout and shaping
- Character composition and decomposition (canonical and compatible)
- Complex, script aware cluster segmentation
- Single pass, iterator based analysis determines word and line boundaries
and detects whether bidi resolution is necessary
Performance is a primary goal for this crate and preliminary microbenchmarks show a general
improvement over FreeType and Harfbuzz by about 10-20% on average and some cases show
substantial wins, particularly when scaling Postscript outlines or shaping text with complex
features. Specifically, shaping runs with fonts like Calibri and Noto Sans Myanmar is almost
twice as fast. Simple fonts and pure ASCII runs tend to show the smallest gains as those
simply measure shaper initialization and glyph iteration. A comprehensive set of benchmarks
(and test cases!) are needed here to gain more insight and track regressions.
Contributions are welcome and appreciated! All contributions must be granted under the
licenses under which this project is released.
This project has been a long term goal of mine and I haphazardly decided to take it on as my
first major foray into Rust. What a ride! I've grown quite fond of development in Rust and
would be interested if there are any employers out there looking for someone who can
competently wrangle the borrow checker. Doubly interested if the work involves text rendering
or general 2D (or 3D!) graphics development. Alternatively, please consider supporting me
on patreon or contacting me about sponsorship if you find this