Resize

You’ve authored a particle effect that looks right at the scale you tested it. Then the level designer moves the spawn point onto a giant boss, and the effect looks tiny against its target. Or it’s used by a small NPC, and the effect overwhelms them.

You could re-author the effect at the new scale — re-edit every Size graph, every Speed range, every Acceleration value, every spawn-cone offset. That’s a lot of edits, and the relative proportions you carefully tuned are easy to lose.

Resize is the tool for this. One slider, scaled logarithmically from 0.5× to 2×, multiplies every spatial property in the selection by the same factor. The proportions you set stay intact; everything just scales together.

The slider

The slider runs from 0.5× (half size) to 2× (double size), centred at 1.0× (no change). It’s log-scaled — the slider position maps to the multiplier through a log-scaled curve, so the same physical slider movement produces the same proportional change whether you’re scaling up or down (0.5× to 1.0× is the same slider distance as 1.0× to 2.0×).

If you need a value outside the slider’s range — 0.1× for a major shrink, 5× for a giant blow-up — type the number directly into the text input next to the slider. The text input is unclamped; the slider just visualises the standard range.

Below the slider you’ll see two toggles:

• Include Descendants (default on) — if the selected item has child emitters (a Model with multiple transformed children, a Folder of emitters), they all scale together.
• Scale Spawn Area (default off) — also scales the source Part’s Size (the BasePart.Size Vector3, which controls spawn region for Box/Sphere/etc. shapes). Off by default because resizing the source Part is a different intent from resizing the emitted particles.

The Apply button commits the change and takes a fresh snapshot. The Reset button restores the original values from the snapshot taken when the panel opened.

What it scales

Resize scales every property the plugin classifies as spatial. The list per type:

Part:

• SizeX, SizeY, SizeZ graphs (multiplied per keypoint)
• Speed graph (Roblox’s Speed is a velocity in studs/sec — spatial)
• Acceleration Vector3 (each component multiplied)
• PosX, PosY, PosZ ranges (spawn region offsets)
• RotSpeedX/Y/Z — not scaled (rotation is angular, not spatial)

Attachment: Speed graph, Acceleration Vector3, PosX/PosY/PosZ ranges. Attachments don’t have their own size graphs (the visual is whatever child instances you put inside the RenderTemplate), so no per-axis size scaling.

Model: Speed graph, Scale graph (the uniform model-wide scaler), Acceleration Vector3, PosX/PosY/PosZ ranges. Per-axis size graphs don’t exist on Model — Scale cascades through Model:ScaleTo() instead.

PointLight:

• Range graph (the only spatial property — radius in studs)

Beam:

• Width0, Width1 graphs
• CurveSize0, CurveSize1 graphs
• Segments graph (yes — even though Segments is a count, the plugin scales it so longer beams keep their tessellation density proportional)
• TextureLength — divided by the factor (it’s “studs per texture tile,” so an inverse scale keeps the tile density visually consistent as the beam’s apparent length changes)

Trail:

• WidthScale graph
• MinLength, MaxLength, TextureLength, Lifetime — not scaled. The plugin’s resize on Trail is narrowly the WidthScale graph; everything else stays.

Native ParticleEmitter:

• Size NumberSequence
• Speed NumberRange
• Acceleration Vector3

ImageLabel:

• Position and Size UDim2s — both Scale and Offset components scale by the factor (so a particle’s pixel-size doubles, but its parent-relative scale also doubles, keeping the visual proportional in both layout modes)
• SizeScaleX, SizeScaleY graphs (the per-axis size multipliers animated over life)
• Speed graph (pixels per second)
• Acceleration Vector2

The principle is consistent: anything measured in studs (or pixels for UI), anything measured in studs/sec or pixels/sec, anything measured in studs/sec², gets scaled. Anything measured in degrees, seconds, particles-per-second, or counts is left alone. That’s what Retime is for.

How the snapshot model works

When you open Resize on a selection, the plugin takes a snapshot of every spatial property’s current value. The snapshot persists as long as the panel is open.

When you move the slider, the plugin computes new values from the snapshot × slider factor — not from the currently displayed values. This means moving the slider back to 1.0× always returns to the original, even if you’ve taken multiple intermediate positions.

Apply commits the new values and takes a fresh snapshot. The next slider movement is now relative to the post-apply state. Reset restores the snapshot — equivalent to the slider returning to 1.0× and discarding any preview changes.

This pattern is shared across Resize, Retime, and Hue — all three use snapshot-then-preview-then-apply. It means previewing is non-destructive: you can drag the slider, see the result live, and discard if it’s wrong. Only Apply commits.

Performance notes

The preview update is throttled to roughly 100 ms between writes. Large selections (a few hundred emitters with many graph properties each) can take a noticeable fraction of a second per preview update — the throttle is there to keep the slider responsive while heavy snapshots are being applied.

For very large selections, the slider may feel laggy. Consider applying in stages: select a smaller subset, resize, apply, then move to the next subset.

When to reach for Resize vs editing manually

Reach for Resize when:

• The relative proportions of the effect should stay intact — Sizes, Speeds, Acceleration all need to scale together.
• The change is roughly proportional — a single multiplier captures it.
• You want a non-destructive preview before committing.

Manual editing is the right approach when:

• You need different scaling per property (Speed up but Size unchanged, for example).
• The change is qualitative, not just quantitative — adding new keypoints, changing graph shapes.
• The spatial relationships should change (a fountain that grows wider but stays the same height needs SizeX to scale while SizeY doesn’t).

For the second and third cases, edit the properties directly in the panel and skip Resize.

What’s next

Where Resize handles spatial scaling, Retime handles temporal scaling — same slider model, same snapshot pattern, but focused on lifetimes, rates, and emission speeds rather than sizes and distances.