Primitives

Construct a new vector. Each argument is optional; omitted axes default to 0.

Vector.new(1, 2, 3)
Vector.new(5)             -- (5, 0, 0)
Vector.new()              -- (0, 0, 0)

Shorthand for Vector.new(0, 0, 0).

Shorthand for Vector.new(1, 1, 1).

Convert a Luau native vector (the built-in primitive returned by vector(x, y, z) and the vector.* library) into a Ruzit Vector userdata. Useful when you've got a native vector from a math helper or external module and need it in the form Ruzit's APIs (BasePart.Size, CFrame.new, etc.) accept.

Vector.FromNative(vector(1, 2, 3))
-- -> Vector(1, 2, 3)

Right-axis component.

Up-axis component.

Forward-axis component (toward the camera in the engine's right-handed convention).

Cached Euclidean length, sqrt(X² + Y² + Z²). Computed once at construction; reads are free.

Linear interpolation. t = 0 returns self, t = 1 returns other. Values outside [0, 1] extrapolate.

Dot product. Positive when the vectors face roughly the same direction, negative when opposite, zero when perpendicular.

Right-handed cross product, perpendicular to both inputs.

Returns a unit-length copy. If the magnitude is effectively zero the original is returned (rather than NaN-ing).

Euclidean distance between two points. Equivalent to (v - other).Magnitude.

Convert to a Luau native vector. Use this in hot paths where you're reading components repeatedly — native vector reads happen inside the VM without crossing into Rust, which is roughly 5-10× faster than reading v.X / v.Y / v.Z on a userdata per access.

local nat = part.Size:ToNative()
-- nat.x, nat.y, nat.z are pure Lua reads from here on,
-- and you can pass `nat` back into any API that takes a Vector.

Component-wise addition.

Component-wise subtraction.

Scalar multiply. The scalar must be a number.

Scalar divide.

Negation. Equivalent to v * -1.

Component-wise comparisons (true only when ALL THREE axes match). Note < is partial-order, not magnitude-based — for length comparisons read .Magnitude directly.

Linear 0 .. 1 channels. Out-of-range values are clamped.

Color3.new(0.18, 0.55, 0.28)  -- forest green

8-bit (0 .. 255) channels. Convenient for colors copied from a paint program. Internally divides by 255. Color3.fromRGB is an alias.

Color3.FromRGB(46, 140, 71)

CSS-style hex literal. Accepts "#RRGGBB", "RRGGBB", "#RGB" (each digit doubled), or "RGB". Throws on bad lengths or non-hex characters. Color3.fromHex is an alias.

Color3.FromHex("#2e8c47")
Color3.FromHex("ff0")        -- expands to "ffff00"

Red channel, 0 .. 1.

Green channel, 0 .. 1.

Blue channel, 0 .. 1.

Component-wise interpolation. Useful for fades and day/night cycles.

Channel-wise add. Result is clamped to 0 .. 1.

Channel-wise subtract. Clamped at 0.

Component-wise comparisons (true only when ALL THREE channels match the relation).

Construct from a position Vector and (optional) rotation Vector. Both arguments are optional; either defaults to zero.

CFrame.new(Vector.new(0, 5, 0))
CFrame.new(Vector.new(), Vector.new(0, math.pi, 0))

Rotation-only CFrame from three Euler angles in radians. Equivalent to CFrame.new(Vector.new(), Vector.new(rx, ry, rz)) but reads more clearly at the call site.

CFrame.Angles(0, math.pi / 4, 0)   -- 45° yaw

Build a CFrame at eye oriented so its forward axis points at target. up defaults to Vector.new(0, 1, 0). The returned rotation is in Euler form, ready to drop into a part's CFrame or a camera.

-- Camera looks from (5, 5, 10) at the origin.
camera.CFrame = CFrame.LookAt(
    Vector.new(5, 5, 10),
    Vector.new(0, 0, 0)
)

World-space position.

Euler-angle orientation, radians. X is pitch, Y is yaw, Z is roll.

Position lerps linearly; rotation lerps component-wise. Adequate for short-arc animations, use spherical interpolation if you need a full half-turn between keyframes.

Compose poses. parent * child gives the child's world transform when the child is described in the parent's local space.

Transforms a point from the CFrame's local space into world space.

Component-wise add / subtract. Position and rotation each blend independently.

true if every component (3 position + 3 rotation) is within epsilon of the matching component on other. Default epsilon is 1e-5. Prefer this over == for "is the part roughly at this pose?" checks — direct equality on floats is brittle.

Caveat: rotation is compared as raw Euler radians, not angular distance, so two visually identical rotations differing by a multiple of 2π will not FuzzyEq. Wrap your bounds yourself if that matters.

-- Snap an animated part once it's settled near the target pose.
if part.CFrame:FuzzyEq(targetCF, 0.01) then
    part.CFrame = targetCF
    stop_animating()
end

Construct a 2D component.

Dim.new(800, 600)

Horizontal component.

Vertical component (down-positive).

Linear interpolation, same shape as Vector.

Rescale this Dim from one reference size to another. Designed for prebuilt UI: lay your panels out against a fixed reference (say Dim.new(400, 400)) at design time, then at runtime call :Scale(reference, Window.GetSize()) to map them onto the actual window.

• reference — the design-time size the dim was authored against.
• target — the runtime size to map into (e.g. Window.GetSize()).
• maintainRatio — when true, both axes use the smaller of the two scale factors so the aspect ratio is preserved (good for letter-boxed UI). Default false.

Component-wise add / subtract.

Scalar multiply / divide / negate.

Component-wise comparisons (true only when BOTH axes match the relation).

Both arguments default to 0.

Shorthand for UDim.new(0, 0).

Shorthand for UDim.new(1, 1) — full size of the parent.

One-shot scale-to-pixels. Equivalent to UDim.new(scaleX, scaleY):ToDim(parent) but reads more naturally when the scale values are constants. Use it for sizing a button or tile to a fraction of a container without first constructing a UDim value.

-- 20% × 20% of the parent.
btn.Size = UDim.FromDim(0.2, 0.2, parentSize)

Resolve to absolute pixels by multiplying each axis by the corresponding component of parent.

UDim.new(0.5, 0.25):ToDim(Dim.new(800, 600))
-- -> Dim(400, 150)

Component-wise addition / subtraction (combine offsets).

Scalar arithmetic and negation.

Component-wise comparisons (true only when BOTH axes match).