API Reference

Canvas-space text component. Renders into a [[Canvas]] via [[CanvasRenderer]] with full Unicode support — bidirectional scripts (Arabic, Hebrew), complex shaping (Devanagari, Thai), proper line breaking, color emoji, and a markup system via [[ParseRule]].

World-space text component. Renders via [[WorldBatcher]] with full Unicode support — bidirectional scripts, complex shaping, color emoji, markup.

Shared base for UniText components — handles text processing (Unicode, BiDi, shaping, line breaking, modifiers, emoji, font fallback, variable fonts). Concrete subclasses supply the rendering backend: [[UniText]] (Canvas) and [[UniTextWorld]] (world-space).

Bridges a Unity Animator to a [[UniTextBase]]: Animator writes hit serialized fields directly and bypass the property setters that normally invalidate the text pipeline, so this turns them back into the correct [[UniTextDirty]] invalidation.

Single-selection dropdown with UniText captions and prefab-authored list, item, and outside-click templates.

Prefab-authored option view driven by its owning dropdown.

A parse rule matching a configurable tag name.

Base class for parsing XML-style markup tags (e.g., <b>, <color=#FF0000>).

Combines multiple parse rules into a single rule.

Matches literal string patterns and optionally replaces them.

Base class for serialized and runtime producers of text range entities.

Represents a parsed text range with associated tag information.

Base class for logic that alters the appearance, layout, semantics, or behavior of ranges emitted by a [[RangeSource]].

Links a range source with the modifier graph applied to its entities.

Shareable, project-asset container of [[Style]] entries that components apply in bulk via [[StylePresets]] or via [[GlobalStylePreset]].

Sets horizontal alignment, justify mode, and last-line alignment for the paragraphs it covers. Apply whole-text or per range/tag — each paragraph can differ.

Matches only when every child selector matches.

Per-range opacity: a multiplier on the alpha of each glyph and of every layer drawn from it.

[[IPaintProvider]] backed by an explicit [[UniTextPaints]] asset reference.

Base class for modifiers that render horizontal lines across text (underline, strikethrough).

Base class for modifier-authored geometry attached to final visual text ranges. It owns range accumulation, paint resolution, renderer handles and main-thread rebuild timing; subclasses only translate one immutable [[RangeDecorationContext]] into a [[RangeMeshWriter]].

How a layer's offset iso-lines treat glyph corners.

Writes the unified paint vertex contract — colour, coverage (TEXCOORD2) and paint (TEXCOORD3) — into a reserved quad whose positions/UV0/UV1 were already copied from the glyph template by [[ReserveQuad]]. One writer shared by every layer kind so the contract lives in a single place.

Fills the glyph interior with a colour, gradient, or texture. The first fill on a glyph claims the (default-suppressed) base quad; additional fills stack above it. Any fill present suppresses the implicit default fill. A colour glyph the fill leaves untouched is drawn as its own picture at the fill's position, even above a lower fill that painted its silhouette; with several such fills the picture takes the topmost position.

One Animator-driven diff unit on a [[UniTextAnimationBridge]]. A Unity Animator writes serialized fields directly, bypassing the property setters that normally raise [[UniTextDirty]]; a handler caches a baseline of the values it watches and, after each apply, re-issues the invalidation those setters would have.

Resolves names through an explicit [[UniTextRevealHandlers]] asset reference.

Periodic hops off the baseline: glyphs jump and land with a sharpened half-sine, staying put between hops.

Launches glyphs from deterministic radial directions into their final cells.

Combines deterministic direction, scale, rotation and colour variation per glyph.

Applies several reveal handlers in authored order while occupying one modifier slot.

Serialized font definition that owns face and rendering metadata and resolves its immutable source lazily. Embedded sources stay in the asset in the Editor and WebGL; other players resolve build-generated disk-backed sources. The [[Core]] materializes only when glyph or shaping work first needs this face.

Ordered list of font families plus an optional fallback stack. The first family's primary provides strut metrics (line height, ascent, descent). Face matching uses pre-computed lookup tables with CSS Fonts Level 4 §5.2 weight matching.

A font family: primary font plus optional variant faces (Bold, Italic, Variable, etc.).

Owns Unicode-sequence font resolution for a text object: composes the family chain from the assigned font and font stack, walks it (plus emoji and the always-on [[SystemFont]] fallback) to pick a covering runtime and exact variation instance when available, and otherwise returns the primary runtime as the intentional.notdef endpoint. Asset-backed faces are captured as worker-safe lazy slots; bare runtime companions and the emoji singleton flow through the same resolution path. The owner must dispose the provider after all processing and raster work finishes.

One variable-font axis pinned to a custom default value, keyed by its OpenType tag (4-char tag packed big-endian, same bits as the HarfBuzz uint tag).

Plain runtime for a font: owns face access, glyph tables, lookup dictionaries, curve cache and atlas pipeline. Constructable on worker threads (no Unity object lifecycle). Dispose instances constructed directly; a [[UniTextFont]] owns and disposes the runtime exposed by its asset.

Processes Unicode text through script analysis, BiDi reordering, shaping, and layout.

Positions glyphs within the layout bounds based on line breaking results and alignment settings.

Configuration for text layout and positioning.

Configuration settings for text processing operations.

Text shaper that converts codepoints to positioned glyphs through a runtime font face. SFNT-backed fonts use HarfBuzz for full OpenType shaping; platform-native faces supply equivalent glyph and positioning results through their backend.

Represents a line of text after line breaking.

Provides a viewport, drag and wheel scrolling, inertia, elastic edges and optional scrollbars for Canvas text of any length; drives the text RectTransform to fill this view.

Loads a [[DocumentSource]] into a [[UniTextBase]] — on enable, whenever the source, any of its settings or the text changes, and on [[Reload]] — and hands the document over with ownership, so the text disposes it when it is replaced or destroyed. Inside a [[ScrollRect]] or under a mask the document scrolls and windows itself.

Where a text component's document comes from. A source yields a [[Rope]] built for the scan profile of the text that renders it; the built-in sources read files, streaming assets and text assets, and a custom subclass appears in the inspector picker like any other. Every setting is state: a change publishes through the source, and a loader holding it reloads.

A file addressed as a root folder plus a relative path. Roots the platform exposes as folders load synchronously through [[FileTextSource]]; roots that are URLs (streaming assets on Android and on the web) download and deliver later, which needs the built-in Unity Web Request module — without it a URL location fails to load.

A [[TextAsset]]'s bytes as the document. Unity holds the whole asset in memory, so this suits documents up to a few megabytes; larger files belong in streaming assets behind a [[FileDocumentSource]].

The document: a flat table of [[TextBlock]] leaves with indexes over chars, codepoints, paragraph separators, heights and line widths. Every position query — char↔codepoint, char↔paragraph, Y↔block, X↔block — is O(log blocks); an edit costs O(edited block) plus O(log blocks), or O(blocks) when it changes the block count. Blocks lent to workers through [[Lease]] are immutable for the lease's lifetime: an edit clones a shared block instead of mutating it.

Editing capability for [[UniTextSelectable]]: text storage (gap buffer), undo/redo, IME composition, validators, caret rendering, input intents, touch gesture pipeline, keyboard / clipboard handling, and the public mutation API (InsertText, Cut/Copy/Paste, Undo/Redo, etc.).

Base class for composable input policies attached to a [[UniTextEditable]].

Shareable, project-asset container of [[InputBehavior]] entries that editors apply in bulk via [[BehaviorPresets]] — one asset defines a field archetype (chat composer, form field, password) reused across scenes. Each editor runs its own copies of the behaviors, so per-instance behavior state never leaks into the asset.

Base class for state-driven field visuals: placeholder, floating label, supporting text, character counter, or validation feedback. It participates in the ordinary [[InputBehavior]] lifecycle and appears in the editor's behavior type picker.

Read-only view of a text document with codepoint-indexed access. Implemented by [[UniTextEditable]]; consumed by generic text-aware features (find / replace, validators, accessibility readers) that should not depend on the concrete editor type.

Filters alphanumeric input: Unicode letters and ASCII digits [0-9].

Selection capability for [[UniTextBase]]: caret + range state with explicit affinity, gesture interpretation (multi-click promotion, drag-to-select, word-by-word drag, context-menu coordination), and highlight rendering. Sits on the same GameObject as [[UniTextBase]]; requires an existing [[UniText]] or [[UniTextWorld]] — [[RequireComponent]] validates the dependency but cannot auto-add the abstract base, so add the text component first.

A command of the text context menu: its label, when it applies, and what it does to the field that presents it. The field lists its commands in [[Commands]]; the system menu shows the applicable ones in that order, and the Unity-UI menu shows each on the item bound to it. Derive from it and implement [[Execute]] for a command of your own.

What a field's [[Commands]] list holds: a contributor of entries to the text context menu. A [[TextCommand]] contributes one entry; [[SystemTextActions]] the platform's own actions. Derive from [[TextCommand]] for a command of your own.

Context menu you lay out yourself in Unity UI: a panel and the objects its items show on, styled and localized however you like. Each of its [[Items]] binds an object of the layout to the command it runs; the menu shows the objects of the commands the field offers and runs a command when its object is clicked. It draws nothing itself, and one menu serves every field that presents it — a click acts on the field that showed it last.

One item of a [[UniTextContextMenu]]: an object of the menu's layout and the command it runs. The menu shows the object while the field offers the command and runs the command when the object is clicked.

Shipped Unity-UI presentation used by [[PrefabSelectionHandles]]. It instantiates a user-authored prefab for the draggable selection handles (one prefab used for both the anchor and focus carets) and for the collapsed-caret insertion handle, and places each at its caret point. The split of ownership: the prefab owns the look — sprite, colour, material, and the pivot, which alone decides how the handle sits relative to the caret (a teardrop pivots at its tip); the code owns the size, forcing each handle to a square of [[handleSize]] dp so the touch target stays a constant physical size across canvases, resolutions, and densities (a fingertip is device-independent). Put Preserve Aspect on the prefab's Image so its sprite fits that square undistorted. Assign its prefab inside a [[PrefabSelectionHandles]] entity; geometry is pulled from the [[UniTextSelectable]] presenting them at call time, the instances live in a canvas-level overlay so the field's RectMask2D never clips them, and a handle whose caret scrolls outside the field box hides until it returns. A [[SelectionHandleDragger]] (drag routing) and a [[FocusGuard]] (so grabbing a handle never defocuses the field) are ensured on each instance, so the prefab need only carry a raycastable Graphic.

Reveals world-space ranges by panning a camera or configured camera rig in its view plane. It never changes zoom, projection, rotation or range layout.

Claims a custom drag after the shared pointer slop is exceeded.

How U+FFFC inline-object clusters participate in range hit geometry.

Interactive ranges carrying a string value to routed event handlers.

Interactive ranges with shared hit policies, routed events and state rules.

Represents a clickable / hoverable / long-pressable range within text.

[[IObjProvider]] backed by an explicit [[UniTextObjects]] asset referenced on the modifier. Use this when multiple components should share the same inline-object catalog managed as a project asset.

[[ISpriteProvider]] backed by an explicit [[UniTextSprites]] asset referenced on the modifier. Use this when multiple components should share the same sprite catalog managed as a project asset.

Tri-state bool override: [[Inherit]] falls back to the weaker layer's value (the catalog entry).

Common entry-data base for inline-flowed media ([[InlineSprite]], [[InlineObject]]). Carries the name and shared presentation data; the renderable payload is added by the concrete subclass.

Inline-media modifier with typed per-entry overrides.

Shared base for modifiers that flow inline media — sprites, prefab instances — through text. Owns the catalog snapshot, the per-occurrence resolution of size, offset, advance and line space, the shaping-slot rewrite that reserves the media's advance, and the line-space reservation. How an occurrence becomes visible is the subclass's: a glyph in the text mesh ([[SpriteModifier]]) or a child object ([[InlineObjectModifier{TEntry, TWrapper, TOverride}]]).

One entry in the bind map: the modifier type plus its schema.

Read-only selection payload handed to [[SerializeCopy]].

Static registry of per-type clipboard schemas: which HTML elements, Markdown delimiters, and canonical source tag each [[BaseModifier]] type speaks. The schema is type-level metadata — instances have no say in it — so it lives here, not on the modifier: modifiers stay clipboard-ignorant, registration is explicit (no assembly scan, nothing for IL2CPP stripping to break), and the first paste costs nothing. Built-ins are pre-registered; integrator modifiers join via [[Register{T}]].

Visible paste text and its resolved destination formatting.

Read-only payload handed to [[DeserializePaste]]. Carries the editor so adapters can resolve external formatting against the destination's styles.

One persistent formatting annotation clipped to UTF-16 coordinates within [[VisibleText]].

Platform system emoji provider. Owns the primary face and any platform fallback faces required by individual emoji clusters.

Utility for locating file-addressable system emoji fonts across platforms.

Runtime for a color font (CBDT/sbix bitmap or COLRv0/COLRv1 vector). Plain [[Core]] subclass — not a ScriptableObject; constructable on worker threads. Owns the color-glyph rasterization pipeline: color-format detection, FreeType/Blend2D rendering into the shared color atlas, and color glyph metrics. The system emoji font ([[EmojiFont]]) and the [[UniTextColorFont]] asset are both built on this base. A glyph an effect decorates also gets a silhouette field in the SDF atlas, derived from the same bitmap's alpha when it is packed.

Cross-platform system-clipboard access. Routes through [[Provider]] to the active [[IClipboardProvider]]; convenience static methods on this class cover the plain-text fast path that most integrators need.

Facade for native producer lifecycles and software-keyboard notifications.

Cross-platform identifier for a clipboard payload. The canonical identifier is a MIME-style string (text/plain, text/html, text/uri-list); each platform clipboard provider translates to the correct OS-level identifier at the boundary (UTI on Apple, CF_HTML / "HTML Format" on Windows, MIME on Web / Android / Linux).

A single (format, payload) pair on the clipboard. Multi-format writes pass a list of items in one atomic [[SetItems]] call; the OS stores them as a single clipboard write whose richest available format is selected by the consumer on paste.

A single clause (segment) within an IME composition string, with its boundaries and style.

Visual classification of one clause in an IME composition.

Marks a string field as a default parameter for a parse rule. Draws the opt-in parameter list generated from the paired modifier's [Parameter] fields.

Inspector emphasis for one of the few [[ParameterAttribute]] fields that characterize their modifier and are adjusted most often: a style newly added with the modifier shows the field at its default value, where other parameters stay hidden until they differ from their defaults or the author adds them.

Unicode General Category property values.

Emits the modifier's parameter surface from its [[ParameterAttribute]] and [[SlotlessParameterAttribute]] fields: the nested Param descriptor class, Param.All, and the Descriptors override. A modifier declaring [[ParameterAttribute]] or [[ParameterContainerAttribute]] fields must carry it.

Populates a string parameter field's dropdown from a registered parameter provider (e.g. "@paints", "@fonts") instead of a fixed enum.

Marks a serialized field as positional parameter metadata: its C# type, declaration order, name, and initializer drive the editor schema and runtime fallback.