Skip to main content
Inkwell renders page text with ordinary Unreal composite font assets (UFont) whose Font Cache Type is Runtime: one asset per family, holding typeface entries named Regular, Bold, Italic and BoldItalic. The B and I buttons in the Page Editor toolbar switch a run between those entries, so a family can only go bold if it actually contains a Bold face. Everything on this page is about those family assets: the five that ship with the plugin, how to make your own out of .ttf/.otf files, and which font a piece of text ends up in when nobody has said.

​
The bundled families

Five families ship at /Inkwell/Fonts/, one per typographic role. Their individual faces are UFontFace assets in /Inkwell/Fonts/Faces/; you never pick those directly. In the Page Editor’s font pickers these appear without the Font_ prefix and with spaces inserted: Courier Prime, Crimson Text, Kalam, Patrick Hand, Great Vibes.
A family with no Italic face does not fail loudly. Pressing I looks for Italic, then Oblique, then falls back to Regular — so Patrick Hand keeps rendering upright. That is deliberate, not a bug.

​
Licensing

All five are licensed under the SIL Open Font License, Version 1.1, which permits bundling and redistribution inside a commercial product as long as the license text accompanies the fonts and the fonts are not sold on their own. Both conditions are met by the plugin as shipped: the full texts live in Plugins/Inkwell/Resources/Licenses/, one per family (OFL-courierprime.txt, OFL-crimsontext.txt, OFL-kalam.txt, OFL-patrickhand.txt, OFL-greatvibes.txt). Ship these fonts in your game without doing anything further; keep that folder with the plugin.
The same is emphatically not true of fonts you did not license for redistribution. Every Microsoft-supplied face on your machine — Courier New, Georgia, Ink Free, Segoe Print, Segoe Script — is licensed to you, not to your players, and cannot be packaged into a game. The importer below will happily convert them into assets; the license is still your responsibility.

​
Importing your own fonts

The importer turns a folder of .ttf/.otf files into finished composite font assets: it groups the files into families by filename and builds one Font_<Family> asset per group. Two ways in, both opening the same Import Font Families window:
  • The import button in the Page Editor toolbar, immediately right of the font family dropdown (tooltip: Import a folder of TTF fonts as page font families…).
  • Import Font Family…, in the Tools section of the level editor’s Page Editor toolbar dropdown — or of the same menu under Tools → Inkwell in the main menu bar.
1

Point it at a source folder

Type a path into Source folder, or press Browse…. Two kinds of path work:
  • An OS folder of .ttf/.otf files. It is scanned recursively, so a folder of per-family subfolders is fine.
  • A content path starting with / (for example /Game/MyFaces), which is scanned recursively for UFontFace assets you already imported. Nothing is re-imported in that case; the composite fonts are built from those assets as they are.
The scan runs the moment the path is committed — Enter, or clicking away — and the status line at the bottom reports how many families were detected, plus any warnings. If it says No font families detected, the path is wrong or holds no .ttf/.otf.
2

Check the detected families

Each row is one family: a checkbox (clear it to skip that family), the family name, and the four typeface slots. A slot is bright when a file was found for it and dimmed when it was not — a dimmed slot will not exist in the finished font.Click the family name to rename it in place. The name you leave there is what the built asset is called, so Crimson Text builds Font_CrimsonText (anything that is not a letter, digit or underscore is stripped from the asset name).
3

Choose a destination

Destination is the content path the composite fonts are written to. It defaults to Font Build Output Path from Project Settings, which is /Game/Fonts out of the box. Imported font faces land in a Faces subfolder of it.Overwrite existing (off by default) re-imports faces that already exist at the destination. Left off, an existing face asset is reused as it is — which is what you want when you re-run an import only to pick up one new family.
4

Import

Import builds one runtime composite font per checked family, writing its typeface entries in the order Regular, Bold, Italic, BoldItalic, and saves each asset. The status line reports Built N of M font family(ies) in <destination>, and a notification reports the built count and destination; per-family warnings appear in the status line and in the Output Log.Every open Page Editor refreshes its font pickers the moment the import succeeds — no need to reopen the window. The import dialog stays open too, so you can point it at another folder and go again.
Keep the destination inside a configured Font Search Path or the new families will not appear in the picker. The default /Game/Fonts is covered, because /Game is one of the two default search paths.

​
How filenames become families and faces

Family and typeface are inferred from each file’s base name. Separators are normalized first (_ and spaces both become -, runs of them collapse), then style tokens are peeled off the end one at a time. So CrimsonText-Bold-Italic, CrimsonText-BoldItalic and Crimson Text_Bold Italic all land on family CrimsonText, face BoldItalic. Names with no separator at all get a second pass for the old Microsoft/Adobe habit of gluing the suffix onto the stem — courbd, courbi, georgiaz, georgiab, georgiai — and only when at least three characters of stem are left over. Grouping is case-insensitive, so Kalam-Regular.ttf and kalam-bold.ttf are one family. If two files claim the same slot, the first one wins and the other is reported as a duplicate in the status line.
Weight and width words the importer does not recognize — Light, SemiBold, Condensed — deliberately keep the whole name as the family, so Kalam-Light becomes its own family rather than masquerading as Kalam’s Regular. Inkwell’s style model has exactly four slots; a five-weight superfamily is best imported as several families.
The importer is a convenience, not a requirement. Import a TTF as a Font Face yourself, create a UFont whose Font Cache Type is Runtime, add typeface entries named Regular / Bold / Italic / BoldItalic pointing at your faces, and save it inside a configured font search path. Inkwell discovers it exactly like a font it built itself.

​
Choosing what text looks like

There are two separate decisions in the Page Editor, and they are easy to mix up. The document default lives in the left panel under Default Text Style: a font dropdown, a Size in page pixels, and a color swatch. This is what every character that carries no style of its own renders in. The dropdown reads (project default) until you pick a family; picking one also sets the document’s typeface to that family’s Regular face. A styled selection comes from the toolbar. Select text on the page, then change the font family dropdown, the size box, B / I / U / S, or the text color. That writes the font’s object path and face name into the selected run’s markup, overriding the document default for those characters only. Because restyling rewrites the markup it clears the selection — which is why the toolbar’s size box applies when you press Enter or release the slider, rather than live. The project default is Project Settings → Plugins → Inkwell → Default Page Font. It is what documents fall back to when their own Default Text Style font is unset, so pointing it at /Inkwell/Fonts/Font_CrimsonText restyles every unstyled run in every document in the project at once. Out of the box it is the engine’s Roboto.

​
The fallback chain

For unstyled text the font is resolved in this order, and never comes out empty:
  1. The document’s own Default Font, when set.
  2. Otherwise the project’s Default Page Font.
  3. Otherwise the engine’s Roboto at /Engine/EngineFonts/Roboto, which is present in every Unreal installation.
A styled run is resolved separately, from the object path stored in its markup. If that path will not load — the asset was renamed, moved or deleted — the run falls back to Slate’s own default font at the run’s size and face rather than rendering nothing. Text is never invisible; at worst it is wrong-looking, which is something you can see and fix.

​
Font References, and why Save Document matters

Markup stores fonts as string paths, not as object references. The cooker cannot see a string, so left alone a packaged build would ship pages whose fonts were never cooked, and whose text falls back to Slate’s default. Inkwell closes that gap with Font References, a hard-reference array on the Page Document (details panel, under Pages, in the advanced section). The Page Editor rebuilds it every time you press Save Document: it walks every text layer of every page — front and back layers alike — collects each Font="..." path, loads it, and adds it to the list — plus the document’s effective default font, so a project-wide default gets a hard reference in the asset too. A font used only in a second text box, or only on the back of a sheet, is covered the same as any other.
Save with the Page Editor’s Save Document button. Saving the asset any other way — Ctrl+S in the level editor, Save All, the Content Browser’s context menu — writes the document without refreshing Font References. Everything looks perfect in the editor, because the editor loads fonts by path on demand, and the packaged build renders fallback glyphs. Do not hand-edit or clear the array either.

​
Which fonts show up in the picker

The Page Editor builds its font list from the Asset Registry, scanning the Font Search Paths in Project Settings → Plugins → Inkwell — /Inkwell/Fonts and /Game by default, both recursive. A font qualifies only if it is a UFont whose cache type is Runtime and which has at least one typeface entry; offline-cached fonts and empty composites are skipped. The list is grouped in a fixed order — plugin fonts (/Inkwell) first, then project fonts (/Game), then anything else, then engine fonts — and sorted alphabetically inside each group. Include Engine Fonts (on by default) is what adds /Engine/EngineFonts, always last.
Keep Font Search Paths tight on a large project. Every font found is loaded so its typeface names can be read, so scanning the whole of /Game costs a visible hitch when the Page Editor opens. Narrowing it to /Game/Fonts fixes that.

​
Next

Page Editor

The toolbar, the three panes, and how styling a selection actually works.

Layers

Several independent text boxes on one page, each with its own fonts.

Project settings

Default Page Font, Font Search Paths, Include Engine Fonts, Font Build Output Path.

Runtime documents

Referencing fonts from markup you build in Blueprint at runtime.