Parley provides an API for implementing rich text layout. It is backed by Swash.

Currently, Parley directly depends on four crates: Fontique, Swash, Skrifa, and Peniko. These crates cover different pieces of the text-rendering process.

Peniko builds on top of kurbo and provides vocabulary types for 2D rendering.

Peniko mostly just exports types like Blob, Color, Gradient, Brush, Point, Rect, Vec2, etc.

Fontique provides font enumeration and fallback.

Font enumeration means listing (enumerating) all the fonts installed on the system. It also means collecting metadata about those fonts: whether they are serif, sans-serif, monospace, their weight, the code points they cover, etc. The library is responsible for loading fonts into memory; it will use memory-mapped IO to load portions into memory lazily and share them between processes on the system.

Font fallback is matching runs of text to a font. This is necessary because fonts typically don't cover the entire unicode range: you have different fonts for latin text, chinese text, arabic text, etc and also usually a separate font for emoji. But if you have, say arabic text or emoji embedded within latin text, you don't typically specify the font for the arabic text or the emoji, one is chosen for you. Font fallback is the process which makes that choice.

Skrifa reads TrueType and OpenType fonts.

It is built on top of the read-fonts low-level parsing library and is also part of the oxidize project.

Skrifa provides higher level metrics on top of read-fonts. Notably it converts the raw glyph representations in font files into scaled, hinted vector paths suitable for rasterisation.

Swash implements text shaping and some miscellaneous unicode-related features.

Text shaping means mapping runs of unicode codepoints to specific glyphs within fonts. This includes applying ligatures, resolving emoji modifiers, but also much more complex transformations for some scripts.

Swash's implementation is faster but less complete and tested than Harfbuzz and Rustybuzz.

Swash also implements font parsing, scaling, and hinting. This part of Swash is now superseeded by Skrifa: the implementation in Skrifa is directly descended from the one in Swash.

Parley itself does text layout.

Text layout means computing x/y coordinates for each glyph in a string of text. Besides what the other libraries do, this involves things like determining a glyph's size, line breaking, and bidi resolution.

In the future, Parley will likely also implement text selection and text editing helpers.

This version of Parley has been verified to compile with Rust 1.70 and later.

Future versions of Parley might increase the Rust version requirement. It will not be treated as a breaking change and as such can even happen with small patch releases.

# Use the problematic dependency's name and version
cargo update -p package_name --precise 0.1.1

Discussion of Parley development happens in the Linebender Zulip, specifically the #text stream. All public content can be read without logging in.

Contributions are welcome by pull request. The Rust code of conduct applies.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache 2.0 license, shall be licensed as noted in the License section, without any additional terms or conditions.

Licensed under either of

• Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)

at your option.