Text

Creates a typographic layout object with font, size, alignment, and wrapping. Outputs TextData for rendering or conversion to shapes.

Category: Text Menu path: Text > Text

Ports

Port	Type	Direction	Description
content_in	string	input	Overrides the literal text param when connected. Chain a String or MergeText node here to drive the content from elsewhere (animated captions, AI prompts, etc).
out	text	output	TextData carrying content, font params, and computed glyph layout
width	scalar	output	Computed text bounding width in pixels
height	scalar	output	Computed text bounding height in pixels
lineCount	scalar	output	Number of lines in the layout

Parameters

Param	Type	Default	Description
text	string	Hello	Text content (supports multi-line). Keyframeable with Hold interpolation — animate caption swaps directly on the node, or pipe in a String at content_in to drive from elsewhere.
fontFamily	string	Helvetica Neue	System font family
fontWeight	enum	Regular	Thin, ExtraLight, Light, Regular, Medium, SemiBold, Bold, ExtraBold, Black. Hidden when a variable font's Weight axis takes over (see Variable fonts below)
fontStyle	enum	Normal	Normal or Italic
axis_<tag>	scalar	axis default	Variable fonts only — one keyframeable slider per design axis (see Variable fonts below)
fontSize	scalar	72	Font size in pixels
tracking	scalar	0	Letter spacing adjustment in font units
lineHeight	scalar	1.2	Line height multiplier
alignment	enum	Center	Left, Center, or Right
wrapping	enum	None	None (point text) or WordWrap (box text)
boxWidth	scalar	0	Text box width (0 = no box constraint)
boxHeight	scalar	0	Text box height (0 = no box constraint)
textTransform	enum	None	Case transform: None, Uppercase, Lowercase, or Title. Applied before shaping, so ligatures and kerning see the final letters — the content you typed is untouched
featKern	boolean	on	Kerning
featLiga	boolean	on	Standard ligatures (fi, fl, …)
featCalt	boolean	on	Contextual alternates
featDlig	boolean	off	Discretionary ligatures
featSalt	boolean	off	Stylistic alternates
featSmcp	boolean	off	Small caps
featFrac	boolean	off	Fractions (1/2 → ½-style forms)
featOnum	boolean	off	Oldstyle figures
featTnum	boolean	off	Tabular figures (fixed-width digits — great for counters)
featSs01–featSs08	boolean	off	Stylistic sets 1–8 (only shown for fonts that declare them)

Variable fonts

When the selected family is a variable font, its design axes appear as regular keyframeable scalar params in the Typography section — Weight (wght), Width (wdth), Slant (slnt), Optical Size (opsz), and any custom axes the font declares. The named-weight dropdown hides when a Weight axis is present (the axis is the weight control).

• Values are clamped to the font's declared range; out-of-range keyframes render at the boundary.
• Axes are continuous: keyframe Weight from 100 to 900 for a smooth thin-to-black animation — shaping, kerning, and outlines all track the axis per frame.
• Switching to another variable font keeps matching axes (values clamp to the new range); axes the new font lacks are removed.
• Static fonts are unchanged — they keep the named-weight dropdown.

OpenType features & case

The OpenType section in Properties exposes the font's typographic features as toggles. Kerning, standard ligatures, and contextual alternates are on by default (matching the shaper's defaults); small caps, discretionary ligatures, stylistic alternates, fractions, oldstyle/tabular figures, and stylistic sets are opt-in. The panel only lists features the current font actually declares — pick a different family and the section updates.

• Tabular figures are the counter/timer feature: every digit gets the same width, so numbers driven through content_in stop jittering.
• Case (Typography section) transforms the rendered text to UPPERCASE, lowercase, or Title Case before shaping — ligatures and kerning apply to the final letters, while the text you typed (and everything addressing it: editing, per-range styles, TextAnimate) stays untouched.

Rich text (per-range styling)

Mix weights, sizes, and colors inside one Text node. In the viewport, enter text edit mode (double-click the text or press T on it), select a range of characters, and a style bar appears above the comp:

• Weight — restyle just the selection. Static fonts get the named-weight dropdown; variable fonts get a numeric weight field driving the wght axis
• Size — per-range font size; lines with mixed sizes grow their line height to fit the largest run
• Baseline shift (A⇅) — raise or lower just the selection (px, positive = up). Ink-only: line spacing and wrapping are unaffected
• Small caps (Tᴛ) — toggle the font's small-caps forms for the selection. Only appears for fonts that provide them
• Color — with the whole text selected, this IS Draw Text's Fill Color (the bar writes the painter's param directly). A sub-range selection gives just those characters their own color (survives TextAnimate reveals and blurs; flows through TextToShape as per-path color attributes)
• Reset — return the selection to the node's base style

Every number in the bar scrubs like a Properties field: drag horizontally to adjust (Shift = ×10, Alt = ×0.1, Escape cancels the drag), or click to type.

Selecting the whole text edits the base style, not an override. Weight and size changes with everything selected (the state you're in right after entering edit mode) write the node's own params, and color writes the downstream Draw Text's Fill Color — so the Properties controls (including a variable font's Weight axis slider) stay live instead of being silently masked by a full-length override. Sub-range selections create overrides as usual.

Overrides are always visible. The Text node's Details tab lists every styled range — the affected text, a color swatch, and which properties it overrides — alongside the node's other attributes, with a one-click Clear and a keyframe diamond. Because the styles travel inside the TextData, the same section appears (read-only, with attribution) on the Details tab of every downstream consumer — TextAnimate, Text Along Path, Draw Text — so you can see what's flowing in wherever you're looking. And if any range carries its own color, Draw Text additionally shows a note on its Parameters panel explaining that Fill Color paints the remaining characters, with its own Clear.

Keyframing character styles. Base styling animates through regular params (weight axis, size, Draw Text's fill — all keyframeable and smoothly tweened). Per-range styles animate as hold keyframes on the whole run set — same stepped model as keyframed text content. The diamond in the Details tab's Character Styles section keyframes the current styles at the playhead; once keyframed, style-bar edits write to the keyframe at the current frame. Runs can't tween (ranges appear and disappear) — for smoothly animated per-glyph styling, use TextAnimate. When keyframing both content and styles (captions), set them together at each keyframe: style ranges are byte ranges into that frame's text.

Styles stick to the text as you edit: typing inside a styled word keeps its style, and ranges shift correctly as text is inserted or deleted before them. Under the hood these are style runs on the node's internal runs param — overrides layered on the base style, not a separate document model. Kerning does not apply across a style boundary (standard rich-text behavior).

When content_in drives the text from another node, runs are ignored (byte ranges can't be trusted against arbitrary upstream strings) — the base style applies.

Fonts that travel

Font files placed in the project folder's fonts/ subdirectory are loaded automatically when the project opens (in addition to system fonts). Handing the project folder to someone else — or opening it on another machine — renders with the same typefaces, no installation step.

Expose Channels

When enabled (E button on node header), adds input ports that override params via edge connections:

Port	Type	Overrides
fontSize_in	scalar	fontSize
tracking_in	scalar	tracking
lineHeight_in	scalar	lineHeight
boxSize_in	vec2	boxWidth and boxHeight

How It Works

The Text node computes a full typographic layout using the engine's font stack (fontdb for enumeration, ttf-parser for parsing, rustybuzz for OpenType shaping). The output TextData carries both the input parameters and the computed glyph positions, cluster information, and line metrics.

Point text (wrapping: None): Text flows on a single line (or multiple lines from explicit line breaks). No width constraint.

Box text (wrapping: WordWrap, boxWidth > 0): Text wraps within the specified box dimensions. Layout is centered within the box when both boxWidth and boxHeight are set.

The Text node does not render pixels -- it produces layout data. Connect to DrawText for rasterization, TextAnimate for per-glyph animation, or TextToShape for outline conversion.

The scalar outputs (width, height, lineCount) are useful for driving other parameters. For example, feed width into a Rectangle node to create a background that auto-sizes to the text.

Usage Examples

Basic: Rendered text

Text (text: "Hello World", fontSize: 96) -> DrawText -> Transform2D -> Output. Standard text rendering pipeline.

Animated text reveal

Text -> TextAnimate (progress: keyframed 0 to 1) -> DrawText -> Transform2D -> Output. Characters animate in one by one.

Auto-sized background

Text -> DrawText -> Transform2D -> Output. Also: Text.width and Text.height -> Math nodes (with padding) -> Rectangle (width/height driven) -> DrawShape -> Transform2D -> Output on a layer below.

Text as geometry

Text -> TextToShape -> ShapeAttributes (Color from Gradient.colorField) -> DrawShape -> Transform2D -> Output. Text outlines filled with a gradient.

Tips

• Use the Text tool (T key) to create text interactively -- click for point text, drag for box text
• Double-click a text layer to enter text editing mode with caret and selection
• The font picker in Properties offers searchable font families with CSS preview
• Safety clamping prevents NaN/Inf from extreme parameter values
• The text port type is distinct -- it cannot connect directly to image or shape ports

Related Nodes

• DrawText -- rasterizes TextData to a texture
• TextAnimate -- per-glyph geometric animation
• TextToShape -- converts glyph outlines to shape data
• DrawAscii -- ASCII art rendering (different approach to text)