KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#dsh #dsh-plugin #typescript #developer-tools #claude-code #ai-agent #codex #deepseek-harness #ai-agents #cli #react #mcp

typography

★ 150 Open GitHub ↗

Fonts, Typesetting and Rasterization.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# Typography - Fonts, Typesetting and Rasterization.

⚠️ Typography has been integrated into [Pixie](https://github.com/treeform/pixie), a full-featured 2D graphics library for Nim. This repo is no longer being actively worked on. ⚠️

Pixie supports more TrueType / OpenType font features as well as rich text layout and rasterizizing through spans.

Consider migrating projects from Typography to [Pixie](https://github.com/treeform/pixie) for additional functionality and future improvements. 🚀🚀🚀🚀🚀

----

`nimble install typography`

[![Run tests](https://github.com/treeform/typography/actions/workflows/build.yml/badge.svg)](https://github.com/treeform/typography/actions/workflows/build.yml)

[API reference](https://nimdocs.com/treeform/typography)

## About

Typography is pure nim implementation for font rasterization (letter drawing) and text typesetting (text layout). It does *not* rely on any external library such as FreeType, stb_truetype, pango or HarfBuzz.

See api reference: https://treeform.github.io/typography/typography.html

# Font file formats:
* SVG fonts - Most features are supported.
* TTF fonts - Fair support. Most modern features are supported but font format came out in 1994 and has a bunch of formats for different OSes that are not supported.
* OTF fonts - Basic TTF outline support only. No support for CFF or SVG outlines.

# Requred Packages

* [vmath](https://github.com/treeform/vmath) - vector stuff, vec2 and matrices.
* [pixie](https://github.com/treeform/pixie) - image stuff, saving and loading PNGs.
* [chroma](https://github.com/treeform/chroma) - color stuff, mostly to save and add rgba colors.
* [print](https://github.com/treeform/print) - better logging.
* [bumpy](https://github.com/treeform/bumpy) - geometry stuff.
* [flatty](https://github.com/treeform/flatty) - dealing with binary encoding.

# Basic usage

```nim
var font = readFontSvg("fonts/Ubuntu.svg")
font.drawText(image, vec2(10, 50), "The quick brown fox jumps over the lazy dog.")
```

![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/basicSvg.png)

```nim
var font = readFontTtf("fonts/Ubuntu.ttf")
font.drawText(image, vec2(10, 50), "The quick brown fox jumps over the lazy dog.")
```

![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/basicTtf.png)

```nim
font.size = 8
font.drawText(image, vec2(10, 10), "The quick brown fox jumps over the lazy dog.")
font.size = 10
font.drawText(image, vec2(10, 25), "The quick brown fox jumps over the lazy dog.")
font.size = 14
font.drawText(image, vec2(10, 45), "The quick brown fox jumps over the lazy dog.")
font.size = 22
font.drawText(image, vec2(10, 75), "The quick brown fox jumps over the lazy dog.")
```

![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/sizes.png)

```nim
font.drawText(image, vec2(10, 10), readFile("examples/sample.ru.txt"))
```
![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/ru.png)

# Dealing with Glyphs

Each font has an table of glyphs.
```nim
font.glyphs["Q"]
```
And for each glyphs, you can see what the SVG path of a glyph looks like:
```nim
echo font.glyphs["Q"].path
```
```
M754,236 Q555,236 414,377  Q273,518 273,717  Q273,916 414,1057  Q555,1198 754,1198  Q953,1198 1094,1057  Q1235,916 1235,717  Q1235,593 1175,485  L1096,565  Q1062,599 1013,599  Q964,599 929,565  Q895,530 895,481  Q895,432 929,398  L1014,313  Q895,236 754,236  Z M1347,314  Q1471,496 1471,717  Q1471,1014 1261,1224  Q1051,1434 754,1434  Q458,1434 247,1224 Q37,1014 37,717  Q37,421 247,210  Q458,0 754,0  Q993,0 1184,143  L1292,35  Q1327,0 1376,0  Q1425,0 1459,35  Q1494,69 1494,118  Q1494,167 1459,201  Z
```
You can also draw this path to see all of the paths and all of the curve contorl points:
```nim
font.getGlyphOutlineImage("Q")
```
![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/qOutLine.png)

Most of the time you would like to just get the image instead:

```nim
font.getGlyphImage("Q")
```
![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/qFill.png)

You can then use this image in openGL, canvas, or even HTML.

# Subpixel glyphs with subpixel layout:

Each glyphs can be rendered with a subpixel offset, so that it fits into the layout:

![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/subpixelpos.png)

Note how many of the "o"s and "m"s are different from each other. This happens because spaces between letters are not an integer number of pixels so glyphs must be rendred shifted by fraction of a pixel.

Here is how glyph changes with different subpixel offsets:

![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/subpixelglyphs.png)

```nim
var glyphOffset # this is an offset of the image from the 0,0 position
var image = font.getGlyphImage(glyph, glyphOffset, subPixelShift=X)
```

# Typesetting

Before glyphs can be rendered they need to be typeset:

```nim
var layout = font.typeset("""
Two roads diverged in a yellow wood,
And sorry I could not travel both
And be one traveler, long I stood
And looked down one as far as I could
To where it bent in the undergrowth;""")
```

This produces a layout.

![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/layoutNoText.png)

## Drawing the layout
You can then use the simple drawing included to draw to an image, or use some other graphical librarry like openGL, canvas, or even HTML:

```nim
image.drawText(layout)
```
![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/layout.png)

## Wrapping and Clipping

You can also give the typeset region width and height so that text wraps and clips:

```nim
font.typeset(
  readFile("sample.wrap.txt"),
  pos=vec2(100, 20),
  size=vec2(300, 160)
)
```

![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/wordwrap.png)

## Alignment

There are 3 horizontal and 3 vertical alignment modes:

```nim
font.typeset("Center, Bottom",
  pos=vec2(20, 20),
  size=vec2(460, 160),
  hAlign=Center,
  vAlign=Bottom
)
```

![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/alignment.png)

## Selection

When selecting text is useful to know where to highlighting rectangles.

```nim
layout.getSelection(23, 120) # selects char 23 to char 120 (not glyphs)
```

![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/selection.png)

## Picking

When clicking on text is useful to know where to highlighting what glyph and what is the string index.

```nim
layout.pickGlyphAt(vec2(120, 48)) # selects glyph at cordiantes
```

![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/picking.png)

# Comparison to different OSs.

At the large font sizes (more then 24 pixels) the fonts on most operating system looks nearly identical. But when you scale the font below 24px different OSs take different approaches.
* OSX - tries to render fonts most true to how font designer intended even if they look a blurry.
* Windows - tries to render fonts to a pixel grid making them look sharper.
* Linux - configurable and somewhere between the two.
* iOS, Android - it really does not matter how the font is rendered because its almost always above 24px because of high resolution screens phones have.

```nim
   var font = readFontSvg("fonts/DejaVuSans.svg")
   font.size = 11 # 11px or 8pt
   font.drawText(image, vec2(10, 15), "The quick brown fox jumps over the lazy dog.")
```

Typography renderer - **this library** (4x):

![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/rendered/scaledup.png)

[Apple Core Text](https://developer.apple.com/documentation/coretext) renderer (4x):

![example output](https://raw.githubusercontent.com/treeform/typography/master/docs/sketchMac.png)

[Paint.net](Paint.net) renderer (4x):

![example output](https://raw.githubusercontent.com/treeform/typography/master/docs/paintNetWindows.png)

[Bohemian Sketch](https://www.sketch.com/) renderer (4x):

![example output](https://raw.githubusercontent.com/treeform/typography/master/docs/sketchMac.png)

[Window ClearType](https://docs.microsoft.com/en-us/typography/cleartype/) renderer (4x):

![example output](https://raw.githubusercontent.com/treeform/typography/master/docs/notepadWindows.png)

How the font should look on screen is very subjective, some people love the crisp windows fonts, others swear by the apples adherence to design. But my opinion is it's all related a lot with familiarity. What you are used to is what you would like best, and when a person switches to a different screen with a different font rendering style brain immediately rejects it.

# Subpixel Antialising is on its way out

About a decade ago use of Subpixel Antialising improved readability of fonts. It would leak a bit of color to the left and right of text because color pixels were not square. The monitors followed predictable pixel patterns first in CRTs then in LCDs.

![example output](https://upload.wikimedia.org/wikipedia/commons/5/57/Subpixel-rendering-RGB.png?raw=true)

Then everything changed. Today our pixels small and they don't follow a typical CRT or LCD orientation.

![example output](https://upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Pixel_geometry_01_Pengo.jpg/220px-Pixel_geometry_01_Pengo.jpg)

The fact that there is no standard pixel layout grid anymore. And the fact that high resolution displays are everywhere makes subpixeling obsolete. Apple, Adobe, Bohemian and others in the typography space are abandoning subpixeling.

This library does not support Subpixel Antialising.

[Neat tricks](http://www.typophile.com/node/60577) with [Subpixel rendering](http://www.typophile.com/node/61920)

[Apple removes Subpixel Antialising](https://www.reddit.com/r/apple/comments/8wpk18/macos_mojave_nukes_subpixel_antialiasing_making/)

# Text Boxes

Full backend implementation of a text area. You need to connect your own rendering, keyboard and mouse input.

Often when displaying text you also need to edit text. This is where the textbox part of this library comes in. This implemented the backend of a text box/text area/input element/text field. Text boxes are surprisingly hard to implement right because the users are very familiar with how they work, so any missing features or inconsistencies are painfully obvious.

Here is a small list of some of the features:

* Typing, arrow keys, backspace and delete.
* Mouse clicking, dragging to select.
* Almost everything can be used to select with shift.
* Double click to select word, triple click to select paragraph, quad click to select all.
* Page up and page down.
* Move left/right by word.
* Move to start or end of lines.
* Copy, Cut and Paste.
* Scrolling and scroll to cursor when typing or selecting.
* Resizing of the text box while it’s being added.
* Remember your horizontal position when going up or down with short lines.

![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/textbox/left_right.gif)

![example output](https://raw.githubusercontent.com/treeform/typography/master/tests/textbox/select.gif)

# How to convert any font to SVG font using FontForge:

SVG fonts are really nice. The are simple to parse and understand and debug. They are very uncommon though. But they are good as a debug input, output, or intermediate step.

```bash
$ fontforge -c 'Open($1); Generate($2)' foo.ttf foo.svg
```

typography

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README