Renderable

Spawn a primitive part. shape is "Cube" (default) or "Sphere".

Spawn a part backed by a ModelAsset (loaded via Asset.GetAsset("Model", ...)). Inherits the asset's animation clips.

Polygon reduction by quantization clustering. ratio is a 0..1 hint (default 0.5 ≈ half the vertices). The returned LOD inherits the source's animation clips. The ModelAsset has no path (it was generated, not loaded), so free it with lod:Free() rather than Asset.Drop.

Define a region inside a part's mesh that you can move, rotate, or resize to deform whatever vertices fall within it. See DistortionBox.

Force-spawn n particles right now (default 1), ignoring Rate. Still bounded by MaxParticles.

Kill every alive particle immediately.

Particle shaders use a 2D-style WGSL contract (the same kind of shader you'd attach to a GUI primitive), not the 3D BasePart contract. Particles are always rendered as flat textured quads, so a 2D fragment shader is the natural fit. See Particle shaders below for the binding layout and the input VsOut you have access to.

Current centre + rotation in part-local space. Writable. Setting it transforms captured vertices on the next tick.

Current full extent on each axis. Writable. Scales captured vertices along the box's local axes.

The box's CFrame at creation. The reference frame for captured vertex offsets. An identity transform (CFrame == InitialCFrame and Size == InitialSize) leaves vertices untouched.

Number of vertices the box captured at creation. If this is 0 the box was placed where no mesh geometry lives; check your CFrame / Size against the model's actual extents.

False after :Destroy(). The box still applies its last transform every tick, but won't accept further mutations.

Freeze the box. Captured vertices stay at their current displaced positions; subsequent property writes are ignored. Mesh is not restored — recreate a fresh box at InitialCFrame / InitialSize if you need to undo the distortion.

Geometry kind. "Cube" / "Sphere" use a built-in mesh; "Model" means the part was created via Renderable.BaseModel(asset).

World pose. Writable.

Object-space scale, in world units.

Albedo when no Texture is set; tint multiplier when one is.

Set false to keep the part in the scene graph but skip drawing it.

Optional surface texture. Uses .Color as a tint.

Render hints surfaced to user shaders as I.cast_shadow / I.receive_shadow (u32 0/1). Defaults: both true.

GPU.Raycast skips this part. Default false.

Fires with the property name on every mutation: "CFrame", "Size", "Color", "Render", "Texture", "CastShadow", "ReceiveShadow", "IgnoreInRaycast", or "Destroyed".

Per-property change signal. Fires with the new value as its only argument every time propName is set — "CFrame" fires with a CFrame, "Color" with a Color3, "Render" / "CastShadow" / "ReceiveShadow" / "IgnoreInRaycast" with booleans, etc. Lazily created: properties no one listens to cost zero. When the last connection disconnects, per-tick firing stops entirely.

For parts wrapped by PhysicsService, the "CFrame" signal also fires each frame the simulation moves the part — same lazy listener-count gating, so unobserved physics objects don't pay any Lua-side cost per tick. (BasePart only exposes .CFrame, not separate Position or Rotation — if you want to react to one axis of motion, decompose cf.Position / cf.Rotation inside your handler.)

part:GetPropertyChanged("CFrame"):Connect(function(cf)
    print("moved to", cf.Position)
end)

Remove from the scene. Connections to Changed still receive one final "Destroyed" fire.

Attach a ShaderAsset or FragmentAsset. See Shaders for the WGSL contract.

Remove a previously-attached shader. Looks up by asset id; no-op if the shader isn't attached.

Detach every shader on this part.

Set a // @ruzit param slot on an attached shader to a number.

Read a // @ruzit param slot. Returns nil if the shader isn't attached or the name isn't declared.

Push every vertex within envelope units of target.Position by displacement * smoothstep(distance / envelope). Smooth radial falloff; per-Part copy of the mesh, so deforming one Part doesn't affect others sharing the same source asset. Returns the number of vertices touched.

Drop the per-Part vertex override and snap back to the source mesh.

Convert an offset in the part's local frame to a world-space position. Vector.new(0, 3, 0) returns the world point 3 units along the part's rotated local Y axis. Useful for placing emitters, nameplates, and child anchors relative to a moving / rotating part.

Inverse of LocalToWorld. Convert a world- space position into the part's local frame.

Bind an Animation (pulled from an AnimationSet via set:GetAnimation(name)) to this part and return a playable AnimationTrack. The same Animation can be bound to many parts — keyframes are shared, but each track has its own playback cursor / Play / Stop state.

local anims = Asset.GetAsset("AnimationSet", "chars.hero_anims")
local walk  = anims:GetAnimation("Walk")

local track = hero:GetAnimatedTrack(walk)
track.Looped = true
track:Play()

Every track currently bound to this part (each one came from a prior :GetAnimatedTrack call).

Non-functional as of 1.2.8. Calling it raises a runtime error. Models no longer carry their own animations — load an AnimationSet and bind with part:GetAnimatedTrack(animation).

Anchor an SFX Sound or VoiceChannel to this part. While linked, the engine copies the part's CFrame.Position into the audio's Position property each heart tick, so the sound follows the part automatically. Saves you from doing the per-frame copy in Lua.

For SFX: the link writes snd.Position, preserving MinFalloff / MaxFalloff. If the sound had no Position, defaults 0 / 20 are installed on first sync. For VoiceChannel: writes the channel's Spatial shader the same way (defaults 0 / 8). Linking the same audio source again replaces the previous binding.

Destroying the part automatically drops the link. The audio keeps its last-synced position frozen.

local snd = SFX.LoadSound(boom_data)
snd.MaxFalloff = 50
projectile:LinkInput(snd)
snd:Play()  -- audio now follows `projectile` in 3D

Remove an earlier LinkInput binding. The audio's Position stops being driven by the part and stays wherever it was on the last synced tick. Use audio.Position = nil after to revert to non-positional playback.

Cross-fade duration in seconds when blending into / out of this track. Currently informational, full blending is future work.

When true and the playhead reaches Length, time wraps to 0 and the part is restored to the captured baseline before replaying.

Time multiplier. 1.0 = normal speed; -1 reverses.

Conflict-resolution weight when multiple tracks are playing on the same part. Higher wins; default is 0. Tracks on different parts never conflict — each part runs its own priority gate.

• Lower priority → output suppressed. A walk loop at Priority = 0 will keep ticking (its clock advances, signals still fire) while a shoot animation at Priority = 1 drives the visual output. When the shoot ends, walk's output takes over automatically — no manual stop / play needed.
• Equal priority → merged. Two tracks tied at the current max contribute together: CFrame samples are averaged; vertex deformations are summed as displacements relative to the base mesh. So overlapping rig animations stack instead of fighting.

local walk  = char:GetAnimatedTrack(walkAnim);  walk.Looped  = true
local shoot = char:GetAnimatedTrack(shootAnim)
shoot.Priority = 1   -- one-shot shoot pose overrides walk while playing

walk:Play()
shoot:Play()    -- you see the shoot pose, but walk keeps its clock

Current playhead. Writable to scrub.

Fires when :Play() is called and the track starts feeding samples.

Fires when the track stops, either naturally at the end (when Looped is false) or because :Stop() was called.

Fires every time a looped track wraps from end to start. Only fires when Looped is true.

Capture a fresh baseline (so Reset has somewhere to restore to) and start ticking. Calling on a paused track resets and restarts; use Resume() to continue from a pause.

Like Pause, but rewinds to time 0. The visible pose is left in place, call Reset to snap back to baseline.

Restore the captured baseline (CFrame + mesh) and rewind.

Author a keyframe. kind is "CFrame" (followed by the target CFrame) or "Deform" (followed by cframe, envelope, displacement).

Returns a Signal that fires every interval track-time seconds with the elapsed playback time. Useful for syncing footstep sounds, particle bursts, or gameplay events to specific moments in an animation. Mirrors Sound:LinkToUpdate.