> ## Documentation Index > Fetch the complete documentation index at: https://docs.teriyakigaming.com/llms.txt > Use this file to discover all available pages before exploring further. # Fonts > The five bundled open-licensed families, importing your own, and how a document, a project and the engine decide what unstyled text looks like. 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](/plugins/inkwell/authoring/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. | Asset | Faces | Good for | | ------------------- | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Font_CourierPrime` | Regular, Bold, Italic, BoldItalic | Typewriter and monospace: case files, incident reports, terminal printouts — anything meant to look typed rather than written. | | `Font_CrimsonText` | Regular, Bold, Italic, BoldItalic | An old-style book serif. The workhorse for printed matter — books, newspapers, posted notices — and the one to reach for when a page holds a lot of text. | | `Font_Kalam` | Regular, Bold | Casual handwriting with a real Bold face, so a scrawled journal can still emphasize a word. | | `Font_PatrickHand` | Regular | Neat, even handwriting. More legible than Kalam at small sizes; no bold or italic, so style with size and color instead. | | `Font_GreatVibes` | Regular | Formal script for invitations, dedications, signatures and title pages. Use it large and briefly — script at body size turns to mush at page resolution. | 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_` asset per group. Two ways in, both opening the same **Import Font Families** window: * The **import button** in the [Page Editor](/plugins/inkwell/authoring/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. 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`. 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). **Destination** is the content path the composite fonts are written to. It defaults to **Font Build Output Path** from [Project Settings](/plugins/inkwell/reference/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. **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 `, 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*. | Face | Tokens recognized (case-insensitive) | | ---------- | ----------------------------------------------- | | Regular | `regular`, `normal`, `book`, `roman`, `rg`, `r` | | Bold | `bold`, `bd`, `b` | | Italic | `italic`, `oblique`, `it`, `i` | | BoldItalic | `bolditalic`, `boldoblique`, `bi`, `z` | 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](/plugins/inkwell/reference/settings) → **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](/plugins/inkwell/reference/settings) — `/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 The toolbar, the three panes, and how styling a selection actually works. Several independent text boxes on one page, each with its own fonts. Default Page Font, Font Search Paths, Include Engine Fonts, Font Build Output Path. Referencing fonts from markup you build in Blueprint at runtime.