Changelog

• Added
  HDRP lighting for world-space text: Lit world text now receives real HDRP lighting, fog and shadow casting through the LightSide/World Lit HDRP Shader Graph, which installs itself into Assets/LightSide/HDRP in HDRP projects; Light Influence works as on the other pipelines, while Ambient Strength and Directional Strength have no HDRP counterpart — light intensities are the scene's there.
• Added
  HDRP in the custom world shader templates: the world shader template and the Rainbow, Hologram and Dissolve examples now carry an HDRP SubShader — regenerate a custom shader from its template to pick it up; already-generated shaders keep rendering under HDRP as before.
• Added
  Folder tree in the migration Analysis tab: pick a folder to narrow the finding list to that part of the project, with the count each folder holds under the current filters, instead of typing paths into the search box.
• Added
  Leaving an asset out of the migration: Exclude on an Analysis row, and Settings ▸ Add asset…, take a single scene, prefab or asset out — so a run finishes around one you keep on TMP or one nothing can read, and the tree's Exclude does the same for a whole folder of third-party content.
• Added
  Mesh-only invalidation for custom animated modifiers: GlyphParamModifier re-resolves its parameters before every mesh rebuild, so subclass parameter fields point their state callbacks at the new protected MarkParamsDirty(), and modifiers that re-resolve their own per-range state the same way raise the new protected BaseModifier.MarkRenderDirty(bool) instead of a full re-apply.

• Changed
  Exclusions now cover the whole migration, not only the scan: nothing under an excluded path is migrated or reference-repaired either, so a reference inside it to a component the migration replaced is yours to fix — the Dashboard and Settings state this while any path is excluded.
• Changed
  The side lists read as panels: the folder tree and the Script Preview file list sit on their own surface rather than floating against the window.
• Changed
  Per-frame cost of animated text: writing an animation parameter each frame — a glyph effect's Phase, RevealModifier's front, ScrambleModifier's progress, or anything a UniTextDriver drives — now rebuilds only the mesh instead of re-applying every style on the text, so texts carrying several styles animate many times cheaper.
• Changed
  Less steady-state garbage: per-frame text rebuilds in players, color-token parsing, and the validation of each newly spawned styled text no longer allocate.

• Fixed
  Buttons not firing under UniText: a Button or any other Selectable holding UniText activated only while the pointer neither moved nor crossed between the text and the rest of the control, so a press that slid a few pixels, or one that started on the text and ended beside it, produced no click.
• Fixed
  World-space text magenta under HDRP: UniTextWorld text, world decorations and world vector animation drew the magenta error shader in HDRP projects.
• Fixed
  Prefabs refused over an asset that was not theirs: migrating a prefab holding a TMP_InputField failed with a message naming an unrelated scene the tool could not read; the blocker now names the asset that actually stopped it and how to get past it.
• Fixed
  Scripts rewritten without the whole project checked: an asset the migration could not read was passed over in silence, so a field pointing at a TMP component from inside it could be dropped by the rewrite without a trace.
• Fixed
  Analysis list jumping to the top: Skip, Migrate or Re-check on a row sent the list back to the first entry, so working down a long list meant scrolling back after every press.
• Fixed
  An exclusion swallowing a neighbouring folder: excluding Assets/UI also excluded Assets/UIKit.
• Fixed
  File names centred in the Script Preview list: the rows were drawn centred instead of reading from the left edge.
• Fixed
  Linux typing with the Input System package: printable characters never reached a focused field on Linux — editing keys worked, letters did not; typing now works under every Active Input Handling setting.
• Fixed
  ScrambleModifier progress frozen when driven alone: changing Progress from code or a driver without also churning Phase left the decode where it was — it caught up only when something else made the text re-apply its styles.
• Fixed
  Blend materials lost or leaked on layer surfaces: a layer with a non-Normal blend could drop its material shortly after its text was disabled and re-enabled, and changing such a layer's blend mode or material left the previous blend variant alive for the rest of the session.
• Fixed
  Invisible keyboard on Android 12/12L: tapping a field could leave the software keyboard off screen while the system reported it shown — retapping never helped and only a screen power cycle brought it up; hits devices whose final OS is Android 12, such as the Pixel 3a.
• Fixed
  Held Backspace deleting one character on Android: holding the delete key erased a single character instead of repeating for as long as it was held.
• Fixed
  Keyboard blink on Android: the keyboard hid and immediately re-showed when the first character was typed into an empty field and when the last one was erased.

• Added
  Custom native field presenters: the surface of a platform-native text replica can be built by your own code on Android, iOS and WebGL, while UniTextEditable stays the only text authority — documented in Documentation~/NativeFieldPresentation.md:

  • NativeFieldOverlayBehavior.PresenterId picks a presenter registered from an Android library (UniTextNativeInput.registerNativeFieldPresenter), an iOS plugin (UniTextNativeInput_RegisterNativeFieldPresenter, declared in the shipped UniTextNativeInput.h) or a page script (window.UniTextNativeFieldPresenters).
  • Identifier sets the platform control identity — Android tag, iOS accessibility identifier, DOM id — and PresenterData carries an opaque per-field string only that presenter interprets.
  • The reserved system presenter follows the host's own appearance and cannot be replaced or unregistered; a presenter owns layout and appearance only and must keep the supplied editor's input connection, delegates and text path intact.
  • The native placeholder is the text of the object on PlaceholderDecorator, so one placeholder serves both the Unity field and its replica.
• Added
  Semantic editor actions from a native control: NativeEditorAction gained Cancel, Copy, Cut, Paste, PastePlain, Undo, Redo and Return beside Submit, Next and Previous, with IsSupported to test one — a presenter's own buttons send an action rather than touching the native value or the platform clipboard.
• Added
  Android autofill hints reach the native field: the autofill hint on a NativeKeyboardBehavior now sets the Android control's own autofill hints, where it was honoured on iOS and WebGL only.
• Added
  AttributeChannel: the pipeline passes reading one attribute key now belong to a channel that runs once per rebuild however many modifiers write that key:

  • A PooledAttributeModifier<T> subclass declares one from CreateChannel and reaches it through SharedChannel; OnActivate, OnDeactivate and OnRelease bracket the writers' active span, OnBeginCycle resets state once per apply cycle, and OnProviderChanged rebinds what the channel captured from a writer that left.
  • UniTextBuffers.ActivateChannel registers a writer against a key directly.
• Added
  PooledArrayAttribute<T>.WritableSpan: the extent prepared by Prepare, or one range of it, as a writable span, so a modifier can fill an attribute without a value-per-element call.
• Added
  UniTextMeshGenerator.currentPositionedIndex: the positioned glyph behind the quad being emitted, or -1 for a quad its emitter authored directly in final pixel space (a decoration line slice) — a modifier that scales a quad about its own pen must skip those.
• Added
  FontFeatureModifier (default tag name feature): turns OpenType features on or off over a text range — kern 0 to drop kerning, -liga, tnum for tabular figures, ss01 2, or several separated by commas; nested feature ranges merge, and the innermost value wins a shared tag.
• Added
  UniTextBuffers.AddFontFeatures: a modifier of your own can hand OpenType features to shaping, building the set with FontFeature and interning it through FontFeatureRegistry.
• Added
  UniTextBuffers.TryResolveInjectedGlyph: resolves a character a modifier draws outside the document text — an ellipsis dot, a list marker, a wheel symbol — in the face the text around it resolved to, returning the glyph and its advance as an InjectedGlyph.
• Added
  Overlay on underline and strikethrough: draws the line together with every layer applied to it — stroke, shadow, glow — above the whole text instead of stacking each of those layers at its own position in Styles, so a line over outlined text keeps its own outline and reads as a separate mark rather than merging into the glyph faces.
• Added
  UniTextMeshGenerator.sequenceBias: raises the layer sequences a modifier records while it is set, so a modifier drawing virtual glyphs of its own can lift their whole stack into a band above the text; layers fold it in where they capture the sequence, during onGlyph.
• Added
  Text structure queries: count and walk a text by TextUnit — clusters, words, lines or paragraphs — through Units, CountUnits, UnitAt and TextSpan on the text component, or Units and CountUnits on a ModifierRange for one range's own share; words follow UAX #29 and any installed dictionary, so Thai, Lao, Khmer, Myanmar and CJK divide correctly, and enumerating allocates nothing.
• Added
  Unit on RevealModifier (third tag parameter, <reveal=fade,50%,line>): the frontier advances by cluster, word, line or paragraph, so a whole word or line arrives in one movement instead of letter by letter; changing it rewrites an absolute Front to keep the same text revealed.
• Added
  TextProcessor.Analyzed: a pipeline hook that runs once script, direction, break and word analysis is final and before shaping begins — the phase for work that needs those results and must still reach shaping, hiding characters from it above all.
• Added
  RevealHandler.SupportedUnits: an appearance effect declares the granularities it is meaningful at as a TextUnits set; a reveal counting in another one reports the mismatch and plays the effect unchanged.
• Added
  RevealGlyphInfo.unit and RevealGlyphInfo.text: an appearance effect can read the codepoint span of the glyph's whole unit and reach the text it belongs to, so an effect can move a word or a line as one body.
• Added
  GeometricRevealHandler: base for eased appearance effects that turn the glyph quad around a point, carrying the authored Pivot a custom effect would otherwise declare for itself.
• Added
  Configurable pivot on the spiral, burst, rain and chaos reveal effects: their transform point was fixed at the glyph centre.

• Changed
  LightSide Core 3.1.0 required: the package now depends on media.lightside.core 3.1.0, up from 3.0.0.
• Changed
  Glyph atlas upload memory: steady-state CPU memory for glyph delivery drops from two page-sized buffers per atlas (16 MiB SDF, 64 MiB MSDF) to a small shared pool proportional to the frame's actual glyph traffic, released when text is idle.
• Changed
  Font file storage: a font asset's compressed file bytes now live in a hidden sub-asset and, in players, on disk instead of the managed heap — rendering reads a memory-mapped cache, so font bytes never stay resident and fonts that are never displayed are never decompressed; existing font assets convert themselves on the first editor load after the upgrade.
• Changed
  Fonts in AssetBundles: content built with the Scriptable Build Pipeline (Addressables included) delivers each font through an on-demand entry — loading a bundle no longer deserializes font bytes, the payload is fetched and cached once per installation, and the bundle can be unloaded immediately afterwards.
• Changed
  Font payloads ship beside the player for exactly the fonts a build packs: the set is taken from the build's own packed content; an incremental build that reuses content without reporting it reuses the payload published for that content, or, failing that, packages every font in the project and says so in the console — a clean build restores the minimal set.
• Changed
  Default text context menu is smaller: the bundled selection context-menu prefab drops to a 22 px label on 48 px rows in a 160 px-wide panel, from 30 px on 72 px rows at 300 px; a project using its own context-menu prefab is unaffected.
• Changed
  A custom modifier's pipeline passes move to a channel: a PooledAttributeModifier<T> subclass that subscribes its passes in OnEnable runs them once per instance instead of once per text — declare them in CreateChannel instead; a subclass that overrides OnDisable or BeforeApply must now call the base implementation, and state produced only by the parse, shaping or layout phase must not be cleared from BeforeApply, which a granular re-apply runs without re-running those phases.
• Changed
  UniTextMeshGenerator.ExpandQuad derives its own scale: the method no longer takes a scale argument and reads the quad's own UV0-to-pixel ratio instead, so an expansion lands on the same iso-line whatever size the quad was built or scaled to; SubMeshModifier.ExpandSubMeshQuad takes its delta in the same UV0 units.
• Changed
  Mixing appended and range writes on one pooled attribute throws: PooledArrayAttribute<T> now rejects an Add after a FillRange since the last Prepare, and the reverse, with an InvalidOperationException.
• Changed
  StylePreset.Changed removed: subscribe to DeltaChanged, which reports the same mutations with their affected node, member and operation.
• Changed
  UniTextFont.FontData returns a fresh copy: each access copies the font's bytes rather than handing out the asset's own array, and CopyFontData() names that cost at the call site.
• Changed
  An unpaired UTF-16 surrogate reads as U+FFFD: UnicodeData.DecodeAt and the parsed codepoint buffer replace a lone surrogate with the replacement character instead of passing its raw value through to a parse rule.
• Changed
  A word that needs an operating-system font is resolved as a whole on macOS: when no assigned font covers a word, the whole word is offered to the system cascade first, so it lands on one face instead of switching typeface between its characters.
• Changed
  The system emoji font is no longer copied into memory on iOS: the face is held by the operating system and queried for coverage, advances, shaping and rasterization in place, where Apple Color Emoji's whole file used to be rebuilt into a managed array on first use.
• Changed
  SystemFont.MemoryStats counts only memory-backed sources: a system font delivered as a mapped file reports no retained bytes and does not consume InactiveByteBudget, so both numbers now track resident memory rather than font size.
• Changed
  Native input is a session rather than a global switch: UniTextNativeInput no longer exposes ShowKeyboard, HideKeyboard, SetEnabled, CompleteComposition, CancelComposition, Context, or the static KeyDown, TextInput, DeleteBackward, EditorAction, CompositionChanged, CompositionEnded, SelectionChanged, NativeFieldSubmitted, NativeFieldCanceled, NativeFieldTextChanged and NativeFieldCreated events:

  • INativeInputBackend is rebuilt around OpenInput, QuiesceInput, CloseInput and AbortInput taking a NativeInputOpenRequest and reporting through a NativeInputReporter, so a custom backend must be rewritten; the RegisterBackend(INativeInputBackend, int) overload is gone and a backend registers through its factory overload.
  • CompositionChangedHandler is gone with the events it typed, and UniTextEditable no longer implements ITextInputContext.
  • UniTextEditable.TouchKeyboardVisibilityChanged is gone — read UniTextNativeInput.IsKeyboardVisible or subscribe to UniTextNativeInput.KeyboardVisibilityChanged.
  • NativeEditorAction.Newline is now NativeEditorAction.Return.
• Changed
  NativeFieldOverlayStyle and NativeFieldHandle removed: per-platform styling of the native replica and the raw handle to its view give way to the presenter contract, taking NativeFieldOverlayBehavior.Style and KeyboardRequest.overlay with them, and a behavior authored in 3.2 comes up on the system presenter without its styling:

  • Placeholder is now the text of the object on PlaceholderDecorator, and CharacterLimit is LengthLimitBehavior, which the replica now obeys like any other input rule.
  • IOSAccessibilityIdentifier and WebGLId are the one Identifier field.
  • AndroidBackgroundResource, AndroidTextAppearanceResource, AndroidThemeResource, WebGLCssClass and WebGLInlineStyle have no direct replacement — a custom presenter builds the surface instead, and system follows the host's own appearance.
• Changed
  UniTextEditable.OnDetachedFromCell takes a completion callback: a virtualised-list host passes an Action and recycles the object when it runs, instead of reusing the cell the moment the call returns while a native session is still closing.
• Changed
  Faster rebuilds of text using OpenType features: a range with small caps, superscript, subscript or font features is now as cheap to re-shape as plain text.
• Changed
  UniTextBuffers.RequestVirtualCodepoint covers every face: a character declared for drawing outside the document text is now prepared for every font the text resolves to, not only the one the font stack picks for that character on its own.
• Changed
  A reveal pivot is a normalized Vector2: the nine named corners give way to a point over the glyph quad — (0,0) its bottom-left, (1,1) its top-right, outside the unit square beside it — so a pivot can sit anywhere and be driven like any other vector; a pivot authored in 3.2 comes up at its effect's default.
• Changed
  RevealGlyphInfo is restated rather than rebuilt: an appearance effect wrapping others calls WithProgress to give a child its own timeline or WithFront to restate the frontier, where it used to construct a second RevealGlyphInfo; that constructor is gone.
• Changed
  Faster reveal, scramble and rolling animations: text is re-shaped only when the set of characters taken out of the layout changes, instead of on every frame of any of those animations.
• Changed
  Auto Size lands on an exact size: the fitted size is the largest one the box actually allows rather than the nearest half point, so CurrentFontSize reports fractional values and follows a resize smoothly instead of in visible steps.
• Changed
  Auto Size is significantly faster: a fit settles with much less work per rebuild — the gain grows with the text length and with the span between Min and Max — and a Fit Steps ladder now costs a fraction of what it did, a line-height step next to nothing.

• Fixed
  Auto Size flipped between two font sizes: in a box sized to the text's own preferred height — what a ContentSizeFitter produces — the size alternated between rebuilds and jumped by half a point at a time, and the text was drawn up to half a point smaller than the box allowed.
• Fixed
  Auto Size overflowed the width of an indented paragraph: a paragraph's start margin, from <indent> or a list marker, was left out of the fit's width test, so the text was sized as if that space were free.
• Fixed
  Crash loop on 32-bit Android devices: [GlyphAtlas:SDF] GPU upload failed (SourceOutOfRange) could recur on every launch on armeabi-v7a phones, permanently breaking text rendering.
• Fixed
  A second modifier of the same kind applied its effect twice: two modifiers writing one attribute — two letter-spacing modifiers, a bold in the component's styles and another in a style preset, a <sup> rule beside a <sub> rule — each ran that attribute's pipeline pass over the shared buffer, so tracking was added twice, synthetic bold expanded twice and an arc bent twice.
• Fixed
  Two underline, strikethrough or glitch modifiers on one text drew each other's ranges: each read the shared range marks with its own parameter list, so both ranges came out with the wrong thickness, offset and colour.
• Fixed
  <math> formulas and <ruby> annotations vanished when a neighbouring style changed: a hover state, a driver clip or an inspector edit on a modifier overlapping the range discarded the formula's layout or the annotation's shaped glyphs, leaving the range blank until the next full rebuild; inline media in the same situation was measured against a stale shaping position.
• Fixed
  <indent> grew every time a neighbouring style changed: the start margin was added again on each re-apply instead of replacing the previous one, so a hover state or a driver clip pushed the paragraph further right on every change.
• Fixed
  A <reveal> with Collapse snapped to its end state when a neighbouring style changed: an in-flight appear or hide animation was completed early by any overlapping modifier's parameter change, and the frontier lost the previous-frame comparison it animates against.
• Fixed
  Math fraction bars and radical bars ignored the range's size: inside a <size>-scaled or small-caps range the bars kept the base size's width and thickness, then took the range's scale a second time, landing detached from the formula.
• Fixed
  Stroke and outline thickness on texture-painted scaled text: an effect expanding a quad drawn from a paint texture measured its step against the base font size, so inside a <size>-scaled or small-caps range the outline came out too thin on enlarged text and too thick on shrunken text; a custom SubMeshModifier calling ExpandSubMeshQuad had the same error.
• Fixed
  macOS 15 system faces rendered nothing: the faces macOS 15 ships with their outlines outside the font file cannot be rasterized from disk, so an operating-system font resolving to one — the default UI face included — produced blank text; those outlines now come from the operating system itself.
• Fixed
  macOS system fonts with no readable font file were skipped: a family the operating system exposes without a file path failed to resolve and fell through to the next candidate, where it now loads like any other.
• Fixed
  COLRv1 colour fonts rendered flat: a font was judged COLRv1-capable by whether its grinning-face emoji carried a paint and by having no bitmap strikes, so a COLRv1 icon or symbol font with no emoji in it, and a font shipping both COLRv1 and bitmap glyphs, lost their colour layers; capability is now read from the font's own colour table and decided per glyph, with the bitmap or outline path taking the glyphs COLRv1 does not cover.
• Fixed
  A native field replica bypassed the editor's own input rules: with a NativeFieldOverlayBehavior attached, whatever the platform control produced was written into the document wholesale, so LengthLimitBehavior, InputMaskBehavior, CaseTransformBehavior, AutoValidateBehavior, every InputFilter hook, the undo history and the paste policy never saw it; typed, dictated, autofilled, pasted, deleted and autocorrected text now enters the same pipeline as keyboard input, and a programmatic document or selection change supersedes the native control's optimistic state.
• Fixed
  A native field replica ignored ReadOnly and lost track of secure entry: the platform control was never told the editor was read-only and so accepted edits, and password mode, keyboard traits and the placeholder were captured once at focus — changing any of them while the replica was open had no effect until it closed and reopened.
• Fixed
  <smallcaps> spread past the tagged range: the rest of the paragraph in the same font and script was rendered as small capitals too.
• Fixed
  <sup> and <sub> had no effect after a font, script or direction change in the same paragraph: on a font carrying real superscript or subscript glyphs the tagged characters kept their full-size baseline form instead of being raised or lowered.
• Fixed
  Characters drawn outside the text ignored its font: the … of EllipsisModifier, list markers and bullets, and the symbols of the rolling and scramble animations always came from the font stack's own pick, so bold, italic, a font override or a variable instance never reached them.
• Fixed
  <ellipsis> behaved erratically over several paragraphs: with word wrap on and more text than the box could show, the marker landed on the wrong line or alone on an empty one, and shrinking the box could show more text than a larger box had.
• Fixed
  <ellipsis> ignored the box height whenever the text was also too wide: with both dimensions exceeded only the width was honoured, leaving the overflowing paragraphs on screen.
• Fixed
  <ellipsis> gave up a character it did not have to: the marker replaced at least one character even on a line with room to spare for it.
• Fixed
  Text after an <ellipsis> range kept its old place: the content following a truncated range stayed on the line it occupied before truncation, leaving a gap after the marker.
• Fixed
  <ellipsis> reserved the wrong marker width under Auto Size: the space freed for the marker was scaled wrongly whenever the rendered size differed from the shaping size.
• Fixed
  RevealModifier in Collapse mode kept the lines of hidden text: paragraph breaks inside text the reveal had not reached still held their lines open, so the block stayed as tall as the whole text instead of shrinking to what it showed.
• Fixed
  <reveal> animations stuttered outside Play mode: a running appear or hide effect advanced in visible steps in the editor, and how smoothly it ran depended on whether the scene happened to hold an enabled UniTextDriver.
• Fixed
  Caret stood inside a letter instead of on its edge: text carrying an invisible formatting character — a zero-width space, a joiner, a directional mark, a byte-order mark — or a range a modifier had hidden placed the caret part-way across the neighbouring glyph.

• Added
  Every modifier field is a parameter: a modifier's serialized fields are now typed parameters addressable by id — read, written, interpolated and composed from code, targetable by a range rule, and drivable per range — where 3.1.0 exposed only the four properties three built-in modifiers hand-declared:

  • ParameterDescriptor / ParameterDescriptor<TModifier,TValue> carries Id, DisplayName, Slot, SlotOn, ValueType, ModifierType and SupportedCompositions, and offers Resolve, ResolveCascade, TryResolve, ResolveNext, ReadRoot/SetRoot, Lerp and Compose; ParameterDescriptor.Find looks one up by id and the generated Param.All lists a modifier's full set.
  • A parameter resolves one cascade — an explicit markup token first, then the rule default, then the modifier's own field — with owned values composed on top.
  • Parameter code generation: a partial modifier marked [GenerateParameters] gets its nested Param class, Param.All and its Descriptors override written for it, in your assemblies as well as UniText's, with authoring mistakes reported as compiler errors UTP001–UTP003.
  • [Parameter] gained Parser (a token vocabulary of the field's own), Invalidate and Descriptor; [SlotlessParameter] joins a field to the parameter surface without giving it a positional markup slot; [ParameterContainer] gained Invalidate.
  • A rule's Target picker now lists every parameter of every modifier in the graph, and IntRuleValue, BoolRuleValue, StringRuleValue and EnumRuleValue<TEnum> join the float, unit, vector, unit-vector and colour rule values, with RuleValue<TValue> as a public base for a project's own unmanaged value type.
  • Every parameter of a paint layer is now rule- and range-drivable — stroke width, alignment and softness, shadow offset, blur and spread, glow radius, fill softness and dilate, corner style and miter limit, tint, blend, and the paint's mapping, shape, fit, angle, scale, offset and spread — while the paint slot itself stays authored-only, on paint layers, line decorations and highlights alike.
• Added
  Range queries and parameter ownership: code can select the live ranges a modifier applies to and take one of their parameters into its own hands, writing it directly while the authored value stays underneath:

  • BaseModifier.Ranges() starts a RangeQuery whose filters combine with AND — WhereLabel, WhereParameter, WhereToken, WhereBare, WherePrimaryValue, WhereChannel, Intersecting, Within, Where (a custom ModifierRangePredicate), Skip and Take — and Collect returns the matches in text order; BaseModifier.GetRanges(List<ModifierRange>) collects them unfiltered.
  • ModifierRange carries Identity, Segment, Range, PrimaryValue, Label, Channel and IsValid, and reads or takes over one parameter of that single range through Resolve and Own.
  • Named tag ranges: an opening tag can carry a #name anchor written after a single space — <b #intro>…</b>, <color #warn=red>…</color>, <sprite #icon/> — naming that one occurrence for RangeQuery.WhereLabel; letters, digits, _ and - are accepted, paired, self-closing and void tags all take one, and ParsedRange.label with the trailing label argument on ParsedRange.SelfClosing lets a custom parse rule emit one.
  • BaseModifier.Own, RangeQuery.Own, ModifierRange.Own and UniTextRanges.Own return an OwnedParameter<TValue> (Value, Baseline, Composition, IsAlive, Release/Dispose) for one range, or an OwnedParameterSet<TModifier,TValue> for a whole query — whose Value broadcasts to every member, SetValue(index, …) writes one, Withhold deactivates them all without giving up membership, Count/GetRange walk them in text order, and Changed reports membership changes after each reparse.
  • An owned value combines with the authored one under ParameterComposition.Replace, Add, Multiply or Custom, at a caller-chosen priority.
  • RangeQueryDefinition is the serialized form of the same filters, built into a live query against a target modifier so its matches follow later text edits.
• Added
  UniTextDriver: a sequencer component (Add Component ▸ UniText ▸ UniText Driver) that animates modifier parameters over a shared timeline — each clip drives one parameter across the ranges its query matches, ramping every match from a From value to a To value inside its own window, with clips free to overlap and to drive different parameters of different modifiers:

  • Each UniTextDriverClip carries Start, MemberDuration, Stagger (matched ranges ramp one after another in text order), Easing, the typed From/To endpoints, Composition, Priority against other owners of the same parameter, a Query narrowing which ranges it drives, and Disabled.
  • Transport is Play, Pause, Stop, Seek and Advance, with Progress (normalized) and Playhead (seconds) both settable to render one exact state, alongside IsPlaying, TimelineLength, Duration (0 derives it from the clips), Speed (negative runs backwards), DriverLoop.Once/Loop/PingPong, a scaled, unscaled or manual clock, and Rebind.
  • A clip can target any parameter of any modifier in the component's Styles, its StylePresets or the project-wide style preset, and the picker groups the choices by modifier.
  • Clips is a live list and UniTextDriverClip.SetTarget binds a clip from code, so a sequence can be built or retargeted at runtime; each clip's ranges follow its query across text edits and return to their cascade when the driver is disabled.
  • Among Replace clips of the same parameter and priority the latest clip whose start the playhead has passed wins, while Add, Multiply and Custom clips compose alongside it, so a clip holds its boundary value until the next one takes over.
  • Playback and scrubbing work in the editor without entering Play mode, while Play On Enable starts only in Play mode; Progress is serialized, so a Unity Animator or a Timeline animation track can scrub the whole sequence.
• Added
  Timeline window for a driver: the driver inspector's timeline button opens the sequence in a window where clips are arranged on tracks and dragged, resized, split at the playhead, duplicated, copied, pasted, muted and marquee-selected, with a scrubbable ruler, snapping, zoom and pan, and transport synced to the driver:

  • Double-clicking a clip opens its full editor in place, and a multi-clip selection edits Start, Duration, Stagger, Easing, Composition, Priority, Mute and the query's label, skip and take together.
  • Tracks can be added and removed, double-clicking an empty lane creates a clip there, and splitting a clip gives both halves the value its easing reaches at the split.
  • Dragging the end marker sets the sequence's fixed duration.
• Added
  ModifierFieldsAnimationHandler: one handler on UniTextAnimationBridge animates the fields of every modifier in the component's Styles, nested children included, after a Unity Animator writes them — where each modifier type previously needed a handler of its own:

  • It rebinds when the style graph changes, so modifiers added or swapped at runtime are picked up.
  • It covers the component's own Styles only; a modifier living in a StylePreset or the project-wide preset is not animated by it.
  • A field whose change notification needs a value transition is skipped — drive it with a UniTextDriver clip instead.
• Added
  CharacterWidthModifier (default tag name cwidth): fits every character of a range into a fixed-width cell with the glyph centred inside it, from a width in em or pixels (1em for a full-width CJK cell, 0.5em for a half-width one) or auto, which measures the fitted text's own widest glyph:

  • Letter and word spacing add their tracking on top of the finished cell, so tracking and fixed cells combine.
  • It appears in the style picker as Character Width, and TextMeshPro's <mspace> imports as one.
• Added
  Gradient spread: a gradient can now repeat or mirror where Scale or Offset leaves part of the surface uncovered, through a Spread setting — Clamp, Repeat or Mirror, with Clamp, the 3.1.0 behaviour, as the default:

  • The setting reads Spread on a paint swatch and on a range highlight — authored or the live text selection reached through UniTextSelectable.SelectionHighlight — and Paint Spread on every effect, honoured by the fill, stroke, shadow, glow and inner-shadow layers, and occupying each effect's final parameter slot so markup can set it positionally.
  • A swatch hides it for an Angular gradient, whose sweep already spans exactly one period, and a texture keeps taking its wrap from the texture asset.
  • PaintSpread, PaintProjection.spread, TextPaint.spread, TextPaint.ApplySpread, PaintSpreadExtensions.Wrap, EffectModifier.ResolveSpread and a Gradient.Evaluate overload taking a spread mode expose it to script.
• Added
  Fit for radial and angular gradients: Fit is no longer texture-only — Contain and Cover keep a radial gradient's ring circular and an angular gradient's angles true inside a non-square area, Tile sizes square cells, and the row appears on any gradient swatch whose Shape is not Linear; a swatch still carrying a non-Stretch Fit from when its source was a texture now applies that fit to its gradient, where 3.1.0 discarded it.
• Added
  Playback: a public, allocation-free weight animation any type implementing IPlaybackHost can drive — instant sets, eased transitions, one-shot pulses, deferred release and reduced-motion completion, on a scaled, unscaled or manual clock.
• Added
  Reveal clock and manual time: RevealModifier.Clock picks the time source appear and hide effects advance on — Unscaled (default), Scaled so Time.timeScale slow motion and pauses reach reveal effects, or Manual, which advances only through AdvanceTime(float) for frame-exact or externally driven reveals.
• Added
  Reveal hide animations: when the reveal frontier recedes, text now animates out instead of vanishing — the cluster keeps its place in the mesh, and under Collapse in layout, until its effect finishes:

  • HideHandler on a named reveal entry picks the effect for the way out; left unset, the entry's own handler replays backwards, so every built-in effect works in both directions.
  • Reversing mid-flight continues from the glyph's current state instead of restarting it.
• Added
  RevealGlyphInfo.hiding: GlyphRevealing subscribers can tell a glyph that is leaving from one that is arriving — Progress is the settled glyph at 1 in both directions.
• Added
  Public RevealGlyphInfo constructor taking an explicit progress: a reveal handler that wraps other handlers can give each child its own remapped timeline, the way CompositeRevealHandler does.
• Added
  RollingModifier.Spread: the rolling wheel's per-character settle offset is now an authorable parameter — editable in the inspector, targetable by a rule and drivable by a driver clip — where 3.1.0 accepted it only as the tag's first value.
• Added
  ParameterProviders.Invalidate: a custom parameter-option provider whose catalog lives outside Unity's object graph must now call it for open inspectors to rebuild their dropdowns; catalogs inside the object graph refresh on object, project and undo changes instead of on every editor tick.
• Added
  Resolved parameter values in the inspection card: the text inspection card now lists each modifier's declared parameters with the values resolved on the probed cluster, beneath the modifier list it already showed.

• Changed
  Assets authored in 3.1 upgrade themselves: the first editor load after the update rewrites scenes, prefabs and presets in place — interactive ranges with their selectors and playbacks, the reveal frontier, easing values, the retired letter-spacing monospace flag and paint overrides all land on their new serialized shape, with no prompt and no menu step:

  • Markup you typed is left as written: a <cspace=…,true> keeps its now-ignored second token and has to be re-authored as <cwidth=auto>.
  • Only serialized data upgrades — code naming a renamed type or member still has to be updated by hand.
  • A prefab instance that overrode one of the renamed serialized fields loses that override and falls back to the prefab's value.
  • A UniTextPhaseDriver left in a scene or prefab is not converted; the component no longer exists and its slot shows as a missing script.
• Changed
  Interaction-state effects are now rules: the whole interaction-state vocabulary is renamed from "effect" to "rule", so every authored state graph and every line of code that touches one uses new type and member names:

  • Definitions: RangeStateEffect → RangeStateRule, ModifierEffect → ModifierRule, PropertyEffect → ParameterRule with PropertyId → ParameterId, and InteractiveModifier.Effects → InteractiveModifier.Rules.
  • Drivers became playbacks: RangeEffectDriver → RangeStatePlayback, InstantEffectDriver → InstantPlayback, BuiltInPropertyDriver → TransitionPlayback, SignalProgressEffectDriver → SignalProgressPlayback, ManualEffectDriver → ManualPlayback, and a rule's Driver → Playback.
  • Selectors: RangeEffectSelector → RangeStateSelector, with Scalar…, All…, Any…, Not…, Interaction… and SpoilerConcealed… taking the matching …RangeStateSelector names.
  • Rule values: RangeEffectValue → RuleValue, with Float…, Unit…, Vector2…, UnitVector2… and Color… becoming FloatRuleValue, UnitRuleValue, Vector2RuleValue, UnitVector2RuleValue and ColorRuleValue.
  • Supporting types: RangeEffectScope → RangeRuleScope, RangeEffectEvent → RangeRuleEvent, RangeEffectClock → PlaybackClock, RangeEffectContext → RangeRuleContext, RangeEffectLifecycleHandler → RangeRuleLifecycleHandler, and IModifierEffectWeightReceiver.SetEffectWeight → IModifierRuleWeightReceiver.SetRuleWeight.
  • The runtime: UniTextEffects.For(text) → UniTextRanges.For(text), RangeEffectInstance → RangeRuleInstance with GetProperty → GetParameter, and the events EffectEntered/EffectExited/EffectUpdated/EffectTriggered → RuleEntered/RuleExited/RuleUpdated/RuleTriggered.
  • Consumer-facing reads: RangeDecorationContext.EffectWeight → RuleWeight, UniTextRangeDebugSnapshot.Effects → Rules of RangeRuleDiagnostic whose DriverType is now PlaybackType, and InteractiveModifier.Ranges → InteractiveModifier.InteractiveRanges.
• Changed
  Modifier properties are now parameters: ModifierProperty / ModifierProperty<TModifier,TValue> became ParameterDescriptor / ParameterDescriptor<TModifier,TValue>, ModifierPropertyComposition / ModifierPropertyCompositions became ParameterComposition / ParameterCompositions, the handle EffectProperty<TValue> became OwnedParameter<TValue>, and ParameterRule.SetTarget<TModifier,TValue> takes a ParameterDescriptor where it took a ModifierProperty.
• Changed
  Reveal frontier is one Front parameter: RevealModifier expresses the frontier as a single Front value carrying its own unit — a percentage of the covered text or an absolute grapheme-cluster position — in place of the separate Fill and VisibleClusters:

  • Front is the second parameter of the reveal tag, so markup can set it: <reveal=fade,50%> shows half and <reveal=fade,12abs> twelve clusters; a number with no suffix takes the field's own unit.
  • Fill, VisibleClusters, FillProperty and VisibleClustersProperty are gone — code that set them sets Front instead (UnitValue.Percent(50f), UnitValue.Absolute(12f)).
  • An absolute frontier is fractional, so a position between two clusters blends the frontier cluster, where VisibleClusters was a whole count.
• Changed
  Easing values take custom curves: EasedRevealHandler.Easing, TransitionPlayback.Easing and SignalProgressPlayback.ExitEasing now hold an Ease rather than a bare EasingType, so every built-in reveal effect and every rule transition can run a cubic-Bézier or authored keyed curve; code assigning an EasingType must wrap it (Ease.Of(EasingType.CubicOut)).
• Changed
  Paint override enums folded into the resolved enums: GradientShape, LayerBlendOverride and PaintTextureFit are gone — shape, fit and blend are authored with PaintProjectionKind, PaintFit and LayerBlend, each of which now carries the shared Inherit member — so HighlightModifier.Shape and Blend, BaseLineModifier.Blend (underline and strikethrough) and RangeDecorationPaint.Fit all change type for code that assigns them.
• Changed
  Paint projection API takes resolved values: for custom paint consumers TextPaint.ApplyProjectionDetails no longer reads tokens itself but takes already-resolved projection values, ApplyProjection gained a reader-less overload beside its reader form, ApplyBlend takes a LayerBlend, ApplySpread is new, EffectModifier.ResolveBlend takes the range context beside the reader with a reader-less overload and a matching ResolveSpread, and BaseRangeDecorationModifier.ResolveDecorationPaint takes a PaintProjectionKind where it took a GradientShape.
• Changed
  Custom shaders reading the paint channel: the paint interpolator's fourth channel now carries the gradient's spread mode alongside the paint kind, so a hand-written shader that reads that channel directly must unpack it; a shader built from the shipped templates picks the change up unchanged.
• Changed
  Custom glyph animation modifiers: GlyphParamModifier<TParams> replaced ParseParams(ref ParameterReader) with ResolveParams(in RangeApplyContext) and OnGlyph now takes the range's resolved phase as a final argument, so a hand-written animation modifier declares its values as [Parameter] fields, carries [GenerateParameters], resolves through the passed context and uses the passed phase instead of the shared field.
• Changed
  Animation inputs resolve per range: the externally driven inputs of the animation modifiers — Phase on WaveModifier, WobbleModifier, BounceModifier, FloatModifier, PulseModifier, ShakeModifier, SpinModifier, PendulumModifier, GlitchModifier and ScrambleModifier, plus Progress and Rate on ScrambleModifier and Roll on RollingModifier — now resolve for each range the modifier covers, so a driver clip can put every matched range at its own point; with nothing driving them all ranges resolve the same value and look exactly as before.
• Changed
  Attribute stores prepare once per parse: a custom attribute store must now implement IAttributeData.Prepare(int), which UniText calls once per parse so the store is always indexed by the codepoints of the text currently being laid out; PooledArrayAttribute<T>.EnsureCountAndClear is renamed Prepare.
• Changed
  [Inheritable] now comes from LightSide Core: the attribute and its inspector override checkbox are no longer declared by UniText — unchanged in name, namespace and constructors, they ship in LightSide Core 2.0.5, which UniText now requires.
• Changed
  Reveal text animates out by default: a named reveal entry whose clusters become hidden now plays its effect backwards, where the text used to disappear instantly; a HideHandler with Duration 0 keeps the instant hide.
• Changed
  An unreadable parameter value falls back to the style's own setting: a tag whose value cannot be read — <color=nonsense>, a superscript tag with an unrecognised placement — now applies the value configured on the modifier, where 3.1.0 left that range unstyled.
• Changed
  255 painted ranges per paint layer: one fill, stroke, shadow, glow or inner-shadow modifier now paints at most 255 applied ranges in a single text; glyphs covered only by ranges past that keep whichever range already won.
• Changed
  Cheaper style parameter changes on heavily styled text: parameter changes at runtime — a hover state flipping, a driver animating a value, an inspector edit — are significantly cheaper on text carrying many styled ranges.
• Changed
  Colour rules animate without allocating: rules driving a Color32 parameter, and custom Color32 range signals, no longer allocate while comparing values, so a running colour transition adds no garbage.
• Changed
  Operating-system fonts are picked by family, not by file location: every entry in a UniTextSystemFont's platform tabs — and the project's default operating-system face, the one used when no font is assigned and at the end of every fallback chain — is now requested from the operating system by family name instead of being looked for at a fixed set of font-file locations, so an entry resolves wherever the machine keeps that family installed:

  • When neither the platform tab's font nor the Common fallback is installed, the remaining catalog entries are tried in order and then the operating system's own default face, where the last resort used to be the first font file found in the system font folder.
  • A resolved face carries the variable-font axis values the operating system bound to it, so a variable system font starts from the instance the OS chose rather than the font file's own defaults.
• Changed
  Android system fonts follow the device's own roles: the Android tab's entries now resolve to the device's own sans-serif, serif or monospace face, so Roboto, Noto Sans and Droid Sans all yield the real sans-serif of the device — a manufacturer-replaced UI font included — instead of failing when the device does not ship that exact font file.
• Changed
  System fonts resolve on first use: a UniTextSystemFont now looks its font up the first time it is drawn or its data is read rather than when the asset loads, so ResolvedFontName, ResolvedPath, ResolvedPlatform and ResolveFailed stay unset until then.
• Changed
  TextMeshPro <mspace> survives conversion: converting a TextMeshPro component whose text uses <mspace> now adds a CharacterWidthModifier bound to an mspace tag rule, where the tag was previously reported as having no UniText equivalent and left to render as literal text; the conversion report warns that TMP reads a unitless mspace value as font units while UniText reads it as pixels.
• Changed
  Default parameter rows copy and paste typed values: copying a default-parameter row now puts the modifier field's own typed value on the shared inspector clipboard — pasteable into any field of that type, with only compatible values offered — where 3.1.0 exchanged the raw token text through the system clipboard.
• Changed
  UniTextAnimationBridge icon: the component now shows an icon of its own in the Inspector, Hierarchy and Add Component menu.
• Changed
  One draw call for LightSide UI: text, its highlights and underlines, UniShapes shapes and UniLottie animations now render through one shared material on a Canvas, so a run of them collapses into a single draw call instead of one per component type; a shape filled with a traced sprite and a paint filled with a texture still take one call each.
• Changed
  Shaders renamed: UniText/SDF, UniText/Lit/SDF, UniText/RangeDecoration and UniText/UI/RangeDecoration are replaced by LightSide/UI, LightSide/World and LightSide/World Lit; materials in scenes and prefabs follow automatically, while a Shader.Find call naming an old shader in your own code has to be updated.
• Changed
  Custom text shaders: the prelude includes are now LightSide_Custom.cginc and LightSide_Custom-URP.hlsl, the glyph atlases are global bindings that must NOT be declared in a Properties block, the paint texture and its keyword are named _LightSidePaintTexture and LIGHTSIDE_PAINT_TEXTURE, and the coverage helpers are LightSideCoverage and LightSideInside; existing custom shaders need these renames and stop compiling until then.
• Changed
  World text no longer needs the Lit shader: unlit world text has a shader of its own, so excluding the Lit one leaves it rendering; a UniTextWorld with Lit on now warns in the Inspector when the project excludes the Lit shader.
• Changed
  Project Settings ▸ LightSide: settings shared by every LightSide package live here, with Include Lit Shaders — moved from Project Settings ▸ UniText — and a list of which shaders the project carries into builds; UniText's own page is now nested under it.

• Removed
  UniTextPhaseDriver: the phase-advancing component is gone — a looping UniTextDriver clip on an animation modifier's Phase parameter is the replacement — and scenes or prefabs that carry one lose the component, with no migration re-creating the motion.
• Removed
  IPhaseDriven: the interface a phase-driven modifier implemented is gone; the animation modifiers still expose a Phase parameter, and a custom modifier that implemented the interface only needs to drop it from its declaration.
• Removed
  Per-modifier Animator handlers: ModifierAnimationHandler and the shipped ColorAnimationHandler, SizeAnimationHandler, LetterSpacingAnimationHandler, GlowAnimationHandler, ShadowAnimationHandler, StrokeAnimationHandler and PhaseAnimationHandler are gone; no migration converts them, so a UniTextAnimationBridge listing one loses that entry on load and must be pointed at ModifierFieldsAnimationHandler, which covers the fields of every modifier in the component's Styles.
• Removed
  IHasModifierProperties and the per-modifier …Property descriptors: the interface a modifier implemented to expose animatable properties is gone, together with RevealModifier.FillProperty, RevealModifier.VisibleClustersProperty, HighlightModifier.TintProperty, PaintLayerModifier.TintProperty and StrokeModifier.WidthProperty — a modifier's parameters are reached through its generated Param class and ParameterDescriptor.Find instead.
• Removed
  LetterSpacingModifier.Monospace: the monospace flag on letter spacing is gone in favour of CharacterWidthModifier; existing assets are converted automatically into a Character Width entry of measured width covering the same text, while markup that switched it on through the letter-spacing tag's second token has to be re-authored as <cwidth=auto>.
• Removed
  Layout-invalidation warning on animated parameters: the text, Style Preset and Modifier Graph Preset inspectors and the Range Debugger no longer warn when an animated parameter of a custom modifier invalidates text or layout.
• Removed
  Glyph-compression inspector warning: the Auto Size section no longer shows a warning when a GlyphScaleFitStep limit exceeds 3%; the field tooltip still names the distortion threshold.

• Fixed
  World text rendered nothing in a build with Include Lit Shaders off: turning the setting off left every UniTextWorld throwing at render time in a player, whether or not it was Lit, while the editor kept working.
• Fixed
  UniTextSystemFont produced no text on iOS: in an iOS player a UniTextSystemFont resolved to nothing whatever family its iOS or Common tab selected, warning that no usable font was found and leaving every text that used the asset unrendered.
• Fixed
  Operating-system font lookup failed in the macOS and Linux editors under a foreign build target: switching the active build target to Windows Standalone on a macOS or Linux editor — or to macOS on a Linux editor — made every operating-system font lookup fail with a missing-native-plugin error instead of using the host machine's fonts, so characters absent from the assigned font stopped falling back until the build target was switched back.
• Fixed
  Linux DejaVu selections rendered in another family: on Debian- and Ubuntu-based systems, choosing DejaVu Sans, DejaVu Serif or DejaVu Sans Mono — including through the Common tab's logical families, which map to them on Linux — rendered in a different family with a console warning even though the fonts were installed.
• Fixed
  Paint layers ignored per-glyph scaling: on glyphs scaled by SizeModifier, small caps, sub/superscript or ruby, pixel-sized layer geometry — stroke width, shadow offset and blur, glow radius, fill dilate and softness — grew or shrank with the glyph instead of holding the requested pixel size, and a texture paint's offset and outward growth did not follow the glyph at all, so its shadow fell short and a wide stroke or glow was clipped.
• Fixed
  ExtrudeModifier Fixed Pixel Size drifted on scaled glyphs: with Fixed Pixel Size on, the extrusion's offset, dilate and softness grew or shrank together with any glyph the text had already scaled — superscript and subscript, small caps, SizeModifier, ruby — instead of holding the authored on-screen size.
• Fixed
  FontModifier ignored its configured family: a whole-text Font style, or a bare tag carrying no family name, left the range in the base font — the family set on the modifier applied only when it was also spelled out inside the tag.
• Fixed
  LanguageModifier ignored its configured language tag: a whole-text Language style, or a bare tag, activated no region-specific glyph variants — the BCP 47 tag set on the modifier took effect only when repeated inside the tag.
• Fixed
  Reveal effect kept playing on replaced text: changing the text or moving a revealed range while an appearance effect was still running left that effect playing at the same positions in the new text, so already-settled glyphs briefly faded, dropped or scaled in for no reason.
• Fixed
  Reveal effects stalled in the editor: in edit mode a reveal effect only advanced while that reveal modifier's own section was on screen in the Inspector, so a reveal driven from anywhere else — an animation preview, an [ExecuteAlways] script — could leave glyphs frozen part-way through their effect.
• Fixed
  Fit steps dead without Word Wrap: with Word Wrap off, Auto Size ignored the FitSteps ladder entirely — the font just shrank with no letter-spacing or glyph-width compression, and no compression ever appeared while narrowing the box.
• Fixed
  MeasureText reported an oversized width under Auto Size fit steps: with Auto Size on and FitSteps configured, MeasureText returned a width wider than the text actually draws, because the letter-spacing and glyph-width compression the fit had already chosen was missing from the measurement.
• Fixed
  Parameter dropdown showed a value the field did not hold: a parameter or default-parameter dropdown whose stored token was not among its options — a paint or catalog entry that had since been renamed or removed — displayed the first option instead of the value actually stored.
• Fixed
  Parameter dropdown ignored changes to its catalog: a parameter dropdown whose option catalog was empty when the inspector drew it stayed a plain text box after entries were added to the catalog.
• Fixed
  Unit selector named the wrong unit: a unit-valued parameter whose modifier names its absolute unit abs — VariationModifier's weight, width, slant, italic and optical size — showed px in the unit selector, and the token written for it spelled px too.
• Fixed
  Scene visibility overlay drawn without its icon: UniText's Scene-view visibility overlay showed no icon in the Scene view's overlay menu when UniText was installed as a package.

• Added
  Auto Size fit steps (FitSteps list next to Auto Size): budgets Auto Size spends, in list order, before it starts reducing the font size — and only as far as each actually buys font size back:

  • TrackingFitStep: tightens letter spacing, up to a limit in em (default 0.02, the tightening iOS applies before truncating).
  • GlyphScaleFitStep: compresses glyph width, quads and advances together (default limit 2% — the hz/InDesign print norm; above ~3% letterforms visibly distort, and the inspector warns).
  • LineHeightFitStep: compresses line height down to a percentage of natural (default 90%).
• Added
  Justification spacing budgets (AlignmentModifier): justified paragraphs now distribute space the way print engines do — word spaces stretch up to WordSpacingMax before letter spacing (LetterSpacingMin/Max, % of em) and glyph scaling (GlyphScalingMin/Max) spend their budgets, with space beyond every budget still landing on word spaces; the defaults reproduce the previous appearance exactly.

• Changed
  Line height follows the text size on the line: every line-height mode now measures the line at the largest font size on it, so a line whose visible content is entirely scaled by SizeModifier shrinks or grows with it while a line that also carries unscaled text keeps its base height — previously only enlargement moved the line, and it opened more space than the scaled text needed.
• Changed
  Overflowing justified lines compress toward the margin: a justified line wider than its box (an unbreakable word, a long URL) now pulls word spaces in — down to WordSpacingMin, 80% by default — and, when letter-spacing or glyph-scaling budgets are configured, spends those too, instead of always sticking out past the edge.

• Fixed
  Font inspector status lines unreadable on the light editor skin: the font-data, compression and system-font resolution lines were drawn in dark-skin greens, blues and ambers that washed out against a light background.
• Fixed
  Clear actions unreadable on the light editor skin: the red marking "Clear Runtime Data" and the clipboard window's Clear as destructive was a dark-skin red.
• Fixed
  Negative paragraph spacing ignored: ParagraphSpacingModifier accepted a negative Before or After value and then silently discarded it, so paragraphs could only be pushed apart, never pulled closer together.
• Fixed
  Phantom WholeText entry in a style's source picker: the Source dropdown listed a second WholeText option beside the "Whole Text" default, and choosing it failed with a missing-constructor error instead of selecting anything — leaving Source unset remains the way to style the whole text.

• Added
  UniTextWorld.Standalone: draws the text through a renderer of its own instead of merging into the shared batch mesh, so it takes its own depth-sorting position and sprites, Entities Graphics instances and other transparent renderers can sort between it and neighbouring world texts — at the cost of one draw call.

• Changed
  World range decorations draw with their text: highlights, selections and other range decorations on UniTextWorld are now part of that text's own mesh instead of adding a renderer of their own, and they follow it when Standalone is on.

• Fixed
  Range decorations on world text covering their neighbours: a highlight or selection on one UniTextWorld was drawn over — or under — every other world text sharing its sorting order instead of only its own.
• Fixed
  Range decorations left on screen by Hide: hiding a UniTextWorld kept its highlights and selection visible.
• Fixed
  SortingGroup ignored when added to live world text: a SortingGroup added, removed or disabled after a UniTextWorld had become active never took effect — the only way to make one apply was to add it before the object entered the hierarchy — and a disabled group won over an enabled one higher up.
• Fixed
  Per-glyph fades ignored under a gradient fill: a typewriter reveal or a per-character alpha ramp had no effect on text painted by a gradient FillModifier — the whole range stayed fully opaque, while the same text under a solid fill faded correctly.
• Fixed
  SpoilerModifier cover showed the text through it: the concealing cover was drawn at 96% opacity, leaving the hidden words faintly legible underneath.
• Fixed
  HighlightModifier block geometry covering neighbouring words: with GeometryMapping.Block, a highlight whose wrapped lines did not overlap horizontally stretched itself across words outside the range in order to join them into one shape, and the further apart the lines were — or the larger the CornerRadius — the more of the neighbouring text it swallowed. Such lines are now drawn as separate surfaces, each covering only its own range, with the paint still mapped across the range as a whole.
• Fixed
  Android: system Back did nothing while a text field was focused: the keyboard-dismiss button — the ∨ that replaces Back in the navigation bar while the keyboard is up — left the keyboard open, and the app's own back navigation never received the key either; builds with Unity's Predictive Back Support enabled, and Android 13 and 14, were unaffected.

Two packages: UniText + LightSide.Core

• Added
  New media.lightside.core package ("LightSide Core", v1.0.0, Unity 2022.3+, MIT / free). UniText's non-text foundation now lives in a standalone package — object pooling (ArrayPool), the worker-thread pool (WorkerPool, MainThread), math/hashing (XxHash64, HashNoise), collections (FastIntDictionary, SpanIntern), named catalogs (INamedCatalog/AssetNamedCatalog/InlineNamedCatalog), color/gradient parsing (ColorParsing, Gradient), the Cat logging system, the touch-gesture recognizer, a full custom-inspector toolkit, and the byte-preserving asset-migration framework (IMigration, IMigratedPackage, RenameManagedType/MoveFieldsToStruct, per-package ledger) — the machinery behind UniText's automatic v2→3 upgrades, open to any package on Core. Assemblies LightSide.Core / LightSide.Core.Editor, root namespace LightSide.
• Added
  Open-core boundary. The shared foundation is MIT and free; UniText's text engine stays the commercial package. The two version independently, and UniText 3.0.0 takes a hard dependency on media.lightside.core 1.0.0, resolved automatically through the media.lightside scoped registry — one install pulls both.
• Added
  Source-compatible split (two renames). Every moved type kept its namespace LightSide, so existing using LightSide; code still resolves. Two utilities were renamed in the move — UniTextArrayPool<T> → ArrayPool<T> and RangeEx.WholeText/IsWholeText → RangeEx.All/IsAll, no aliases — everything else compiles unchanged.
• Added
  Reusable inspector toolkit in Core. The [SerializeReference] type picker (Selector, TypeSelectorDrawer, ManagedReferenceTypeMenu), reorderable styled lists (StyledListUtility, ListReorder), and section/vector/padding widgets that power UniText's inspectors are now a Core editor toolkit any project can drop into its own editors.
• Added
  GPU glyph-upload promoted to Core. The regional texture-upload backend (native plugin renamed unitext_gpu → lightside_gpu) became a public GpuUpload API in LightSide.Core/Runtime/Gpu, rebuilt around a device-epoch/device-reset-aware pool with a synchronous WebGL2 bridge — shared infrastructure across LightSide packages.
• Added
  Built-in profiler (advanced/developer tooling). Core ships Prof — a lock-free per-thread Enter/Exit sink that reconstructs the call tree with self-time and per-method allocation — driven by ProfWeaver, a Unity ILPostProcessor (Mono.Cecil) that auto-wraps method bodies, inert unless PROF_ENABLE is set and the assembly is allowlisted (Window > LightSide > Profiler Weaver → ProjectSettings/ProfWeaver.txt). ProfSampler adds a zero-per-call statistical backend for IL2CPP players (a native plugin walks the real stack into a lock-free ring), and development-build captures stream to the editor over the player connection into Window > LightSide > Profiler.
• Added
  One LightSide editor menu. Shared tools consolidated under Tools/LightSide/ — the Noise Generator moved there from Tools/UniText/, joined by a new Log Zones window (live on/off panel for the Cat logging system's zones).

Selectable & editable text components

• Added
  UniTextSelectable: read-only text selection for both Canvas (uGUI) and world-space text. Click to place a caret, double-click to select a word (a drag continuing from it extends by whole words), triple-click a paragraph, drag to select, Shift to extend, right-click/long-press to select-word-and-open-menu, keyboard Copy and Select-All while focused. Public mutators (SetCaret, SetSelection, ExtendSelection, SelectWord/SelectLine/SelectParagraph, SelectAll, ClearSelection, DragSelectionHandle, each returning bool) plus GetSelectedText and gesture drivers (HandlePrimaryClick, DispatchTap/DispatchDoubleTap/DispatchTripleTap, BeginDrag/UpdateDrag/EndDrag). Single-selection-per-document with EventSystem-driven defocus.
• Added
  UniTextEditable: editable text — a sibling of UniTextSelectable on the same GameObject. Implements ITextDocument and ISavedStateProvider. It tracks the text size through the text component's ILayoutElement — add a ContentSizeFitter or place it under a layout group. Field chrome (background, viewport, scrolling, placeholder, labels) is assembled from standard Unity layout components plus field decorators, not a fixed component. Content typing is composed from input behaviors/filters/validators, not a content-type enum. All OS input is delivered independently of Unity's input system.
• Added
  Zero-alloc text access: CharCount/CodepointCount, CopyTextTo(Span<char>), TextEquals(ReadOnlySpan<char>), with surrogate-pair-safe codepoint indexing — poll and compare a field every frame without touching the GC (the Text getter is the opt-in allocating path).

Text selection model & BiDi

• Added
  TextSelection (readonly struct): Anchor/Focus/Affinity over codepoint indices, with IsCollapsed, Start/End/Length, Clamp, a Caret(index, affinity) factory, and full value equality. Direction is implicit in anchor/focus ordering, modeled on the W3C Selection API / Flutter TextSelection.
• Added
  CaretAffinity (Downstream/Upstream): one unified hint that disambiguates caret rendering at both soft-wrap line breaks and LTR↔RTL BiDi run boundaries.
• Added
  BiDi-aware hit-testing (SelectionHitTest, UniTextBase.HitTestCaret/IsOverText): edge-snapped caret placement (left half of a glyph → cluster N, right half → N+1), closest-edge resolution with swapped left/right semantics inside RTL runs, grapheme-cluster snapping, and a web line-box "over text" model for the I-beam affordance. Line resolution binary-searches a per-line advance prefix and the within-line scan touches only that line's glyphs — a click costs O(log lines + line), never the document.
• Added
  Word/line/paragraph boundaries: UAX #29-aware word segmentation with VS Code / Windows / macOS Ctrl/Option+Arrow semantics — apostrophes in words (don't, and the curly don’t), digit separators (3.14, 1,000), Katakana as its own script run, Han ideographs and Hiragana broken per cluster, Thai/Lao/Khmer/Myanmar snapped to dictionary word boundaries (Thai dictionary in the box; register others via UniTextSettings.Dictionaries), emoji/ZWJ/variation-selector clusters never split.
• Added
  Selection events: SelectionChanging (vetoable — Cancel or reassign Proposed to clamp a proposed change out of an atomic pill or read-only region), SelectionChanged (with a reason), and a 14-value SelectionChangeReason open-string vocabulary (select.pointer, select.word, select.extend, select.clamp, …) matching the CodeMirror 6 convention.

Caret navigation & rendering

• Added
  Grapheme-cluster caret movement: one arrow press or one Backspace crosses a whole emoji, ZWJ sequence, or base+combining-mark cluster — caret positions always sit on grapheme boundaries.
• Added
  Vertical movement with a preserved column anchor: Up/Down/PageUp/PageDown keep a desired-X column across consecutive vertical moves, reset on any horizontal/word/edit/click.
• Added
  RTL-base-aware horizontal movement: in an RTL line, Left/Right step toward logical start/end (Android getParagraphDirection convention); word movement obeys the same flip. The empty last line after a trailing newline follows the preceding paragraph's direction, matching mainstream editors.
• Added
  InputCaretRenderer: the caret component — a RectMask2D-clipped quad with blink-on-interval, blink-idle-timeout-then-steady, immediate geometry on type (no one-frame lag), and configurable width/color; subclass it (override OnPopulateMesh) for a block, underline, or gradient caret.

Editing & document model

• Added
  Edit operations on UniTextEditable: InsertText (string and ReadOnlySpan<char>), DeletePrevious/DeleteNext, DeleteSelection, DeleteWordPrevious/DeleteWordNext, DeleteToLineStart/DeleteToLineEnd, TransposeCharacters (carries adjacent formatting through the swap), SelectAll, Select, MoveCaretTo. Delete/transpose boundaries are computed over the document with a bounded UAX #29 window — never a stale previous-frame layout — so key-repeat and frame hitches can't delete the wrong cluster.
• Added
  Undo/redo: Undo/Redo/CanUndo/CanRedo/ClearUndoHistory, with word-aware token-class coalescing (the VS Code / CodeMirror 6 word↔separator rule, held-Backspace merged, Replace never coalesced), a configurable time window (UniText settings, default 0.5 s), and an allocation-free store — undo text lives in a shared char[] referenced by slices, capped by the settings' undo memory limit (default 1 MB, oldest-first eviction, the newest entry always survives; 0 = unlimited). Restores the pre-edit selection on undo; multi-step commands (styled typing, IME commit over a selection) group into one undo step.
• Added
  Programmatic set-text with explicit undo policy: SetText (replace, reset selection, clear history) vs SetTextProgrammatic(value, recordUndo = false, preserveHistory = false, reason = null) — preserveHistory:true rebases existing undo entries through the swap's minimal diff, so a collaborative/network echo that only appends keeps the user's local undo (CodeMirror addToHistory:false); reason tags the event (e.g. sync.network).
• Added
  ITextDocument: a read-only, codepoint-indexed document abstraction (CodepointCount, CharCount, Version, CopyCodepointRange, GetCodepointAt) that validators, find/replace, and accessibility consumers depend on instead of the concrete editor.
• Added
  EditApplied + EditShape: every mutation raises EditApplied(EditShape) synchronously (after Version advances, before the frame-coalesced TextChanged) carrying Start/Removed/Inserted/Delta/MapIndex — the zero-alloc damage hint for keeping indexed state (search results, CRDT positions, highlight ranges) in sync without rescanning.
• Added
  Change-reason vocabulary (TextChangeReason): open dotted-prefix strings carried by DocumentChanged — input.type, input.type.compose, input.paste, input.delete[.backward|.forward], input.cut, input.format, input.restore (input.* is exclusively user input), program.set for programmatic mutation, sync.network for collaborative sync, and edit.style for formatting-command tag rewrites — so integrators react differently to typing vs paste vs programmatic vs IME edits with one prefix check.
• Added
  Events: TextChanged (zero-alloc), ValueChanged, DocumentChanged (with reason), SelectionChanged (frame-coalesced), Submitted, Cancelled, Focused/Defocused, CompositionStateChanged, TouchKeyboardVisibilityChanged, ValidationChanged.
• Added
  ISavedStateProvider: SaveState/RestoreState persist text, selection, affinity, and scroll into a unitext.*-prefixed bundle for host-driven view recreation (virtualized lists, mobile process-death restore, Web bfcache).
• Added
  Input sanitization: lone surrogates and C0/DEL control chars dropped, \r\n collapsed to \n, NUL rejected, with a 1,000,000-char paste safety cap — the field is safe to point at arbitrary pasted data.
• Added
  GraphemeCountCache: grapheme-cluster count cached by document Version, predicting a pending edit by re-segmenting only a boundary-safe window — live counters and grapheme length limits stay O(window) per keystroke instead of a full rescan.

Keyboard input & edit actions

• Added
  EditAction enum: the full editing action set — movement (char/word/line/page/document), selection variants of each, delete (prev/next/word/line), TransposeChars, InsertNewline/InsertTab, Copy/Cut/Paste/PasteAsPlain, Undo/Redo, Submit/Cancel — plus Ignore (consume a key and block its platform default) and range constants for permission filtering.
• Added
  Platform-aware key resolution (PlatformKeySemantics + a built-in key map): macOS (Cmd shortcuts, Option word-nav, Cmd+←/→ line, Cmd+↑/↓ document, plus default Emacs bindings Ctrl+A/E/F/B/P/N/K/T/D/H) vs Windows/Linux (Ctrl shortcuts, Ctrl+Y redo, Ctrl+Home/End, Shift+Insert/Ctrl+Insert/Shift+Delete, AltGr-safe Ctrl+Alt), with Cmd-vs-Ctrl resolved at runtime (a macOS-browser WebGL build and an iPad hardware keyboard get Cmd). Read-only mode runs only navigation/selection/Copy/Submit/Cancel; mutating actions are suppressed during IME composition.

IME & composition

• Added
  Non-destructive composition: in-progress IME text renders without being written to the document until the IME commits, and the commit lands as a single undo entry. CJK candidate windows, dead keys (´+e→é), and accent menus work correctly; composition renders unmasked in password fields. The overlay commits synchronously on defocus/SetText so text is never lost when the user taps away or switches apps, and late echoes from a killed session are discarded.
• Added
  Clause model (CompositionData, CompositionClauseStyle): per-clause attributes (macOS/iOS NSMarkedClauseSegment runs, Android composing spans) are normalized into one neutral clause vocabulary — Unconverted / TargetConverted / Converted / TargetNotConverted / Error, the Windows IMM ATTR_* taxonomy — so integrators reason about conversion state without per-platform code; a platform that delivers no clause detail reports one Unconverted clause.
• Added
  Candidate-window placement: the caret position is reported in native client space (UniTextNativeInput.SetCursorScreenPos, Editor Game-View letterbox-compensated), and SetImeCaretScreenRect pins the window for inline Scene-view editing — so the candidate/emoji/accent window sits on the caret in a build, the Editor Game View, and the Scene View.
• Added
  Text-input-context queries answered from UniText's own layout: TryGetCharRangeRect (first-rect-for-range), HitTestChar (closest position to point), WritingDirection (per-codepoint UAX #9 levels), and a grapheme/word TokenizerQuery — feeding macOS NSTextInputClient, iOS UITextInput, dictation, VoiceOver character/word reading, and candidate placement from real shaped glyphs, not an approximation.
• Added
  ITextInputContext: the neutral document-context seam the native backends query. UniTextEditable installs itself while active; a console, terminal, or custom text host installs its own context and receives full native IME. CompleteComposition/CancelComposition give hosts programmatic commit/discard; IME-driven caret moves (Gboard spacebar-swipe, InputConnection.setSelection) are applied as input.
• Added
  Android IME context mirror: the focused document and selection are mirrored into the platform InputConnection — the whole text when ≤ 1,024 UTF-16 chars, else a ~512-char window centered on the selection and snapped to grapheme boundaries, coalesced to one push per frame and cached by document version — so Gboard suggestions, autocorrect, and spacebar cursor control see real surrounding context with zero per-keystroke allocation; pull-model platforms (Windows, macOS, iOS) skip the push entirely.

Native input & soft keyboard

• Added
  UniTextNativeInput: delivers OS key, text, composition, selection, and keyboard-visibility events independently of Unity's input system (no Event.PopEvent), so editing works regardless of the project's Active Input Handling (Legacy / New Input System / Both) — removing the single biggest friction point of every Unity input-field asset. Control keys arrive only via key-down; printable text only after the OS resolves layout/dead-keys/IME. Cross-platform NativeKeyCode and [Flags] NativeModifiers.
• Added
  Windows Text Services Framework text store: the new UniTextNativeInputWindows.dll (x86_64 + ARM64) hosts an ITextStoreACP document, so the Win11 emoji/GIF panel (Win+.), clipboard history (Win+V), and modern TSF IMEs insert into the field with the candidate window anchored at the caret — even under the New Input System.
• Added
  Pluggable input backends (INativeInputBackend, RegisterBackend): a priority-ranked registry with a ManagedInputBackend fallback registered on every platform, so a missing/failed native plugin (or an unsupported platform) still types, and studios can add first-class input for consoles/TVs without forking the package.
• Added
  NativeKeyboardConfig: soft-keyboard traits the OS reads on show — KeyboardType, ReturnKeyType, AutoCapitalization, AutoCorrection, SpellChecking, AutofillHint, iOS smart-quotes/dashes/insert-delete opt-out, KeyboardAppearance, return-key auto-dim, Done toolbar, password rules, AndroidImeFlags, and raw iOS keyboard/return-key overrides. Every option defaults to the user's OS preference. (iOS coverage is full; Android maps type/caps/correction/spell/return/ime-flags; WebGL maps inputmode/enterkeyhint/autocapitalize/autocorrect/spellcheck/autocomplete.)
• Added
  NativeFieldOverlayStyle / NativeFieldHandle: opt into the OS's own field (UITextField/UITextView, EditText, DOM <input>/<textarea>) for system selection handles, autofill chrome, voice input, and per-platform styling — the only route to true native UX inside a WebGL browser sandbox. NativeFieldHandle returns the raw native-view pointer for further customization (functional on iOS today).
• Added
  Keyboard-avoidance data (KeyboardEvent, KeyboardEventPhase, KeyboardEasing): will-show/animation-progress/did-show/will-hide/did-hide/will-change-frame phases with duration, easing, and a frame-synced animation fraction where the OS exposes it (Android API 30+), plus a documented client-side fallback (iOS, Android <30, WebGL).
• Added
  Soft-keyboard action button (NativeEditorAction): the keyboard's action key is delivered as an open vocabulary — Submit/Next/Previous/Newline, with Go/Search/Send/Done all delivering Submit — so a chat composer submits and a form field advances focus, degrading to a synthesized Return with no subscriber.
• Added
  Native plugins shipped and CI-built: Android UniTextInput.aar, macOS UniTextNativeInputMacOS.dylib (an NSTextInputClient view), Windows UniTextNativeInputWindows.dll (x64 + ARM64), iOS UniTextNativeInput.mm (a UITextInput view), and WebGL .jslib — full native IME and soft-keyboard support in the box, no external SDK.
• Added
  Automatic hardware cursor: an I-beam appears over text and a hand over links, from a 25-shape internal cursor table mapped to per-platform IDs (Windows OCR_*, macOS NSCursor, WebGL CSS cursor; Linux keeps the default arrow); an interactive range's hover cursor is configurable per modifier in the inspector (serialized hoverCursor, default: link hand).

Clipboard

• Added
  Multi-format, multi-channel clipboard: one Copy writes many formats atomically and Paste auto-selects the richest understood one — ClipboardFormat.PlainText, Html, Markdown, UniTextSource (lossless UniText vendor format), Url, and Png/Jpeg/Gif images. ClipboardItem pairs a MIME-string ClipboardFormat (with Custom(string) and TryDetectImage) with bytes; bypasses GUIUtility.systemCopyBuffer on the six supported platforms (a plain-text fallback covers anything else).
• Added
  Format adapters (IClipboardAdapter): per-format translators between UniText markup and external formats, ordered by Priority on paste (lossless UniText source 100, HTML 50, Markdown 40, plain text 0 — the richest present format wins). Four shipping stateless built-ins: UniTextSourceClipboardAdapter, TagHtmlClipboardAdapter, MarkdownClipboardAdapter, PlainTextClipboardAdapter.
• Added
  Data-driven modifier serialization schemas (ModifierClipboardSchema, ClipboardModifierBindMap): each modifier type declares how it maps to HTML (semantic element, CSS-on-<span>, or attribute) and Markdown (marker or link), registered per type with no assembly scan (IL2CPP-safe). Pre-registered for the 15 shipping modifiers (bold, italic, underline, strikethrough, color, size, font, link, language, line-height, letter-spacing, script position, small-caps, upper/lowercase). Register a custom modifier's mapping with one ClipboardModifierBindMap.Register<T> call — this is the per-modifier extension seam, not custom adapters.
• Added
  Word / Outlook / Google-Docs interop: the HTML paste parser is a single forward pass with an explicit element stack — it strips leaked <style>/<script> blocks, collapses whitespace the way CSS renders it, resolves entities, closes mis-nested tags, and honors the Windows CF_HTML fragment header — so pasted rich text comes in clean, not as a wall of CSS and blank lines. CSS unit bridging (CssValueFormat) converts px/pt/rem, unitless line-heights, and rgb()/rgba() colors into UniText's own units on paste and emits valid CSS units on copy — including Google-Docs font-weight conventions.
• Added
  Lossless UniText round-trip (ClipboardFormat.UniTextSource, application/vnd.lightside.unitext): a JSON fragment keyed by modifier signature re-resolves each span by modifier identity and re-emits it in the destination field's own syntax — copy between two of your fields and keep every style byte-perfect, even styles no HTML or Markdown could express.
• Added
  Style-safe partial copy: copying part of a styled run re-synthesizes the open or close tag the selection cut off, in the pair's original syntax — a half-selected <b> span (or *bold* marker run) copies as valid, still-styled markup instead of a dangling tag.
• Added
  Paste policies & commands: PlainTextPastePolicy (Auto/Literal/Parse), Paste(), PastePlain() (paste-and-match-style), Cut()/Copy(), async PasteAsync()/PastePlainAsync() (required for programmatic paste on WebGL), and PasteFromItems(IReadOnlyList<ClipboardItem>).
• Added
  Media clipboard (MediaContent, MediaSource, IMediaClipboardProvider, the MediaReceived hook): receive pasted images and files before the text channels run, and read their bytes per platform (CF_HDROP paths on desktop, content:// on Android, browser blob on web; large files off-thread) — paste a screenshot into a chat field and upload it.
• Added
  Windows screenshot & image interop: copies write the registered PNG format plus a synthesized CF_DIBV5, and reads convert CF_DIB/CF_DIBV5 back to PNG — so a copied image pastes into Paint/Word and a PrintScreen capture pastes straight into a field.
• Added
  Provider abstraction (UniTextClipboard facade, IClipboardProvider / IAsyncClipboardProvider): swap the backend for tests or a custom platform behind one interface; static GetText/SetText/GetTextAsync cover the plain-text fast path.
• Added
  Six native backends: Windows CF_HTML + registered formats + CF_DIBV5 + CF_HDROP; macOS NSPasteboard multi-format writes via the Obj-C runtime (no compiled plugin); iOS UIPasteboard items; Android newHtmlText + a bundled content:// image provider (no androidx dependency); WebGL Async Clipboard API + Web Custom Formats; Linux xclip/xsel/wl-copy — a real OS clipboard everywhere, not Unity's plain-text-only buffer.
• Added
  Hostile-input hardening (ClipboardBudget): every paste parser caps at 4 MB / nesting depth 64 / 1,000,000 chars and stays linear on degenerate input, so a malicious clipboard payload can't hang or OOM the app.

Rich-text formatting (editor)

• Added
  Apply/toggle styles over a selection, in the style's own markup syntax: ApplyStyle<T>, ApplyStyleRange<T>, SetStyle<T> (range on/off), ToggleStyle<T>, ToggleStyle(BaseModifier, …), RemoveStyleRange<T>, ClearFormatting, InsertObject<T>. Reference-only — a style the field has no configured rule for is a no-op; nothing is ever minted. Toggle-off splits runs so the style survives outside the range, with single-undo semantics.
• Added
  Pending typing styles (ProseMirror stored-marks model): at a collapsed caret a style command stores a pending style that wraps the next typed text; caret movement discards it, and ArrowKeyEscapesFormatting (off on a bare editable; TextFormattingBehavior turns it on) peels one formatted range at a time at its edge — the ProseMirror/Lexical mark-boundary model.
• Added
  Toolbar-state queries: IsStyleActive<T>(), TryGetStyleParameter<T>(out …) (false on a mixed selection), ModifiersAtCaret, and a frame-coalesced CaretContextChanged event delivering a CaretContext diffed by modifier signature — bind a formatting toolbar's pressed/color state without per-frame polling.
• Added
  MarkupVisibility — Hidden (tags hidden and atomic but preserved so styles round-trip), RevealActiveRange (reveal the markup of the span under the caret, like a code editor), Raw (literal source view). Caret, selection, hit-testing, and deletion stay correct while tags are hidden — deleting the last styled char removes the whole <b>…</b> pair in one undo step.
• Added
  TypingMarkupPolicy (Parse/Literal): markup the user types by hand is either recognized or escaped to literal text; affects only keystroke/IME input, not formatting commands or paste.
• Added
  ChromeRule + IMarkupSelector: style the visible tag delimiters when revealed (AnyMarkup / ByModifier / ByRule, by specificity), with tag characters protected from the surrounding document style; runtime-mutable via MarkupChrome + RefreshMarkup.
• Added
  Parse rules describe and re-emit their own syntax (ParseRule.Identity, SourceToken, MarkupTriggers/ScanTriggers, CanWrap, Apply, plus the literal-escape contract EscapePrefix/IsEscapable): this is the mechanism that lets one formatting command drive a tag rule (<b>) and a Markdown marker rule (*bold*) alike — the core "it is now an editor" story.
• Added
  Style identity by modifier signature: toggling Bold finds the field's own <b> style instead of minting one — styles are matched by concrete modifier type, a composite by its ordered child types ({Bold,Italic} distinct from {Italic,Bold}) — and composite styles round-trip losslessly through the clipboard.
• Added
  Multi-syntax binding (UniTextBase.EnsureStyleFor): one semantic modifier reacts to multiple input syntaxes (<i>, *…*, pasted <em>), merged into a CompositeParseRule on demand — no duplicate style entries.
• Added
  IFormatStyleSource / ReferencedStyle: the serialized seam a formatting command toggles — pick a modifier in the inspector and a toolbar button applies it in that style's own syntax, inert on fields that lack it.
• Added
  TriggerWordParseRule: built-in @mention / #hashtag auto-detection with a configurable trigger character, runs at negative priority so explicit markup wins.
• Added
  Link rules carry a default style: MarkdownLinkParseRule and RawUrlParseRule gained a DefaultParameter merged positionally behind the matched URL, so an auto-detected or [text](url) link applies a fixed visual preset (e.g. a Link;Color;Underline composite) configured on the rule.
• Added
  Markdown markers follow CommonMark flanking rules (MarkdownWrapRule): a marker opens only when left-flanking and closes only when right-flanking (CommonMark §6.2), and _-markers never toggle inside a word — 2 * 3 and snake_case_name stay literal. In 2.x every marker occurrence toggled.
• Added
  Per-style enable toggle (Style.Enabled, an eye button on each style row): disable a style non-destructively — skipped by the parser, rendering, and every style query while its configuration is preserved; re-enabling restores its authored precedence among overlapping styles.

Input Behavior system

• Added
  Composable, serialized, user-extensible behavior system (InputBehavior): drop-in policy units attached to a field as a [SerializeReference] type-picker list, authored like style modifiers — subclass the base, add serialized fields, override OnEnable/OnDisable to subscribe the editor's extension events. Teardown is fully reversible (an internal Saved<T> slot restores host state on disable).
• Added
  Documented transaction seam: the four hooks a behavior subscribes — InputFilter (InputEdit), KeyResolver (KeyResolve), KeyboardResolver (KeyboardRequest), MediaReceived (MediaContent). InputEdit carries the inserted text, target range, caret, and a TextChangeReason, with a sticky Rejected — so a whole-field mask can rewrite the entire transaction. Hooks run in order, each seeing the previous result, only on committed text (never IME composition, undo replay, or programmatic writes).
• Added
  Runtime hot-swap: AddBehavior, RemoveBehavior, GetBehavior<T>(), GetBehaviors<T>(List<T>) flip a field's policy live; shared presets attach via AddBehaviorPreset/RemoveBehaviorPreset.
• Added
  InputBehaviorPreset: a reusable ScriptableObject field archetype (chat composer, password field, form field). Each editor instantiates a runtime copy so per-instance state never leaks back to the asset; editing the preset asset raises Changed and rebuilds every live field using it in place.
• Added
  Built-in behaviors (15 concretes; KeyboardBehavior and MediaInputBehavior ship as ready-made bases for authoring keyboard-lifecycle and media-handling behaviors): PasswordBehavior (caret-aligned masking + secure entry + copy blocking + reveal toggle), SingleLineBehavior, LengthLimitBehavior (grapheme-counted, boundary-safe), CaseTransformBehavior (upper/lower/title), InputMaskBehavior (live (###) ###-####-style formatting, paste- and mid-field-edit aware, with RawText), SubmitKeyBehavior (Enter or Ctrl/Cmd+Enter), TabKeyBehavior, NativeKeyboardBehavior, NativeFieldOverlayBehavior, KeyboardAvoidanceBehavior (animated lift, canvas-scale and projection correct), TextFormattingBehavior, AutoValidateBehavior, LinkOnPasteBehavior, StripFormatOnPasteBehavior, CaretContextBehavior.
• Added
  TextFormattingBehavior: a field's whole formatting layer on one behavior — a configurable Commands list (default B/I/U via FormatCommand), a clear-formatting shortcut (Ctrl/Cmd+\ by default), Toggle(string)/Toggle(int) for toolbar buttons, and ownership of MarkupVisibility / RichPaste / paste policy / TypingMarkup / arrow-key escape / tag chrome while enabled.
• Added
  CaretContextBehavior + StyleStateHandler: wire a Bold button's highlight with zero code — an edge-triggered handler fires a UnityEvent<bool> only when "would typing now produce this style?" flips.

Input filters & validators

• Added
  InputFilterBase: a self-wiring behavior that rejects characters as typed by judging the whole post-edit span (surrogate/grapheme-safe, native-multi-char aware) and requests a preferred mobile keyboard. Built-ins: IntegerFilter, DecimalFilter, AlphanumericFilter (Unicode letters + ASCII digits), EmailFilter, NameFilter (letters + space/hyphen/apostrophe). Numeric filters expose AllowNegative, which both accepts a leading minus and switches the requested keyboard to one that has a minus key.
• Added
  InputValidatorBase + ValidationState: judge the whole value and publish an open-string status (ValidationStatus.Invalid/Pending; valid = empty status) + message, scheduled by AutoValidateBehavior (OnValueChanged/OnUnfocus/OnSubmit/Always) and wired straight into the field's error visuals. Async-capable (Pending).
• Added
  TextMeasure / TextLengthUnit: measure and boundary-safe-truncate text by Graphemes (default — a family emoji counts as one), Utf16Units, Utf8Bytes, or Codepoints; LengthLimit published to counters — never the wrong number string.Length gives.

Field decorators

• Added
  Decorator system (FieldDecorator): composable field chrome reacting to a pushed FieldState snapshot (IsEmpty, IsFocused, IsComposing, LengthLimit, Validation, Box) with attach/dispatch/tick/detach lifecycle; an idle decorator holds no per-frame subscription. Author your own via the type picker.
• Added
  Built-in decorators: PlaceholderDecorator, FloatingLabelDecorator (Material-style animated label with easing curve/duration, snapping instantly under Reduce Motion), SupportingTextDecorator (helper text that swaps to the validation error message/color), CharacterCounterDecorator (grapheme-aware count/count/limit, recolors at the limit, cached by document version).

Context menu

• Added
  UniTextContextMenu (ITextContextMenu): a data-driven, bring-your-own-UI context menu — you build and style the panel/buttons in the scene, the component wires controls to commands, hides inapplicable items, positions and clamps the panel on-screen with an edge-aware pivot, and dismisses on outside click via a generated full-screen blocker. Visibility runs through a CanvasGroup (never deactivating the GameObject) so a FocusGuard on the panel keeps the editor focused.
• Added
  Menu items (ContextMenuItem, BuiltInContextMenuItems): Cut/Copy/Paste/SelectAll plus custom ActionContextMenuItem (a Button → UnityEvent) and ToggleContextMenuItem, each with per-item applicability rules (onlyWithSelection on the custom items). Standard commands route through the last-shown presenter so one menu instance safely serves every field; custom items fire their own UnityEvent. Raised on right-click or long-press via UniTextSelectable.RequestContextMenu, or subscribe ContextMenuRequested/ContextMenuDismissRequested for a fully custom or OS-native menu (capability-gated — no copy from a password field).

Touch & mobile interaction

• Added
  Gesture recognition (TouchGestureRecognizer, a public state machine now in LightSide.Core): platform-standard single/double/triple tap, long-press, and drag — disambiguating drag-to-select from swipe-to-scroll by tap count, with no single-tap flicker under a double-tap — and time-scale independent. Thresholds are serialized on UniTextSettings, dp-based and DPI-aware: long-press 0.5 s, drag slop 10 dp, multi-tap window 0.3 s / slop 100 dp, desktop multi-click 0.5 s / 8 dp (matching Android DOUBLE_TAP_*, Flutter kDoubleTap*, Windows GetDoubleClickTime).
• Added
  Magnifier loupe (IMagnifier, shipped DefaultMagnifier): an iOS-style magnification bubble during long-press caret placement and handle dragging, rendered through a secondary camera into a render texture (Built-in RP via Camera.Render, URP/HDRP via SubmitRenderRequest on 2023.1+), with a documented graceful hide where capture isn't possible. Replaceable via the interface.
• Added
  Selection handles (ISelectionHandles + IInsertionHandle, shipped DefaultSelectionHandles): draggable teardrop start/end handles that extend the selection cluster-by-cluster — never collapsing, swapping roles past the fixed endpoint, showing the loupe during their drag — plus a caret knob that drags the collapsed caret and taps to reopen the menu, all rendered in a canvas-level overlay so the field mask never clips them. Replaceable via the interfaces.
• Added
  Replaceable touch UI: SelectionHandles, Magnifier, and ContextMenu are component slots on UniTextSelectable — assign the shipped defaults, your own custom-rendered components, or OS-native ones without subclassing; UniTextEditable only drives what's assigned.
• Added
  UniTextPasteControl: on iOS 16+ overlays a native UIPasteControl to bypass the system paste-permission prompt and capture plain/HTML/lossless-UniText in one tap; falls back to a Button → Paste() elsewhere, raising Pasted either way; display and corner styles (PasteControlDisplayMode/PasteControlCornerStyle) map to Apple's UIPasteControl configuration.

Pointer events

• Added
  TextPointerEvent: a consumable, reused (zero-alloc) pointer event on UniTextBase carrying the hit result, a PointerTrigger (PrimaryClick/SecondaryClick/LongPress/Hover), a PointerKind (Mouse/Touch/Pen, resolved authoritatively from the new Input System), screen position, camera, and live [Flags] PointerModifiers. Setting Consumed claims the click so a parent ScrollRect never sees it.
• Added
  New events on UniTextBase: ContextRequested (right-click or touch/pen long-press, mirrors HTML contextmenu/WinUI/SwiftUI), TextLongPressProgress (0→1 for loupe/ring feedback, mouse holds excluded), PointerPressed/Released, PointerEntered/Exited (topmost-raycast model — an occluding child correctly suppresses the hover). No per-frame cost when unsubscribed; Canvas and world-space text raise the same events.
• Added
  Drag-to-select events on UniTextSelectable (SelectionDragStarted/SelectionDragUpdated/SelectionDragEnded, anchored at the original press position) — kept off UniTextBase so a plain label never captures drags from an enclosing ScrollRect.

Highlight layers, find-in-page & interactive ranges

• Added
  UniTextHighlights: named highlight layers over any text component — the CSS Custom Highlight model (selection, find-in-page, hover feedback, custom range marks). One-liner entry: UniTextHighlights.GetOrAdd(text).GetOrCreate("find-results"); layers can also be authored in the inspector. All layers of one render side draw as a single mesh on both Canvas and world-space text; an idle component costs nothing per frame.
• Added
  HighlightLayer: codepoint ranges (Add/SetRange/SetRanges/Clear) painted as a merged union (overlaps never double-blend). Integer Priority with documented anchors (HighlightPriorities: Interactive −10, Custom 0, Selection 100, FindCurrent 200, Diagnostics 300), Order (behind/above text), Visible, animation-friendly Opacity (re-tints in place, no geometry rebuild), and edit-sticky ranges — Stickiness (GrowsAtEdges (Monaco), Shrinks, RemoveOnOverlap) maps ranges through every edit of a sibling UniTextEditable, tracked in document space and remapped under hidden markup (public MapThroughEdit lets an external document backend — a CRDT, a network host — drive the same mapping).
• Added
  HighlightStyle: the layer's presentation — Paint (an inline colour or a solid/gradient swatch from the paint catalog), Height (LineBox / Content / LineAdvance), padding, corner radius, merge threshold, and BoxBreak (Slice/Clone/Block — Block collapses a range to one rounded rect for the code-block look).
• Added
  Handle-based render backend (TextHighlightRenderer, HighlightGroup, HighlightRect): individually mutable rects with per-rect color, rounded corners, gradient paint, and a free CustomData (uv1) channel for authoring custom highlight shaders — yet a side's layers collapse into one draw call. Steady-state repaints mutate live rects in place, and a stale handle throws ObjectDisposedException instead of silently aliasing another rect.
• Added
  Find & read API on every text component: UniTextBase.FindAll(query, comparison, results) — allocation-free for queries up to 64 chars, codepoint-correct, case-sensitive or -insensitive per the passed StringComparison (bundled Unicode simple case mappings; culture values compare ordinally), returning ranges that feed highlight layers and GetRangeBounds directly — plus the CodepointCount/RenderedCodepoints read surface.
• Added
  Interactive ranges are now configuration, not a subclass: InteractiveModifier is a concrete, inspector-pickable modifier (new InteractiveModifier { RangeType = "mention" }) running a per-range Normal/Hovered/Pressed state machine, consuming pointer events, and exposing six events (RangeStateChanged, RangeClicked, RangeContextRequested, RangeEntered, RangeExited, RangeLongPressProgress) plus GetRangeState and a protected IsRangeEnabled override to disable ranges dynamically (visited links, permission gates) — the web LVHA / UIKit UITextItem / Android ClickableSpan model with no registry.
• Added
  Range stylers (RangeStyler): the presentation seam assigned to InteractiveModifier.Styler — state transitions, activation flashes, and long-press progress arrive as hooks, typically drawn through highlight layers; idle stylers hold no per-frame subscription. StateHighlightStyler is the shipped default: animated hover tint, instant pressed fill, activation flash, optional long-press buildup — all Opacity fades, no geometry rebuild — plus a NormalEnabled persistent chip layer under the state layers (the Material state-layer model: a mention chip is one InteractiveModifier with this on, rebuilt at parse rate, never per frame).
• Added
  Built-in interactive modifiers: the new SpoilerModifier (Discord/Telegram tap-to-reveal covers — RevealChanged, SetRevealed/ConcealAll/IsRevealed, per-range reveal reconciled across re-parses, animated covers via the shipped SpoilerCoverStyler) and LinkModifier rebuilt on the state machine: base colour/underline styling moved out to composition, an iOS-style grey pressed flash via its default StateHighlightStyler (its 2.x LinkClicked/LinkEntered/LinkExited events and AutoOpenUrl — on by default — carry over) — both worked examples for authoring your own stateful interactive text.
• Added
  Selection style: UniTextSelectable.SelectionStyle (a HighlightStyle) drives the reserved "selection" layer at HighlightPriorities.Selection — recolor, round, or gradient-fill the selection bar from one serialized field.

Text effects & paint

• Added
  One paint system for every layer (UniTextPaints catalog, PaintSwatch, IPaintProvider): a named swatch is a solid color, a Gradient, or a Texture2D, referenced straight from markup (<fill=ember>, <stroke=gold>) or configured on a modifier. The same paint drives fills, strokes, shadows, glows, and underlines.
• Added
  Texture-filled text: any layer can be painted with an image — chrome, marble, foil, animated sheets — with PaintFit (Stretch/Contain/Cover/Tile).
• Added
  Gradients rebuilt per-pixel: 2.x evaluated a gradient at the four corners of each glyph quad; gradients now sample a shared ramp atlas per fragment, so radial and conic shapes stay correct inside every glyph. New PaintMapping frames (Block across the text, Line per line, Glyph per glyph, Range across the styled span) plus scale/offset join the 2.x Linear/Radial/Angular shapes and angle.
• Added
  FillModifier: fills the glyph interior with a paint; the first fill claims the suppressed base quad (no extra geometry), additional fills stack above it.
• Added
  StrokeModifier (replaces the old outline blob): a true rim band with continuous Align (−1 inside → 0 centered → +1 outside; legacy inside/center/outside keywords still parse), Width, Softness, and a CornerStyle (artifact-free Round, or Sharp mitered up to MiterLimit — shared by the layer base, so shadows and glows get the same corner treatment) — from an MTSDF two-distance read, works with the fill off, and takes any paint.
• Added
  GlowModifier (paintable soft halo, Radius), ShadowModifier rebuilt with independent Offset/Blur/Spread and any paint (a real blurred/spread/gradient shadow, not a hard offset copy), and InnerShadowModifier (inset shadow via a second SDF tap — embossed/letterpress depth, crisp at any size).
• Added
  Paintable decorations (BaseLineModifier): underline & strikethrough gained per-range paint (color/gradient/texture, defaulting to the text fill like CSS text-decoration-color: currentColor), and the 2.x line-style set (solid/double/dotted/dashed/wavy, thickness, offset, skip-ink) gained serialized defaults and public properties (Style, Thickness, Offset, SkipInk) — CSS Text Decoration Level 4.
• Added
  GlyphResolutionModifier: raises the atlas tile resolution of the glyphs in its range (ResolutionBoost 0–2) for crisp large headings without bumping the whole font's atlas.
• Added
  UnitValue / UnitVector2: the px/em/%/delta parameter grammar became a serialized value+unit type — an inspector default now carries its unit, and every effect geometry parameter (stroke width, glow radius, shadow offset/blur/spread) takes px or em: pin to px for constant on-screen size, or em to scale with the glyph.
• Added
  Serialized defaults + public property + per-range override on every modifier: a bare tag (<b>, <glow>, <color>) takes the inspector-configured default; an inline value overrides it — and each parameter is now a real C# property (ColorModifier.Color, BoldModifier.Weight/Mode, SizeModifier.Size).
• Added
  PaintLayerModifier extension point: fill/stroke/shadow/glow/inner-shadow all derive from one layer that resolves the paint, precomputes gradient/texture mapping per range, and stamps coverage quads — a custom effect gets swatch resolution and the full override chain for free, and a layer's overlapping ranges (nested tags) resolve innermost-wins once per codepoint (O(1) per glyph, not per glyph×range).

Kinetic text animation

• Added
  Phase-driven model (IPhaseDriven): a modifier's visual state is a pure function of its Phase and never advances itself — drive it from the drop-in UniTextPhaseDriver (free-running Speed, optional UnscaledTime, scrubbable Phase), a tween, Timeline, an Animator (PhaseAnimationHandler), or code. The same phase always renders the same frame, so scrubbing, rewinding, and multi-instance sync all work.
• Added
  Eleven built-in glyph animations (up from one wobble in 2.x), each configurable per range and most staggered along the text by a per-cluster Spread: WaveModifier, BounceModifier, PulseModifier, ShakeModifier, WobbleModifier, SpinModifier, PendulumModifier, FloatModifier, plus three effects that normally need custom shaders — GlitchModifier (RGB-split bursts), ScrambleModifier (hacker-style decode, grapheme-correct, no reflow), and RollingModifier (odometer / split-flap wheels — drive Roll toward 0 to settle).
• Added
  Per-glyph reveal animation (RevealModifier.GlyphRevealing): the 2.8 typewriter modifier gains a mesh-build hook — each rendered glyph of a revealing range arrives as a RevealGlyphInfo (ordinal, count, front, fractional Progress), so fade/scale/drop-in appearance is a few lines of quad mutation; while subscribed, the frontier cluster renders at fractional progress instead of popping in whole.
• Added
  Author your own (GlyphParamModifier<TParams> + the static GlyphQuad helpers): a phase-driven per-character effect in ~50 lines, riding the same driver/scrub/Timeline machinery as the built-ins; OnGlyph runs allocation-free during mesh generation, worker-thread-safe.

Custom shader effects

• Added
  Write once, run everywhere: author a single half4 UniTextEffect(UniTextFrag i) holding only visual logic and the template shells wire it into every pass — Canvas + world-space, Built-in + URP, SDF/MSDF/emoji. The UniTextFrag struct exposes sdfAlpha/signedDist/glyphUV/tileId/tileHash/userA/userB/positionWS, plus an optional vertex hook and a world shadow-caster program. Custom effects on world text — Built-in or URP — did not exist in 2.x.
• Added
  New authoring templates: every bundled effect (Rainbow, Dissolve, Hologram) now ships as a Canvas shell and a world/URP shell over a reusable logic include, plus a blank UniText_Effect-Example.hlsl starting point; shared building blocks live in UniText_EffectLib.hlsl.
• Added
  One-click scaffolding (Assets > Create > UniText > Custom Effect, renamed from Custom Material Shader): one click writes the full trio into the selected folder — the pipeline-neutral effect include plus pre-wired Canvas and World shader shells, include paths resolved and a unique shader name stamped in — so a new effect compiles for every pass the moment it lands.

Performance — glyph rasterization, rebuilt

• Added
  Cold-glyph rasterization now costs the main thread almost nothing. The async GPU rasterizer (shipped in 2.10.0) is rebuilt end-to-end — Burst outline extraction and contour union, CPU-precomputed 2D binning, per-font batching — leaving the main thread only a short dispatch while the GPU fills the atlas asynchronously.

  • Measured (Galaxy S21 FE 5G, Adreno 660, Vulkan, IL2CPP release build), cold-atlas fill of a 3,029-glyph multilingual NotoSans corpus (TextMeshPro/UI Toolkit filled 3,091/3,092): UniText ≈ 33 ms of main-thread dispatch vs TextMeshPro 8,635 ms and UI Toolkit 6,446 ms of synchronous main-thread work — a 263× / 196× reduction in main-thread cost (per-glyph: 10.8 µs vs 2,793.6 / 2,084.8 µs). The atlas finishes filling ≈ 2.1 s later without ever blocking a frame. A decorative 609-glyph RubikStorm fill: 96 ms vs 2,025 ms (TMP) / 826 ms (UI Toolkit).
• Added
  Binned GPU rasterizer (UniTextGlyphRaster.compute + GpuRasterPrep): CPU-precomputed 2D binning — 16 row-bands and a 16×16 control-hull cell grid — so each GPU texel evaluates only the local candidate segments instead of the glyph's whole outline. Heavy fonts (CJK, decorative, complex Arabic) rasterize far faster than v2's single 1D scan.
• Added
  Burst contour resolution (ContourUnionBurst): a new zero-allocation [BurstCompile] stage on raw pointers resolves self-intersecting and stroked outlines up front; cleanly-resolved glyphs are tagged so the SDF/MSDF sampler skips the per-pixel silhouette heuristic 2.x ran for every glyph.
• Added
  Parallel CPU rasterization (GlyphBatchRasterizer + per-font worker fan-out): a frame's glyph requests batch per font; fonts render concurrently, and within one font outline extraction and Burst SDF generation spread across every core — ≈ 9.7× over single-threaded on a 12-core desktop (3,029 NotoSans glyphs: 220 ms vs 2,138 ms; Editor measurement of the CPU-raster path). Platforms without compute support (WebGL) take this path automatically.
• Added
  GPU raster robustness: GraphicsFence-tracked completion polled at frame granularity, a submission-cost budget (250 ms mobile / 500 ms desktop), and a DeviceResetSentinel that re-arms the atlas after a graphics-device loss or scene-reload — text survives alt-tab/driver resets without corruption.
• Added
  Atlas growth tapers: past 16 slices the glyph atlas grows +25 % per step instead of doubling, and pre-allocation discounts reusable page area — large multilingual atlases stop overshooting their memory footprint, and a double-allocation crash risk on the CPU-raster path with very large glyph sets is gone.

Performance — Unicode analysis, shaping & incremental rebuilds

• Added
  Burst-compiled analysis with a byte-identical fallback: the four Unicode analysis passes — UAX #9 BiDi, #24 script, #29 grapheme, #14 line-break — each run as a single [BurstCompile], auto-vectorized kernel exposed as a FunctionPointer, with the exact same source available as managed IL where Burst is unavailable. Output is bit-for-bit identical either way (integer-only logic) — speed with zero behavioral risk. (These are Burst auto-vectorized kernels, not hand-written SIMD intrinsics.)
• Added
  Per-paragraph, parallel, cached analysis: because the kernels are FunctionPointers (not Unity IJobs) they run on the WorkerPool threads; analysis is paragraph-scoped, and a content-addressed ParagraphAnalysisCache (XxHash64) reuses resolved levels/scripts/line-break and grapheme boundaries so editing one line never re-analyzes the document. In 2.x each document was analyzed whole, on one thread, uncached.
• Added
  Unchanged paragraphs are never re-shaped (ParagraphShapeCache): each paragraph is fingerprinted over its codepoints plus everything that feeds shaping (font size, per-range font/language data, hidden markup), and a hit replays the stored pristine HarfBuzz runs and glyphs — the Blink shape-cache model. Typing re-shapes only the edited paragraph. Android release build, 100 multilingual objects: an incremental edit rebuilds in 43 ms vs 69 ms for the all-new cold path.
• Added
  Cross-document word-shape cache (WordShapeCache): shaped words are reused across every text on the engine (XxHash64-keyed by codepoints, font, variation axes, script, direction, language) — changing labels, counters, and chat logs that share vocabulary splice stored glyphs with no HarfBuzz call at all. Only words HarfBuzz marks safe-to-break on both boundaries are cached — the exact per-font condition under which the isolated word shapes identically to its in-context form — and entries hold font-unit glyphs, so they survive font-size changes; a miss shapes the whole run in context, byte-identical to the uncached path.
• Added
  One document parallelizes too: the parallel pipeline (on by default since 2.x) fanned out per component; analysis, shaping, and layout are now paragraph-scoped, so one large text also spreads its bidi/script/break/shaping work across every core — per-paragraph shape jobs from every dirty component flatten into a single worker-pool run. Release build (Galaxy S21 FE 5G, Vulkan, IL2CPP), cold rebuild of 100 multilingual objects: UniText 69 ms vs UI Toolkit 167 ms — both HarfBuzz-shaped, like-for-like — and TextMeshPro 455 ms (TMP does not shape Arabic/bidi; its output is not equivalent). Editor, 12-core Ryzen 9 5900X: 92 ms parallel vs 351 ms single-threaded (≈ 3.8×).
• Added
  Viewport-windowed rendering (UniTextBase.VisibleWindow): a local-space window bounds mesh emission — paragraphs fully outside it produce no quads, while layout, selection, caret, and hit-testing stay whole-document. Canvas text feeds it automatically from the enclosing RectMask2D clip rect, so a long editable document or ScrollRect only meshes the visible band (a half-window hysteresis margin makes small scrolls free); set it explicitly for custom virtualized scrollers (chat, logs) — null renders everything.
• Added
  Pure-LTR BiDi fast path: all-LTR text (Latin, Cyrillic, CJK — the common case) short-circuits the full X1–L1 bidirectional cascade after one classification scan, a fast path 2.x had no equivalent of.
• Added
  Native-memory Unicode tables: the whole Unicode character database moved into NativeArray<T> (Persistent) — off the GC heap, shared by both the Burst and fallback paths.
• Added
  Trigger-scan markup parsing: every ParseRule declares the characters that can start its match, and the parser bakes their union into an ASCII jump table — the match walk skips runs of plain text without probing any rule, degrading to the 2.x linear walk for exotic trigger sets.
• Added
  Single source per algorithm: each UAX rule now exists in exactly one place, collapsing the engine classes to thin wrappers (BidiEngine 2,287 → 402 lines, LineBreakAlgorithm 680 → 122) — less surface to break, zero drift between fast path and fallback.

Rendering & shaders

• Added
  Unified coverage × paint SDF pipeline: every glyph quad picks a CoverageMode (Fill/Stroke/Shadow/InnerShadow) and a PaintKind (Solid/Gradient/Texture); plain glyphs leave both at 0 and pay nothing, while styled text composes Photoshop-style layer effects on the GPU with one draw call per material. Backed by UniText_Coverage.hlsl + UniText_Paint.hlsl and shared decode includes (UniText_AtlasDecode.hlsl, UniText_SdfSample.hlsl) that de-duplicate four hand-copied decode paths.
• Added
  Lit world text is a checkbox (UniTextWorld.Lit): one per-component toggle renders the text with scene lighting — the lit SDF/emoji materials are selected automatically, and adjacent instances can independently be lit or unlit. In 2.x this required hand-assigning the shipped lit materials through a custom-material style. CastShadows (independent of Lit, off by default) opts the batched renderer into shadow casting, resolved per sorting context — 2.x lit text always cast, with no supported way to turn it off.
• Added
  Unlit fast path on the Lit shaders: _LightInfluence 0 branches around the whole lighting computation (UNITY_BRANCH on a uniform — no extra keyword or variant), instead of 2.x's compute-then-lerp — a world-text material dialed to unlit pays no per-fragment lighting cost.
• Added
  World shaders ship via the settings asset: UniTextSettings now retains the world-space UniText/Lit/SDF / UniText/Lit/Emoji and Canvas UniText/UI/Highlight shaders (six required-shader slots, up from three), so world text and highlight materials resolve in builds without touching Always Included Shaders; the new Include Lit Shaders toggle (Project Settings → UniText → Rendering, default on) drops the Lit pair from builds that use no lit text.
• Added
  Shared gradient-ramp atlas (GradientRampAtlas): one 256-wide row per unique gradient, deduped by content and ref-counted, uploaded row-granularly — crisp gradients that stay allocation-free and animate at one texture-row upload per frame, shared across all text and highlights on the device.
• Added
  Rounded, gradient highlight shaders: the world UniText/Highlight gained a rounded-rect SDF with gradient-ramp paint, and a new Canvas UniText/UI/Highlight provides the uGUI counterpart — rounded, gradient-filled selection/find highlights on both backends.

Animator integration

• Added
  UniTextAnimationBridge: a sibling component that makes Unity Animator-driven changes update the text — add it next to a UniText/UniTextWorld and add the handlers for the fields and modifiers you animate; text without the component does no per-frame diff work.
• Added
  Component field handlers — UniTextFieldsAnimationHandler (font size, colour, word wrap, auto-size with min/max, alignment) and UniTextWorldFieldsAnimationHandler (the same, plus sorting order and layer).
• Added
  Modifier handlers — ColorAnimationHandler, SizeAnimationHandler, LetterSpacingAnimationHandler, GlowAnimationHandler, ShadowAnimationHandler, StrokeAnimationHandler, and PhaseAnimationHandler (keyframe a phase-driven glyph animation — binds the host's first IPhaseDriven modifier), each with the correct per-parameter invalidation.
• Added
  AnimationHandler / ModifierAnimationHandler: [SerializeReference] extension points — subclass to animate a custom component's fields or a custom modifier's [Parameter] fields from an Animator.

Editor tooling

• Added
  Inline Scene-view text editing: double-click any UniTextBase in the Scene, press F2, run Tools/UniText/Edit Text in Scene, or click the inspector's "✎ Edit in Scene View" button to open a live editing session — caret, selection, drag-select, word/paragraph click, keyboard nav, clipboard, undo/redo, and OS IME (candidate window anchored to the Scene-view caret) — all driven by the runtime engine, with a floating formatting overlay (B/I/U, colour, markup visibility) and a right-click menu. On exit the edited markup is written back through Undo.RecordObject, and every helper component the session spawned is removed, leaving the GameObject graph exactly as it was.
• Added
  Automatic v2.x → 3.0 asset migrations: nine concrete IMigration classes upgrade serialized scenes/prefabs/assets on first load (byte-preserving YAML splices, auto-run on version change, no prompts, CI excluded) — Outline→Stroke, Gradient→Fill, Wobble→Wave, the gradient-provider trio → InlinePaintProvider/AssetPaintProvider/GlobalSettingsPaintProvider, a bold-weight sentinel fix, DefaultTextHighlighter → StateHighlightStyler, and legacy UniTextGradients catalogs → UniTextPaints. A breaking major upgrade that costs the user nothing.
• Added
  Custom inspectors for UniTextEditable, UniTextSelectable, and InputBehaviorPreset, backed by the shared [SerializeReference] type picker with grouped, icon-labelled, description-carrying "Add" menus for behaviors, decorators, filters/validators, and context-menu items. InputBehaviorPresetEditor audits preset assets for behaviors pointing at scene objects.
• Added
  New property drawers: PaintSwatchDrawer, UnitValueDrawer (value + unit dropdown), InheritableFieldDrawer (NaN inherit sentinel), ChromeRuleDrawer, FormatCommandDrawer, and ModifierBodyDrawer (shows a modifier's [Parameter] fields as an opt-in override list — a field appears only when it differs from the default, and edits route through the live C# property for scoped invalidation).
• Added
  Clipboard Inspector window (Tools/UniText/Clipboard Inspector): shows every format a copy wrote — plain text, UniText source, HTML, Markdown, URL, custom MIME, images (with a decoded preview) and files — with counts, decoded payload, and whitespace visualization.

Focus & accessibility

• Added
  FocusGuard (in LightSide.Core): marks a UI hierarchy (formatting toolbar, context panel) focus-preserving, so pressing its controls neither defocuses the editor nor drops the selection — the toolbar contract of a word processor. One drop-in component; FocusGuard.PointerIsOverGuarded() recovers the press target.
• Added
  UniTextFocusable: a hidden, runtime-managed Selectable that makes an editable surface a Tab stop (Navigation.Mode.Automatic) while a selection-only surface stays pointer-focusable but Tab-excluded (the web model) — reconciled automatically, never added by hand.
• Added
  Accessibility preferences: Accessibility.PrefersReducedMotion (LightSide.Core, with a change event; honored by FloatingLabelDecorator and any driver that consults it — maps to iOS/macOS Reduce Motion, Android Remove Animations, web prefers-reduced-motion) and InputCaretRenderer.PrefersNonBlinkingCaret (suppresses caret blink — iOS "Prefer Non-Blinking Cursor"). The app sets the flags from platform prefs.

Samples, scaffolding & CI

• Added
  One-click scene scaffolding: GameObject → UI (Canvas) → UniText → Selectable Text / Editable Text instantiate the project's own prefab from UniTextSettings.{SelectableText,EditableText}Prefab (the Unity way — a designer's configured prefab, not a code-built hierarchy), provisioning a Canvas + EventSystem (wiring InputSystemUIInputModule under the new Input System) and warning when a slot is empty.
• Added
  Shipped Defaults/ assets: Selectable Text, Editable Text, Input Field prefabs plus the three selection-handle sprites for the touch UI.
• Added
  New EditableText sample: a complete working editor scene — the selectable → editable ladder, an InputBehaviorPreset, a password field with a reveal toggle, a caret-context formatting toolbar, and chat-style media paste turning pasted images into attachment cards.
• Added
  Expanded Basic Usage sample: auto-detected @mention/#hashtag chips, tap-to-reveal spoilers, a live-swappable custom RangeStyler, Find-in-Page over FindAll painted onto highlight layers, and a LanguageFonts/ set covering 17 non-Latin scripts. The Modifiers sample is renamed Styles; FontExamples gains a variable-font EdgeCasesFonts/ set (Comfortaa and Outfit variable-weight fonts).
• Added
  CI: a GitHub Actions urp-compile-check matrix imports the package into URP 12.1 / 14.0 / 17.0 projects and fails on any shader import error, and three workflows build the Windows/macOS/Android native input plugins reproducibly from committed source; LightSide.Core adds its own workflows for the GPU-upload and profiler-sampler plugins — shaders proven across three URP majors, and native binaries transparent, not opaque blobs.
• Added
  Optional Input System: documented as an optional dependency (UNITEXT_INPUTSYSTEM via versionDefines) — works with the old Input Manager, the new Input System, or both. Native text input works regardless either way.

• Changed
  UniText now depends on media.lightside.core 1.0.0 and is layered on top of the shared foundation extracted into that package (see Two packages). Source-compatible apart from two utility renames (UniTextArrayPool<T> → ArrayPool<T>, RangeEx.WholeText/IsWholeText → RangeEx.All/IsAll); the moved types kept namespace LightSide.
• Changed
  IParseRule interface replaced by the ParseRule abstract class (breaking, no alias). Custom parse rules now subclass ParseRule and override TryMatch; the base carries the syntax-introspection contract (Identity, SourceToken, MarkupTriggers/ScanTriggers, CanWrap, Apply) that lets the editor apply/toggle/round-trip a style in its own markup.
• Changed
  StyleCore gained editor-grade introspection: ParseRule now describes and re-emits its own syntax (all public — see Rich-text formatting), and UniTextBase gained EnsureStyleFor and GetModifier(Type) — the surface that powers the formatting toolbar. Style addressing is by modifier signature (a concrete exemplar, resolved internally); there is no name-based style lookup.
• Changed
  Pipeline events are per-component now: new UniTextBase instance events — FrameUpdated (once per frame while the component updates; the tick range stylers and modifier animations subscribe to) and LayoutCommitted (fires only when this component reprocessed and its glyph geometry is final — the moment to rebuild coordinate maps, caret geometry, or overlay positioning) — replace the removed public static UniTextBase.BeforeProcess/MeshApplied/AfterProcess (breaking, no alias). A subscriber now pays only for the component it watches, never for every text update in the scene.
• Changed
  InteractiveModifier went from an abstract, subclass-required handler to a concrete, inspector-pickable modifier with a per-range state machine, six range events, and a RangeStyler seam (see Highlight layers, find-in-page & interactive ranges). Range pointer events moved off UniTextBase onto the modifier.
• Changed
  Pointer/click events on UniTextBase use the TextPointerEvent type. TextClicked now carries a consumable TextPointerEvent (device kind, modifiers, trigger, consume flag) instead of a bare TextHitResult; the previous base range pointer events (RangeClicked/RangeEntered/RangeExited, IsHoveringRange/CurrentHoverRange) were removed in favor of InteractiveModifier's events.
• Changed
  UniTextBase.HitTest/HitTestScreen renamed to HitTestRange (range/bounding-box "which entity is here" semantics), distinct from the new caret hit-testing (HitTestCaret).
• Changed
  Style modifiers rebuilt around the paint system: the whole visual half of StyleCore now runs on one paint abstraction (fills/strokes/shadows/glows/decorations take any solid/gradient/texture paint), every parameter gained a serialized default + public property + per-range override, and files reorganized into TextStyle/Layout/Appearance/Utility/Decoration/Effects/Media subfolders (see Text effects & paint).
• Changed
  Highlight rendering moved from a flat single-color rect list to named, prioritized highlight layers: the TextHighlighter/DefaultTextHighlighter family and the serialized highlighter field on UniTextBase were removed — selection visuals via UniTextSelectable.SelectionStyle, interactive-range feedback via RangeStyler, everything else through UniTextHighlights.
• Changed
  The world batcher groups by sorting context, not material: a batch is keyed by (sorting layer, order, SortingGroup, GameObject layer, scene) with materials demoted to sub-meshes, so one component's cross-material layers — emoji beside SDF glyphs, texture-paint fills, per-style custom materials — draw in exact Styles order, the way Canvas sibling order does (in 2.x each material was its own batch mesh, with unspecified relative order). Inside a context, entries pack into size-bounded shards (target raised 8,192 → 16,384 vertices, tunable via UniTextSettings.WorldBatcherShardTargetVertexCount) so a structural change re-bakes only the owning shard; index buffers escalate UInt16 → UInt32 automatically past 65,535 vertices.
• Changed
  UniTextDirtyFlags renamed to UniTextDirty (breaking, no alias) and re-cut to name pipeline stages instead of properties: Color → Mesh, Alignment → Positions, FontSize folded into the existing Layout; Text/Font/Direction/Material keep their names; Sorting and the LayoutRebuild composite were removed (sorting propagates through events, not a rebuild flag). Recompile against the new enum; do not persist raw values.
• Changed
  Text animation is now phase-driven, not self-animating: v2's WobbleAnimationModifier (read Time.time, rebuilt every frame) is renamed WaveModifier (auto-migrated, speed → frequency) and re-cut as a pure function of Phase — controllable and scrubbable instead of a fire-and-forget frame-eater (see Kinetic text animation).
• Changed
  Animator support is opt-in via UniTextAnimationBridge: animating a component's own fields now requires the bridge with the matching field handler, instead of every Animator-driven component diffing its fields automatically.
• Changed
  The GPU glyph-upload backend was rebuilt (ABI v3) and moved to LightSide.Core as the public GpuUpload API, with device-loss and multi-backend (D3D/Metal/Vulkan/WebGL2) handling.
• Changed
  3D text shadows match the visual: the shadow casters now cast each visible layer's coverage, so an outlined or glowing glyph throws a shadow shaped like what you see, not the bare core glyph.

• Removed
  Legacy gradient & outline modifiers: GradientModifier, OutlineModifier, IGradientProvider/IHasGradientProvider, and the Inline/Asset/GlobalSettings gradient-provider family — superseded by gradient paints on any layer via IPaintProvider and by StrokeModifier — along with the UniTextGradients catalog asset and UniTextSettings.Gradients (superseded by UniTextPaints and UniTextSettings.Paints; a migration converts each legacy catalog into a -Paints sibling asset). The <gradient>/<outline> tags survive as deprecated parse rules so existing markup still renders; the removed types have no alias (asset data auto-migrates).
• Removed
  TextHighlighter / DefaultTextHighlighter and the serialized Highlighter field on UniTextBase — replaced by highlight layers, SelectionStyle, and RangeStyler.
• Removed
  Interactive-range dispatch types InteractiveRangeRegistry, IInteractiveRangeProvider, IInteractiveRangeHandler, and InteractiveRange.priority — InteractiveModifier now self-subscribes to the pointer surface; overlapping ranges from different modifiers all dispatch, in registration order.
• Removed
  Static pipeline events UniTextBase.BeforeProcess/MeshApplied/AfterProcess (breaking, no alias) — replaced by the per-component FrameUpdated/LayoutCommitted (see Changed).
• Removed
  AnimationHandlerBase<T>: extending the Animator diff is now done by adding a field/modifier handler to a UniTextAnimationBridge.