TrailEmitter

A Trail in Roblox is a streak of geometry between two Attachments. The plain Trail type in this plugin already handles that: you transform a Trail, the plugin pulses its Enabled flag for a parsed duration, and the streak draws while the underlying attachments move. One trail, on or off.

TrailEmitter is a different shape. It treats the source Trail as a template and emits clones of it on a Rate / EmitCount cycle, just like Part-emitter emits clones of a Part. Each cloned Trail is an independent particle with its own Lifetime, its own graph-driven width and colour over that lifetime, and its own flipbook animation if you set one up. Five clones at once produce five concurrent ribbons; a hundred per second produce a flowing dense stream.

That’s the difference: Trail is one streak you toggle. TrailEmitter is many streaks you spawn.

What it transforms

A native Trail instance — same starting point as the regular Trail type. The plugin checks whether you want direct-access (the plain Trail behaviour) or emitter (TrailEmitter) when you transform, via the Transform tool’s type selector.

After Transform, the source Trail becomes a TrailEmitter: it gets a RenderTemplate child (a hidden clone of the original Trail, disabled by default), a Configuration child with the property graphs, and a GraphBlender folder for the multi-state width/colour/transparency animation. Each emission clones the RenderTemplate, parents it under your EmitParent, runs through its TrailLife worth of animation, then destroys (or pools) the clone.

When to reach for TrailEmitter

The clone-per-emission model fits any case where you want multiple, overlapping, independently-animated trails:

• Sword swing slipstream. Each frame of a swing spawns a glowing slipstream trail that fades over half a second. With Rate around 30, you get a dense feathered streak with each individual ribbon dimming independently — much richer than a single trail.
• Spell projectile aura. A projectile drags a primary trail (plain Trail, on-from-launch) plus a TrailEmitter rig that spawns small spiral trails along the path. Each spiral animates from bright to dim, narrow to wide, then fades.
• Crowd-formation effects. A formation of particles where each particle leaves its own short-lived ribbon. The ribbons overlap, intersect, dim independently.
• Authoring with GraphBlender. Multi-state Color and Transparency animation along each cloned trail’s life — the same Blender model Beam uses, but on a Trail. Pulse from white-hot at birth to red-fade at half-life to deep-blue ghost at death. Each clone gets the full animation.

For a single fixed-duration streak (a sword’s idle gleam, a fixed laser line), plain Trail is still the right tool — TrailEmitter’s machinery is wasted on a single binary toggle.

Properties at a glance

The panel has more rows than plain Trail because every visual property is graph-driven over each particle’s life. Grouped by section.

Emission

Panel label	Data attribute	Type	Default	What it does
Enabled	Enabled (Configuration attr.)	boolean	false	Master gate for continuous emission
Rate	Rate	number	10	Particles per second
Lifetime	Lifetime	NumberRange	2	How long each emitted Trail-particle lives
TrailLife	TrailLife	NumberRange	2	How long each cloned Trail’s tail segments persist (separate from Lifetime)
EmitCount	EmitCount	number	0	One-shot burst count
EmitDelay	EmitDelay	number	0	Wait before first particle
EmitDuration	EmitDuration	number	0	Seconds of continuous loop after the initial bursts

Appearance (graph-driven over particle life)

Panel label	Data attribute	Type	Default	What it does
Brightness	Brightness	NumberSequence	1	Brightness over each particle’s life
LightEmission	LightEmission	NumberSequence	0	Self-illumination strength over life
LightInfluence	LightInfluence	NumberSequence	1	How much scene lighting affects the trail over life
MinLength	MinLength	NumberSequence	0.1	Minimum segment length over life
MaxLength	MaxLength	NumberSequence	0	Maximum trail length over life. 0 is unbounded
TextureLength	TextureLength	NumberSequence	1	How far one texture tile covers along the trail, over life

GraphBlender (multi-state Width / Color / Transparency)

Width, Color, and Transparency aren’t single graphs — they live in a GraphBlender folder of Configuration states, exactly like Beam’s GraphBlender (see also GraphBlender Math). Each state holds a Time (0 to 1 across the particle’s life), a Width graph, a Color sequence, and a Transparency graph. Add states via the panel’s + Add State button; the engine blends smoothly between adjacent states as each particle ages.

A typical authoring shape: state 0 at Time = 0 (Color cyan, Width 1, Transparency 0), state 1 at Time = 1 (Color purple, Width 0, Transparency 1). Each emitted trail fades from cyan-and-wide to purple-and-thin-and-gone over its own lifetime.

Flipbook

Panel label	Data attribute	Type	Default	What it does
Mode	TrailFlipbookMode	enum	OneShot	Frame sequence playback mode — OneShot or Loop
Framerate	TrailFlipbookFramerate	NumberRange	30	Frames per second
StartRandom	TrailFlipbookStartRandom	boolean	false	Start each particle on a random frame
Reverse	TrailFlipbookReverse	boolean	false	Play frame sequence backwards

Drop numbered Decal children into the source Trail to populate the flipbook (same shape as Beam/Part flipbooks, just attached to the Trail instance). See Mesh Flipbooks for the authoring pattern.

Advanced

Panel label	Data attribute	Type	Default	What it does
Timescale	Timescale	NumberSequence	1	Per-frame time scaling on the appearance graphs
Anim. Steps	TotalKeyFrames	number	100	Graph sample resolution per particle
Linger	PartLife	number	0	Seconds the trail persists past Lifetime end
Emit Into	EmitParent (ObjectValue)	instance	(source’s parent)	Where emitted Trails parent
Preload Texture	PreloadTexture	boolean	false	Force-load the texture before emit
Link	LinkSource	enum	None	Camera / Object / None link target
Link Mode	LinkMode	enum	Follow	How the link composes with emit position
Link Dir.	Link (ObjectValue)	instance	none	The picked link target

Per-property prose

TrailLife

How long each emitted Trail’s segments live before fading out. A NumberRange, sampled at emit per clone. Different from Lifetime — Lifetime is how long the emitted particle entity exists (and animates its graphs); TrailLife is how long each segment of the trail persists.

A Lifetime of 1 second with TrailLife of 0.5 means each emitted trail animates its property graphs over 1 second, but the segments it lays down only persist for half a second before fading. The visible wake is short; the animation cycle is long.

A Lifetime of 1 second with TrailLife of 3 seconds is the reverse: short emitter life, long-fading wake. Useful for puffs that bloom briefly then leave a slow-dissolving cloud.

Brightness

A NumberSequence graph for the cloned Trail’s Brightness over each particle’s life. Sampled per frame, applied as a multiplier on the Trail’s rendered intensity. A ramp from 2 at age 0 to 0.3 at age 1 produces a trail that flares hot at birth and dims as it ages.

Unlike plain Trail (where Brightness is a single number with no animation), TrailEmitter animates it frame-by-frame on each clone.

LightEmission

A NumberSequence graph for additive-blending strength. 0 is normal blending; 1 is fully self-illuminated. Animated over life — useful for trails that should look hottest at the moment of emission and cool toward death (start 1, end 0).

LightInfluence

A NumberSequence graph for how much scene lighting affects the trail. 0 ignores scene lighting (the trail self-lights regardless of environment); 1 follows scene lighting normally. The default of 1 is the realistic look; lower values for trails that should glow consistently through dark or shadowed areas.

MinLength

Minimum segment length, in studs, animated over life. Roblox draws Trail segments only when the attachments have moved at least MinLength since the last segment was placed. Larger values mean sparser geometry — a few long segments rather than many short ones.

A MinLength graph that ramps from 0.5 to 0 gives you a trail that starts sparse and fills in as it ages. Mostly useful for low-rate emitters where you want each individual trail’s geometry to feel intentional rather than dense.

MaxLength

Maximum total trail length, in studs, animated over life. 0 (the default) is unbounded — the trail draws as much geometry as it wants based on attachment motion. Positive values cap the visible length; older segments are dropped once the total length exceeds the cap.

A MaxLength ramp from 5 to 0 produces a trail that visibly shortens toward the head as it ages — old segments disappear from the back. Useful for “consuming” effects where the trail eats its own tail.

TextureLength

How far one texture tile covers along the trail, in studs, animated over life. Lower values produce denser, more compressed texture repeats; higher values stretch the texture longer.

Animating this graph over life lets you compress and stretch the texture as each particle ages — a quick way to produce wavy or breathing motion in the visible pattern without changing the underlying geometry.

Timescale

A NumberSequence graph that controls how fast each particle’s other graphs are sampled. A constant 1 is normal playback; 0.5 plays the appearance animation at half speed; 0 freezes the animation at whatever frame the particle is currently at; negative values rewind.

This is the same Timescale system used by other types (added in v37). For most authoring, leave it at constant 1; reach for it when you want one particle in a burst to play faster or slower than another, or when you want an animation to pause-and-resume mid-flight.

Render Template

When you Transform a Trail as an emitter, the plugin creates a RenderTemplate child — a clone of the source Trail with Enabled = false. On each emission, that template is duplicated (or fetched from the object pool, if pooling is on), Enabled = true, its Attachment0 / Attachment1 are preserved, and the duplicate is parented under your EmitParent. The duplicate runs through its Lifetime while the appearance graphs animate frame-by-frame, then the duplicate is destroyed (or returned to the pool) and the GraphBlender / property state is reset.

The template’s Texture, Attachment0, Attachment1, FaceCamera, and TextureMode carry over verbatim to each clone; the graph-driven properties (Brightness, LightEmission, etc.) are overwritten frame-by-frame during the particle’s life.

Worth knowing

A few TrailEmitter-specific quirks.

Two separate “duration” values. Lifetime is how long each particle lives and animates. TrailLife is how long each segment of that particle’s trail persists before fading. They’re independent — short Lifetime + long TrailLife produces a brief emit followed by a long-fading wake; vice versa for short bursts with short tails.

Pool is on by default. Emitted Trail clones are pooled and reused rather than destroyed and recreated. Better for high-rate emitters (avoids GC churn). Toggle off only if you’re seeing pool-related artefacts.

GraphBlender is the same as Beam’s. Width, Color, and Transparency live in a GraphBlender folder, same authoring model as transformed Beams. Multi-state interpolation across the particle’s life. If you’ve authored a Beam’s GraphBlender, the same patterns work here.

Attachment0 / Attachment1 are inherited from the source. Each cloned Trail uses the same attachments as the source. If those attachments move (e.g. they’re parented to a moving character), every concurrent clone follows. If you want independent geometry per clone, that’s outside TrailEmitter’s model — use a Part emitter with per-particle Attachment children instead.

Plain Trail still exists. This chapter is for TrailEmitter. The plain Trail type is still the right choice for static streaks you only need to toggle on and off. The Transform tool offers both options when you click Transform on a Trail; pick TrailEmitter when you need the particle-system shape.

What’s next

TrailEmitter is one of three new types added in v38. The other two are Highlight (covered earlier) and BeamNative — a sibling to Beam where the source stays as a native Roblox Beam instead of a fully-transformed emitter. BeamNative documentation lands in a future revision; for now the closest reference is the existing Beam chapter, which covers both the transformed-Beam emitter shape and the native-Beam direct-access path it overlaps with.