Skip to main content
An Ink Page Document (UInkPageDocument) is the asset that holds everything you author: the pages, the layers on them (front and back), the paper look, and the default text style. It is a Data Asset — no world, no components — so one document can be shown by any number of displays, stacks, widgets, and actors at once, and editing it updates all of them. At runtime each page’s layers are baked into an ink render target which the page material multiplies over the paper, so the content reads as ink or print rather than a decal. See Rendering for that pipeline.
The Page Editor left panel showing the Pages list and Page Setup section

The Page Editor's left panel is the whole document asset: Pages, Page Setup, Paper & Ink, Custom Mesh, Default Text Style.

​
Creating a document

1

From the level editor toolbar

Click the Page Editor button on the level editor toolbar and choose Create New Page Document…. You pick a name and folder, and the new asset opens straight into the Page Editor.
The Level Editor toolbar with the Inkwell Page Editor dropdown button highlighted

Inkwell's Page Editor button (1), at the right end of the Level Editor toolbar.

The Inkwell menu: Edit Document, Recent / All Documents, Create New Page Document, Import Font Family, Documentation

The menu the button opens. Create New Page Document... is the entry that makes a new one.

2

Or from the Tools menu

Tools → Inkwell carries the same menu, for projects that hide the toolbar button (Show Toolbar Button in Project Settings → Plugins → Inkwell).
3

Or from the Content Browser

Add (or right-click in the folder) → Inkwell → Page Document, like any other asset type. Double-click the result to open it.
A new document is seeded from project settings so it renders something immediately: the New Document Page Size Pixels setting becomes its Page Size Pixels, the Default Paper Texture becomes its Paper Texture, and the Default Page Font becomes its Default Font with Default Typeface set to Regular. It always starts with exactly one page, and that page always has a Text layer to write in.
Author documents in the Page Editor. The text is stored as machine-generated markup and is not meant to be typed into a details panel by hand.

​
A page is a stack of layers

A page (FInkPageSpec) is not a block of text with pictures bolted on. It is an ordered back-to-front stack of layers (FInkPageLayer): index 0 is the back of the page, the last entry is the front. A layer is one of three types — Text, Image, or Drawing — and carries a Name, bVisible, bLocked and Opacity of its own. Text is a layer payload, so one page can hold a heading, a body and a signature as three independent text boxes, with images or freehand drawings stacked between them. A watermark is an Image layer before the text; a stamp is one after it. Layers covers the stack in full — the panel, reordering, locking, and what each payload does.
Every page Inkwell creates or loads is guaranteed a Text layer on its front, so a page’s writing always has somewhere to draw. The back deliberately gets no such guarantee — an empty back is the free, unauthored state. Documents authored before layers existed are converted on load — see Layers.

​
The back of the sheet

Every page is one face of a physical sheet, and the sheet has two (EInkPageSide: Front, Back). The back is authored independently: its own layer stack (BackLayers), optionally its own paper. A sheet whose back was never authored renders bare paper there and pays nothing for the feature — Has Back (HasBack) is false, no back bake runs, no render target is allocated. Every document saved before backs existed loads exactly that way. Flip the sheet in the Page Editor with the Front / Back toggle under the Pages list; at runtime the Ink Page Reader turns sheets over with Flip Page, and on a multipage document Next Page reads in book order: front → back → next page.

​
Where the back gets its paper

The document-wide choice is Back Paper (FInkPaperFace), whose Mode is an EInkBackPaperMode: When the Mode is anything but Same As Front, the face’s Tint is multiplied over the back’s paper the way Paper Tint is over the front’s. On top of all of that, any single page can set Back Paper Override to give just its own back a texture.

​
Page Setup

Geometry shared by every page in the document.

​
The page-sizing model

This is the part worth reading twice, because it is what stops authored pages from looking wrong in the world. A page has exactly one shape and one physical size, derived from two numbers that do different jobs:
  • Page Size Pixels is resolution and proportion. 1024 × 1400 is a portrait page; 800 × 500 is a landscape one.
  • Page Width Cm is how big that page is in the level — and it is the only physical dimension in the whole plugin. There is no height field anywhere.
The height is computed, not authored. Get Page Size Cm (GetPageSizeCm) returns (PageWidthCm, PageWidthCm × PageSizePixels.Y / PageSizePixels.X): The reason is mechanical: the baked ink texture is mapped across the whole sheet, so a sheet shaped differently from the page would stretch every letter on it. By deriving the height there is no second number to get wrong, and authored text can never come out stretched. Author a landscape page and you get landscape paper, automatically, everywhere the document is shown. Every Inkwell surface measures its paper from this: the sheet an Ink Page Display spawns, every sheet in an Ink Page Stack, and the Ink Page actor. In the Page Editor, the Width cm row shows the derived height beside it as x 28.7 cm high, and committing either row re-sizes every page already placed in the level.
To make one placed sheet bigger without touching the document, use Page Scale on that page’s Ink Page Display component. It multiplies the document’s size for that instance only — Get Effective Page Size Cm (GetEffectivePageSizeCm) returns the result. Because it scales both axes together, the no-stretch guarantee survives every value.
Bake resolution is safety-clamped by Max Page Bake Dimension in Project Settings → Plugins → Inkwell (default 4096 per axis). A document asking for more is scaled down proportionally rather than allocating an enormous render target — the aspect ratio, and so the page shape, is preserved.

​
Paper & Ink

The sheet itself and the tint of everything written on it.

​
The four paper modes

EInkPaperMode decides where the sheet under the ink comes from:
In Mesh’s Own Material mode the target material must contain the MF_InkwellPageInk material function, with your final color wired through it. A material without the function shows no ink and raises no error — that is the contract, not a failure. See Rendering for wiring it up.

​
Per-page paper override

Any page can replace the document’s paper with its own. Paper Override on the page wins over everything: it beats the document’s Paper Texture and the generated sheet, so switching a document to Procedural never silently discards a page that had been given its own stock. Cleared, the page falls straight back to the document’s paper. Get Paper For Page (GetPaperForPage) is the one function that resolves all of this. For the front (and for a back whose mode is Same As Front, which falls through to the front’s chain — per-page override included):
1

The page's own Paper Override

Returned as-is when set.
2

No texture in the material modes

When Paper Mode is Custom Material or Mesh’s Own Material the material brings its own paper, so there is no texture to hand out — the function returns nothing.
3

Generated paper

When Paper Mode is Procedural, the sheet is rasterized on first use and cached on the document, so twenty pages sharing a document share one generated sheet.
4

The document's Paper Texture

Otherwise. If that is unset too, the page material uses its own plain-paper color.
Asked for the back (Side = Back), the back’s own chain runs first: the page’s Back Paper Override, then the document’s Back Paper mode. A back Procedural sheet with settings identical to the front’s reuses the front’s cached paper rather than rasterizing a second identical texture. Use overrides for the aged first page of an otherwise clean journal, a bloodstained note in a sequence of ordinary ones, or a title page on different stock.

​
Default Text Style

The style of unstyled text — anything typed without applying toolbar styling. Styled runs carry their own font, size, color and typeface in the markup and ignore these. Get Effective Default Font (GetEffectiveDefaultFont) resolves a three-step chain: the document’s Default Font when set, otherwise the project-wide Default Page Font (Project Settings → Plugins → Inkwell), and as a last resort the engine’s own Roboto — so text is never invisible in a project that has configured nothing. See Fonts for the full picture.

​
Custom mesh preview

Three editor-only properties under Preview let the Page Editor show the document on the prop that will carry it in game: Preview Mesh (unset, the preview uses the plugin’s flat page sheet, sized from the document — exactly what a mesh-less actor gets in game), Preview Material Slot, and Preview Face Mapping (FInkPageFaceMapping), which maps the page onto a UV region of that slot with quarter-turn rotation. These are authoring intent: they travel with the asset but do not survive cooking, and a document never imposes a mesh on its consumers. At runtime the mesh and the face mapping belong to the component that displays the page — copy the preview’s settings onto the Ink Page Display component’s Page Face when the real prop uses the same mesh. Edit all three in the Page Editor’s Custom Mesh section.

​
Pages

Do not clear Font References by hand. Markup stores fonts as string paths, which the cooker cannot follow; without these hard references a packaged build renders fallback glyphs wherever a styled run’s font failed to cook. Pressing Save Document in the Page Editor rebuilds the list from every text layer on both sides of every page.

​
Text markup

A Text layer’s Markup is UE rich-text markup. A styled run looks like this:
Untagged text renders in the document’s Default Text Style; Font and Face are omitted from a run entirely when unset, so the document default wins. The same rich-text marshaller drives the in-game bake and the Page Editor’s edit box, which is what keeps the two pixel-identical. Every attribute, what it inherits, and the rules for generating markup safely are in the markup format. Author through the Page Editor or the Blueprint API rather than by hand — the markup writer does not escape attribute values.

​
The content revision

ContentRevision is a transient (never saved) counter bumped on every content change. The runtime bake cache keys on it, so stale render targets regenerate whenever a document changes. This is why Page Editor edits show up live on pages already placed in the level, even during PIE. If you mutate a document any other way at runtime, call Bump Revision (BumpRevision) afterwards. Every Blueprint function below already does.
In the editor, Bump Revision also marks the package dirty so authoring changes stay saveable — but not during a play session. Data assets are not duplicated for PIE, so gameplay mutations deliberately leave the source asset untouched rather than offering to save play-time changes into the .uasset on exit.

​
Blueprint API

Pages is deliberately read-only from Blueprint: every mutation must invalidate the bake cache, which a directly writable array could not guarantee. Build and edit documents through these instead — see Runtime documents for worked examples. Every layer function takes a Side input (EInkPageSide, default Front), so the same nodes author both faces of a sheet.

​
Reading

​
Writing

All of these mutators invalidate cached bakes for you. Everything here is equally available from C++ on UInkPageDocument.
The “a page always has a Text layer” repair is a front rule. Set Page Layers with Side = Back accepts an empty array — that returns the back to its unauthored, zero-cost state, which is exactly how you blank a back from Blueprint.
A page with no Text layer has nowhere to draw its writing — the bake walks the layer stack, not a markup string. If you construct an FInkPageSpec yourself, add it with Add Page (which guarantees the page a Text layer) rather than pushing it into Pages, and set its words with Set Page Markup or Set Layer Markup. If a page still looks blank, check the layer’s Visible flag and its Opacity.

​
Next

Page Editor

The window where you actually author all of this.

Layers

The stack model: text boxes, images, drawings, and their order.

Paper

Generated paper: ruling, margin rule, punched holes, grain.

Runtime documents

Building and editing documents from Blueprint at runtime.