RichText Pro

Quick start

RichText Pro 1.0 runs inside Roblox Studio and builds styled or animated text for Roblox UI objects.

1. Open the plugin

Install and enable RichText Pro, then press RichText Pro in the Studio plugin toolbar. The editor opens as a DockWidget and can be docked or floated.

2. Select a target

Select one of these objects in Explorer or the Studio viewport:

• TextLabel
• TextButton
• TextBox

Selecting a target does not overwrite either editor. Press Load Text when you want to bring the selected object into the active editor.

3. Build the text

1. Choose Basic Editor or Animation Editor.
2. Press Load Text, or begin with the default layer.
3. Edit the selected layer’s text.
4. Add a new line or duplicate a layer when the composition needs another independently styled section.
5. Apply Basic styles in the Inspector, or add Animation effects from the Tag Library.
6. Review the result in Preview.
7. Press Apply Text.

If several supported text objects are selected, Apply Text writes the current composition to all of them.

4. Test animated text

Test Animation Editor output in Studio Play mode. Confirm the copy fits the target at each supported resolution and behaves correctly when its ScreenGui, SurfaceGui, BillboardGui or parent frame is hidden.

Save the place or create a version checkpoint before applying a large batch of UI changes.

Editor overview

RichText Pro 1.0 is layer-first. The visual layer model is the source of truth and tag code is generated automatically.

Visual text layers

A text layer is an editable piece of the final message. Layers on the same line render next to one another; layers on different line numbers render as separate lines.

Add and edit layers

• Press Add New Line to create a layer on a new line.
• Edit the selected layer in the Layer text field.
• Press Duplicate to copy the text and its current styling or effects.
• Press Delete to remove the selected layer. An editor always keeps at least one layer.

Arrange the composition

Use the line controls to move a layer to an earlier or later line. Use the left and right controls to change its order within the current line. You can also drag a layer card to reorder it visually.

The Preview and applied text follow the visual order shown in the layer list.

Copy styles and effects

In Basic Editor, Copy Style and Paste Style copy the selected layer’s formatting. In Animation Editor, Copy FX and Paste FX copy its effect stack. Layer text is not replaced.

Undo and Redo

Each editor has its own history. Use the visible Undo and Redo controls, or use Ctrl+Z and Ctrl+Y when keyboard shortcuts are enabled.

Basic Editor

Basic Editor creates native Roblox RichText. It does not need animated runtime behavior.

Inspector controls

The Inspector changes only the selected layer:

• Text color and opacity
• Font face, weight and size
• Stroke color and thickness
• Highlight color and opacity

The font menu includes common Roblox faces such as Gotham, FredokaOne, SourceSans, Code, Cartoon, Arcade, SciFi, Highway and Ubuntu.

Quick Styles

Quick Styles include:

• Bold, Italic, Underline and Strike
• Uppercase and Small caps
• New line and Safe symbols
• Text color, Typography, Stroke and Highlight
• Title, Success, Warning, Danger and Muted treatments
• Large text, Small text and Code font

The underlying Basic tags are bold, italic, underline, strike, uppercase, small caps, font, stroke and mark/highlight.

Basic actions

• Load Text imports the selected target.
• Apply Text writes the current layers to one or more selected targets.
• Check validates the generated RichText.
• Clear styles removes formatting from the selected layer after confirmation.
• Fix cleans stale RichText Pro metadata and repairs the selected target.
• Audit checks the full Basic layer model for empty layers, duplicate styles, high layer counts and heavy strokes.

Animation Editor

Animation Editor uses the same visual layer workflow and gives each layer its own effect stack. Select a layer, choose a category, then click a Tag Library item to add it.

The library contains 64 entries:

• 57 custom color, motion, timing, sound and style effects
• 7 native RichText styles that can be used inside Animation layers

Large categories include a search field. Search matches the tag name, display name and description.

Effect chips

The selected layer shows its active effects as chips. Click an effect to edit its properties. Remove an effect with its remove control, or use Remove FX to remove Animation output from the selected Roblox target without changing the editor composition.

Combining effects

Start with a restrained stack:

1. Add one Color treatment.
2. Add one primary Motion effect.
3. Add Timing only when it improves the message.
4. Add a Style effect for finishing.

Multiple effects can work together, but several movement or color effects on one layer may compete or become expensive. Use Audit before applying a large composition.

Animation actions

• Load Text imports current layer data or migrates compatible older source.
• Apply Text compiles every layer and writes the composition to the selected targets.
• Rebuild regenerates the internal source from the current visual layers.
• Remove FX removes generated animation objects from the selected Roblox target while preserving the editor.
• Fix repairs managed target data and removes stale attributes.
• Audit checks unknown effects, empty layers, duplicate tags and expensive stacks.

Tag properties

Selecting an editable effect opens a compact property editor. Changes preview live.

• Apply commits the current values as one editor change.
• Cancel restores the values from when the panel opened.
• Enter applies where keyboard focus allows it.
• Escape cancels and closes the panel.

Drag the panel from its title bar when it covers the Preview.

The control type follows the property: number input, slider, dropdown, on/off switch, color input, palette or free-form text. Use the small help control beside a field for its description.

Colors and gradients

The color picker supports saturation/brightness dragging, hue selection, hexadecimal values, RGB fields and saved swatches.

Gradient effects can open the visual Gradient Stops editor. Add or remove stops, drag a stop to reposition it and click a stop to change its color.

Tag reference

Color tags

Motion tags

Timing tags

Style tags

Preview controls

Each editor has its own Preview board.

Pan and zoom

• Hold the middle mouse button over Preview and drag to pan.
• Scroll over Preview to zoom.
• Use + and − for stepped zoom changes.
• Use Center to fit all visible layers.

The displayed zoom level affects only the editor view, not the final Roblox text size.

Background and axes

Switch between dark and light backgrounds to check contrast. Optional horizontal and vertical center axes help with alignment. The Settings panel can pause the Preview for the hidden editor and change animated-gradient quality.

Presets

Basic and Animation presets are stored separately.

Default Presets

Default Basic presets provide common text treatments. Default Animation presets include examples such as Showcase Reveal, Frost, Inferno, Neon, Cinematic, Spring, Launch Up, Spotlight Reveal, Comet, Celebrate, Arcade, Impact Pop, Kinetic Reveal, Aurora Float, Hologram and more.

Use a default preset as a starting point, then replace the sample wording and tune each layer.

Your Presets

Enter a clear name and press Save preset. User presets remain available after Studio restarts and appear in Your Presets.

Deleting a user preset requires confirmation when destructive-action confirmation is enabled. Default presets cannot be deleted.

Productivity and safety

Audit

The Text Audit reports issues and cleanup suggestions. Depending on the editor, it can detect:

• empty layers
• duplicate styles or effects
• unknown effects
• heavy strokes
• too many effects on one layer
• several movement or color effects competing on one layer
• high Basic, animated or dynamic layer counts

Use Fix Safe Issues to remove duplicate/unknown data that RichText Pro can clean without changing the intended text.

Fix

Fix operates on the selected Roblox target. It migrates current metadata, rebuilds managed output where possible and removes stale attributes. Use it when a target was created by an older release or its generated objects were manually changed.

Destructive-action confirmation

Deleting layers, effects, presets or styles can show a preview before the action runs. These editor actions still participate in RichText Pro history where supported.

Settings

Open the gear button to configure RichText Pro.

Behavior

• Confirm destructive actions
• Center after Load Text
• Keyboard undo and redo
• Detailed status messages

Appearance

Choose from Midnight, Graphite, Contrast, Violet, Ocean, Emerald, Ember, Rose, Royal, Solar, Cherry and Arctic themes. Choose Compact or Super Compact density, and adjust the editor text-stroke strength.

Preview

• Pause hidden previews
• Auto-fit after layer changes
• Show Preview center axes
• Performance, Balanced or High animated-gradient quality

The Shortcuts page repeats the current Preview and editing controls.

Applying to Roblox UI

Load and Apply are separate

Selecting a new object updates the target but does not change the editor. This prevents an accidental selection from discarding the current composition.

• Press Load Text to import the selected target into the active editor.
• Press Apply Text to write the current editor to the selected target or targets.

When loading older RichText Pro animation source, the current release converts compatible content into its visual layer model.

Batch apply

Select multiple TextLabel, TextButton or TextBox objects, then press Apply Text. The current composition is applied to every supported selected object as one Studio change-history action.

Basic output

Basic output enables Roblox RichText and stores the visual layer data needed for later editing.

Animation output

Animation output creates managed visual-layer wrappers inside the selected text object. It stores layer data and effect configuration on the target and generated wrappers, then ensures the shared runtime and client API exist.

Removing effects

In Animation Editor, Remove FX removes RichText Pro generated animation objects from the selected target. It does not clear the current editor composition.

Playback API

Applying managed text creates or updates:

• RichTextProClient in ReplicatedStorage
• RichTextProClientRuntime in StarterPlayerScripts, with its shared Engine module

Require the API from a LocalScript:

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RichTextPro = require(ReplicatedStorage:WaitForChild("RichTextProClient"))

The API can only be required on the client. Each target must be a GuiObject. For layered output, every command also reaches the managed visual-layer wrappers below that target, so developers should always pass the original TextLabel, TextButton or TextBox.

Play, Pause and Restart return the same target that was passed in. Invalid or non-GuiObject targets raise a clear error.

Play

RichTextPro.Play(titleLabel)

Play resumes from the current timeline position after a manual pause. Pass true as the second argument to restart in one call:

RichTextPro.Play(titleLabel, true)

Pause

RichTextPro.Pause(titleLabel)

Pause keeps the current animation state. Calling Play later continues it.

Restart

RichTextPro.Restart(titleLabel)

Restart resets the managed playback state and resumes the animation.

IsPlaying

if RichTextPro.IsPlaying(titleLabel) then
	print("The title is playing")
end

IsPlaying reports whether playback was requested, not whether the target is currently visible. A target can return true while the shared runtime has temporarily suspended rendering because the UI is hidden or fully clipped.

Example: follow a panel

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RichTextPro = require(ReplicatedStorage:WaitForChild("RichTextProClient"))

local panel = script.Parent
local titleLabel = panel:WaitForChild("Title")

local function syncPlayback()
	if panel.Visible then
		RichTextPro.Restart(titleLabel)
	else
		RichTextPro.Pause(titleLabel)
	end
end

panel:GetPropertyChangedSignal("Visible"):Connect(syncPlayback)
syncPlayback()

Use Play instead of Restart in the visible branch when the animation should resume from the point where it paused.

Developer hooks and recipes

RichText Pro is designed to sit behind normal Roblox UI events. The API does not require a special controller object: keep the original text target, then call the playback method from any LocalScript that owns the surrounding UI behavior.

Replay from a button

Use Activated so the same hook works with mouse, touch and gamepad input:

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RichTextPro = require(ReplicatedStorage:WaitForChild("RichTextProClient"))

local replayButton = script.Parent:WaitForChild("Replay")
local titleLabel = script.Parent:WaitForChild("Title")

replayButton.Activated:Connect(function()
	RichTextPro.Restart(titleLabel)
end)

Trigger from a RemoteEvent

Use a RemoteEvent when the server decides that an existing announcement, reward or warning animation should play. The visual effect still runs locally:

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RichTextPro = require(ReplicatedStorage:WaitForChild("RichTextProClient"))

local showAnnouncement = ReplicatedStorage:WaitForChild("ShowAnnouncement")
local announcementLabel = script.Parent:WaitForChild("Announcement")

showAnnouncement.OnClientEvent:Connect(function()
	RichTextPro.Restart(announcementLabel)
end)

Validate and rate-limit the server action that fires the RemoteEvent. Do not let the client decide protected game outcomes merely because it controls the visual playback.

Use RichText Pro in a dialogue system

The 1.0 playback API controls animation state; it does not replace the text stored in an applied visual-layer composition. For animated dialogue, create one RichText Pro TextLabel for each prepared line or response style, place the labels in the same UI position and let the dialogue controller choose which label is visible.

Example hierarchy:

DialogueGui
└── DialogFrame
    ├── Lines
    │   ├── Greeting
    │   ├── Quest
    │   └── Goodbye
    ├── Next
    └── Dialogue.client.lua

Apply the intended Animation Editor treatment to Greeting, Quest and Goodbye in Studio. Set the labels to the same size and position, then use this LocalScript:

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RichTextPro = require(ReplicatedStorage:WaitForChild("RichTextProClient"))

local dialogFrame = script.Parent
local linesFolder = dialogFrame:WaitForChild("Lines")
local nextButton = dialogFrame:WaitForChild("Next")

local lines = {
	linesFolder:WaitForChild("Greeting"),
	linesFolder:WaitForChild("Quest"),
	linesFolder:WaitForChild("Goodbye"),
}

local currentIndex = 0

local function hideAllLines()
	for _, label in ipairs(lines) do
		RichTextPro.Pause(label)
		label.Visible = false
	end
end

local function showLine(index)
	hideAllLines()

	currentIndex = math.clamp(index, 1, #lines)
	local label = lines[currentIndex]
	label.Visible = true
	RichTextPro.Restart(label)

	nextButton.Text = currentIndex == #lines and "Close" or "Next"
end

nextButton.Activated:Connect(function()
	if currentIndex >= #lines then
		hideAllLines()
		dialogFrame.Visible = false
		return
	end

	showLine(currentIndex + 1)
end)

dialogFrame.Visible = true
showLine(1)

Each line restarts from the beginning when it becomes active, so intro, reveal and typewriter tags play consistently. Replace the fixed list with your own dialogue state or response tree while keeping the targets pre-authored.

Open dialogue from a ProximityPrompt

An NPC or world object can open the prepared dialogue from a client-side ProximityPrompt hook:

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RichTextPro = require(ReplicatedStorage:WaitForChild("RichTextProClient"))

local playerGui = Players.LocalPlayer:WaitForChild("PlayerGui")
local dialogueGui = playerGui:WaitForChild("DialogueGui")
local dialogFrame = dialogueGui:WaitForChild("DialogFrame")
local linesFolder = dialogFrame:WaitForChild("Lines")
local firstLine = linesFolder:WaitForChild("Greeting")
local npc = workspace:WaitForChild("NPC")
local prompt = npc:WaitForChild("Head"):WaitForChild("ProximityPrompt")

prompt.Triggered:Connect(function()
	dialogueGui.Enabled = true
	dialogFrame.Visible = true
	firstLine.Visible = true
	RichTextPro.Restart(firstLine)
end)

If the dialogue has several prepared labels, call the showLine function from the previous example instead of controlling firstLine directly.

Play an intro only while the player looks at it

For animated text inside a BillboardGui or SurfaceGui, combine a camera view-cone check with viewport, distance and line-of-sight checks. The example below restarts the intro once when the player begins looking at the sign, pauses when they look away and does not restart continuously while they keep looking.

Example hierarchy:

Workspace
└── AnimatedSign
    ├── FocusPart
    └── BillboardGui
        └── Title

Place this LocalScript in StarterPlayerScripts:

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RunService = game:GetService("RunService")

local RichTextPro = require(ReplicatedStorage:WaitForChild("RichTextProClient"))

local player = Players.LocalPlayer
local signModel = workspace:WaitForChild("AnimatedSign")
local focusPart = signModel:WaitForChild("FocusPart")
local billboardGui = signModel:WaitForChild("BillboardGui")
local titleLabel = billboardGui:WaitForChild("Title")

local MAX_DISTANCE = 70
local LOOK_ANGLE_DEGREES = 18
local LOOK_DOT_THRESHOLD = math.cos(math.rad(LOOK_ANGLE_DEGREES))
local CHECK_INTERVAL = 0.1

local raycastParams = RaycastParams.new()
raycastParams.FilterType = Enum.RaycastFilterType.Exclude

local wasLooking = false
local elapsed = 0

RichTextPro.Pause(titleLabel)

local function playerIsLooking()
	local camera = workspace.CurrentCamera
	if not camera then
		return false
	end

	local cameraPosition = camera.CFrame.Position
	local toTarget = focusPart.Position - cameraPosition
	local distance = toTarget.Magnitude

	if distance <= 0 or distance > MAX_DISTANCE then
		return false
	end

	local viewportPoint, onScreen = camera:WorldToViewportPoint(focusPart.Position)
	if not onScreen or viewportPoint.Z <= 0 then
		return false
	end

	local lookDot = camera.CFrame.LookVector:Dot(toTarget.Unit)
	if lookDot < LOOK_DOT_THRESHOLD then
		return false
	end

	local character = player.Character
	raycastParams.FilterDescendantsInstances = character and { character } or {}

	local hit = workspace:Raycast(cameraPosition, toTarget, raycastParams)
	return hit == nil or hit.Instance:IsDescendantOf(signModel)
end

local function updatePlayback(isLooking)
	if isLooking == wasLooking then
		return
	end

	wasLooking = isLooking

	if isLooking then
		RichTextPro.Restart(titleLabel)
	else
		RichTextPro.Pause(titleLabel)
	end
end

RunService.Heartbeat:Connect(function(deltaTime)
	elapsed += deltaTime
	if elapsed < CHECK_INTERVAL then
		return
	end

	elapsed = 0
	updatePlayback(playerIsLooking())
end)

Increase LOOK_ANGLE_DEGREES for a wider trigger area or reduce it when the player should aim more directly at the text. Remove the raycast block when walls and other obstructions should not matter.

The RichText Pro runtime already suspends hidden, disabled, transparent or fully clipped managed UI. This custom hook adds game-specific intent: it narrows playback to a chosen view cone and deliberately replays the intro when the player looks back.

Replay when a menu tab becomes active

When one ScreenGui contains several tab pages, restart only the animated heading owned by the page that was selected:

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RichTextPro = require(ReplicatedStorage:WaitForChild("RichTextProClient"))

local tabs = script.Parent
local pages = tabs.Parent:WaitForChild("Pages")

local tabButtons = {
	Inventory = tabs:WaitForChild("Inventory"),
	Quests = tabs:WaitForChild("Quests"),
	Settings = tabs:WaitForChild("Settings"),
}

local pageFrames = {
	Inventory = pages:WaitForChild("Inventory"),
	Quests = pages:WaitForChild("Quests"),
	Settings = pages:WaitForChild("Settings"),
}

local pageTargets = {
	Inventory = pageFrames.Inventory:WaitForChild("Heading"),
	Quests = pageFrames.Quests:WaitForChild("Heading"),
	Settings = pageFrames.Settings:WaitForChild("Heading"),
}

local function showPage(pageName)
	for name, target in pairs(pageTargets) do
		local selected = name == pageName

		pageFrames[name].Visible = selected
		if selected then
			RichTextPro.Restart(target)
		else
			RichTextPro.Pause(target)
		end
	end
end

for pageName, button in pairs(tabButtons) do
	local selectedPage = pageName
	button.Activated:Connect(function()
		showPage(selectedPage)
	end)
end

showPage("Inventory")

Control several animated labels

Store the original targets in a table and apply the same command to each:

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RichTextPro = require(ReplicatedStorage:WaitForChild("RichTextProClient"))

local targets = {
	script.Parent:WaitForChild("Heading"),
	script.Parent:WaitForChild("Subtitle"),
	script.Parent:WaitForChild("Reward"),
}

local function restartAll()
	for _, target in ipairs(targets) do
		RichTextPro.Restart(target)
	end
end

restartAll()

This is runtime grouping only. It does not require the labels to have been batch-applied together in Studio.

Observe playback-state changes

The public methods update the RichTextProPlaying attribute on the original target. A LocalScript can observe that attribute when another local controller needs to react:

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RichTextPro = require(ReplicatedStorage:WaitForChild("RichTextProClient"))

local titleLabel = script.Parent:WaitForChild("Title")

local function onPlaybackRequestChanged()
	local requested = RichTextPro.IsPlaying(titleLabel)
	print(requested and "Playback requested" or "Playback paused")
end

titleLabel:GetAttributeChangedSignal("RichTextProPlaying"):Connect(
	onPlaybackRequestChanged
)

onPlaybackRequestChanged()

Use the API to change playback. Treat every other generated RichTextPro attribute, CollectionService tag and child object as managed implementation data.

Build a small reusable controller

For UI with several screens, wrap the API once and reuse the wrapper:

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RichTextPro = require(ReplicatedStorage:WaitForChild("RichTextProClient"))

local TextAnimationController = {}

function TextAnimationController.Show(target, replay)
	target.Visible = true
	if replay then
		RichTextPro.Restart(target)
	else
		RichTextPro.Play(target)
	end
end

function TextAnimationController.Hide(target)
	RichTextPro.Pause(target)
	target.Visible = false
end

return TextAnimationController

Place this code in a client ModuleScript and require it from the LocalScripts that manage your menus. Pass only text targets that were applied from Animation Editor.

Restart after another UI animation

RichText Pro can be hooked to Tween completion or any other Roblox signal:

local TweenService = game:GetService("TweenService")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local RichTextPro = require(ReplicatedStorage:WaitForChild("RichTextProClient"))

local panel = script.Parent -- CanvasGroup
local titleLabel = panel:WaitForChild("Title")
local tween = TweenService:Create(
	panel,
	TweenInfo.new(0.25),
	{ GroupTransparency = 0 }
)

tween.Completed:Connect(function(playbackState)
	if playbackState == Enum.PlaybackState.Completed then
		RichTextPro.Restart(titleLabel)
	end
end)

tween:Play()

Cleanup event connections

When a controller may be destroyed or reused, retain and disconnect its connections:

local connection = replayButton.Activated:Connect(function()
	RichTextPro.Restart(titleLabel)
end)

script.Destroying:Connect(function()
	connection:Disconnect()
end)

The shared RichText Pro runtime manages its own target tracking. Developers only need to clean up the event connections created by their own scripts.

Completion and progress

Release 1.0 does not expose per-effect progress or a universal animation-completed signal. Effects can loop, hold or combine timelines, so there is not always one meaningful completion point. Use the Roblox event that owns the UI flow, a known game-state transition or your own task timing when another action must follow the visual.

Do not inspect generated layer wrappers to estimate progress. Their names, attributes and layout are managed by RichText Pro and may change when text is reapplied.

Visibility and performance

The shared runtime automatically tracks managed targets and checks whether the target, its generated layer and relevant ancestors are actually visible. It reacts to target visibility and size, GuiObject ancestor visibility, LayerCollector Enabled state, CanvasGroup transparency, clipping bounds, reparenting and managed-layer replacement.

Hidden ScreenGui, SurfaceGui, BillboardGui and GuiObject ancestors suspend unnecessary active playback. Fully transparent CanvasGroups and targets completely outside a clipping ancestor are also suspended. The render-step connection is disconnected when no managed target needs active animation.

These automatic hooks handle performance. Use Play, Pause and Restart for game semantics—for example, deciding whether reopening a panel resumes or replays its title.

Performance guidance

• Prefer one strong motion effect per layer.
• Avoid several color effects competing for the same final gradient.
• Treat more than seven active effects on one layer as a reason to simplify.
• Treat more than five animated layers as a reason to test performance carefully.
• Use Audit before shipping a complex composition.
• Choose Performance Preview quality when editing many gradient-heavy layers.
• Test on representative client hardware and target UI sizes.

RichText Pro uses one shared client runtime instead of placing a large LocalScript under every layer.

Sound effects

The sound tag plays a Roblox audio asset when its layer first becomes visible.

Editable values include:

• audio asset ID
• volume
• playback speed
• looped state
• start delay

Use either the numeric ID or the Roblox asset-ID form accepted by the editor. The runtime creates managed Sound instances under the target and pauses or removes them with managed playback.

The experience must have permission to use the chosen audio. Test the sound in a published test place as well as Studio.

Migration and repair

RichText Pro 1.0 can load compatible older RichText Pro source into the visual layer model.

When opening an older target:

1. Select the target.
2. Press Load Text in the intended editor.
3. Review the converted visual layers.
4. Run Audit.
5. Press Fix if stale data or generated objects remain.
6. Apply the reviewed 1.0 composition.

Keep a place version before migrating many targets. The plugin removes known obsolete RichText Pro and RichText Studio attributes during managed cleanup.

Troubleshooting

The editor did not change when I selected another target

This is intentional. Press Load Text to import the selected object. Apply Text always writes the current editor, so confirm the target and Preview before applying.

A style or effect changed the wrong words

Select the intended layer card first. Inspector changes and Tag Library actions operate on the selected layer.

Layers appear in the wrong order

Check both the line number and the order within that line. Use the line controls, left/right controls or drag the layer card.

Apply changed several objects

RichText Pro supports batch application. If multiple supported text objects are selected, Apply Text writes to all of them. Select only the intended target when editing a single object.

The property editor covers the Preview

Drag it from the title bar. Apply or cancel it before switching workspaces.

Preview will not pan or zoom

Move the pointer over the Preview surface before using middle-mouse drag or the wheel. Press Center to recover an off-screen composition.

Motion is clipped

Increase the target’s available space, reduce distance/scale values and inspect clipping on parent containers. Centering the Preview does not change in-game bounds.

A gradient or glow looks wrong

Check effect order and remove competing color/style effects. Review the result against both Preview backgrounds. Use the gradient-stop editor for exact stop positions.

Animation does not play in game

Confirm that:

1. The text was applied from Animation Editor.
2. RichTextProClientRuntime exists under StarterPlayerScripts.
3. Its Engine ModuleScript exists.
4. The target and its GUI ancestors are enabled and visible.
5. A LocalScript has not paused the target.

Press Fix and reapply if the generated runtime or managed layer data was manually changed.

Sound does not play

Confirm the asset ID, experience permission, volume, delay and layer visibility. Test on the client in Play mode.

Audit reports many effects

Remove duplicate or competing effects first. Fix Safe Issues handles data RichText Pro can clean automatically; visual simplification remains a design decision.

Limitations and scope

Included

• Visual Basic and Animation text-layer authoring
• Multi-line layer layout inside one Roblox text target
• Native RichText formatting and 57 custom effects
• Live Preview, presets, settings, audit and repair tools
• Batch application to TextLabel, TextButton and TextBox objects
• Shared client runtime and manual playback API
• Migration of compatible older RichText Pro authoring data

Developer responsibilities

• Provide adequate UI bounds for motion, glow and multiline text.
• Test readability, wrapping and performance at target resolutions.
• Confirm audio permissions.
• Keep game-specific state and panel lifecycle logic in your own LocalScripts.
• Version places before large migrations or batch application.

Not provided

RichText Pro does not replace a localization pipeline, dialogue-state system, responsive UI layout, accessibility review or general-purpose animation framework. Use it to author and play the text treatment, and keep game-specific behavior in the surrounding UI code.