RobloxForge

RobloxForge health: Studio bridge, connected Studio instances, Rojo, repo state.

Use to discover standalone Studio Instances and role-suffixed temporary Instances nested within multiplayer groups.

Health of the Studio bridge: connected Studio instances and the round-trip time of a trivial eval on each peer that is up.

Use when you need the current place's identity or settings.

Use to recover a retained Studio operation outcome after a timeout.

Use to read official Roblox engine or Luau references.

Use to read installed Roblox Studio Assistant skills.

Use to manage Studio processes or list place revisions.

Use to list, inspect, create, or update developer products and game passes.

What is going on in this Studio: open script tabs, the selection, undo/redo availability, the last output lines, and Team Create collaborators when the place is in Team Create.

Which Studio and place this session is talking to: place id/name, game id, the connected instance ids.

Add a CollectionService tag.

Check an instance's attributes against a schema {key: {type, required, min, max, oneOf}}.

Set several attributes on one instance: attributes = {name: value} (types inferred).

Deep-copy an instance to a new parent.

Physics collision groups: op=list (groups + collision matrix), create, remove, rename, set_collidable (name, other, collidable), assign (paths -> group, BaseParts and every BasePart inside a Model).

Diff two instances property by property (useful when a duplicate behaves differently).

Create an instance (any creatable class), optionally with properties.

Remove an attribute.

Delete an instance (undoable).

Snapshot two subtrees (properties of every node down to maxDepth) and report what differs: nodes only in A, only in B, and changed properties.

Use to inspect every attribute on one instance.

Reflection for a class: superclass, every property (type, writable, category), methods and events -- the engine's own API, without docs.

All descendants of an instance with depth, optionally filtered by class (IsA).

Instance hierarchy as a nested tree (name, class, children) from a root.

Children of an instance with their classes.

Use to inspect an instance's current properties.

Use to inspect a DataModel subtree and its hierarchy.

The objects currently selected in Studio.

List the DataModel's services with their child counts, or the children of one service.

Every instance carrying a tag.

CollectionService tags on an instance.

Get or create a service by class name (e.g.

Create many instances in one call: objects = [{className, parent, name, properties}].

Several smart_duplicate operations in one call: duplications = [{instancePath, count, options}].

Read the same property from many instances.

Set the same property on many instances.

Redo the last undone change in Studio.

Remove a CollectionService tag.

Move an instance to a new parent (keeps its identity, unlike delete + create).

Find instances whose property equals a value (compared after conversion to JSON).

Search instances by name, by class, or by script CONTENT (plain substring).

Use to find instances by name, class, or property value.

Use to get, set, or frame selection.

Set an attribute.

Set a property on many instances from an arithmetic formula.

Use to update several properties on one instance in a single call.

Set one property; the value is converted to the property's real type (see the value formats).

Change a property relative to its current value on many instances: add, subtract, multiply or divide by a number or a per-component vector (Position +[0,5,0], Transparency *0.5...).

Duplicate an instance N times with a name pattern ('{n}'), a cumulative position/rotation offset, cycling property variations and target parents.

Undo the last change in Studio (ChangeHistoryService).

Use to remove a known inclusive line range from one script.

Use for an exact, localized replacement in one script.

Use for custom Studio traversal, edits, or peer execution.

Run a .luau / .lua file from disk in Studio (edit, server or client).

Use to preview or apply one replacement across scripts.

Use to read all or part of a script's source.

Use to search script sources.

Use to add source after a known line in one script.

Every script under a root (default the whole place): path, class, line count, enabled, RunContext.

Syntax/lint-check a Luau snippet with selene (repo config) without touching Studio -- run it before sending code to an eval, since Studio pauses on any eval error.

Search the place's handoff/notes files (HANDOFF, MapGeneratorNotes, LIMINAL_AMBIENCE_HANDOFF, AUDIO_REQUISITION) for prior attempts, rejected ideas and traps before building something.

Compare every script in Studio against the Rojo files on disk (length + Adler-32)

Run selene on the Rojo repo (or given paths) from the repo root and summarise: errors in full, warnings grouped by rule.

Is `rojo serve` running for the repo? With start=true, start it detached (Studio's Rojo plugin still has to press Connect).

Studio script editor tabs: action=list (open documents), read (the editor's text, unsaved edits included), open (open a script, optionally at a line), edit (apply {old, new} replacements through the editor, so it is undoable and...

Use only when replacing a script's entire source.

Write the place's scripts to disk as a Rojo-layout folder tree (Script .server.lua, LocalScript .client.lua, ModuleScript .lua; a script with script children becomes a folder with init) plus manifest.json, so git, ripgrep and any...

Send edited files from a source_pull folder back into the place.

Pull the scripts into a git repository and commit them -- the history a place file cannot keep (diff, blame, revert)

Use to trace script execution with breakpoints or logpoints.

Record every Touched contact on the BaseParts under an instance for 1-15 s during a playtest: which part hit what, when and where.

Record changes on an instance for 1-15 s: property changes (all, or the listed ones), children added/removed, attribute changes -- a timeline of what touched it.

Use to run Luau in a live client VM with its require cache.

Use to run Luau in the live server VM with its require cache.

Read the place's SelfTest verdict (workspace.SelfTestOut) from a running playtest server.

Use to inspect device simulation or list device presets.

Studio's output history (LogService), in edit or play.

Output captured since start_playtest (or since the last poll), plus whether a test is running.

Use to read merged logs for one Instance or separate Instance logs for a MultiplayerGroup.

Use to inspect current network and device simulation.

What Studio is doing: edit, or a playtest (play / run, solo or multiplayer).

Use to run or inspect a multi-client Studio playtest.

Use to clear network and device simulation state.

Start a playtest, run Luau on the server (or a client), collect what it returned and printed, and stop the test again (unless keep=true)

Run the place's tests in a playtest and summarise pass/fail.

Use to manage device simulation in edit or a playtest client.

Use to simulate client latency, jitter, or packet loss.

Use to send key presses or text to a live playtest client.

Use to click the live playtest viewport at known pixel coordinates.

Use to start, stop, or inspect a single-player Studio playtest.

Start a playtest and begin capturing its output (print/warn/error)

Stop the playtest and return everything it printed since start_playtest.

What 3D object is under a viewport pixel (raycast from the camera)

Poll a Luau condition until it is true (or time runs out)

Top-down floor plan of the world around a point (default: the first player) as an image: walls/pillars light, floors dim, furniture in its own colour, players in red with facing.

Numeric visual-pass audit of a built model in Studio: z-fighting faces, floating groups, hidden parts, hover/sink against the ground.

Build a Model in Studio from a part list (validated first), then run the numeric audit on it.

Export a Model/BasePart as a part list (pivot space) -- feed it to parts_render / parts_audit, edit it, or rebuild it with model_build.

Seat a model by its lowest TRUE corner onto the surface below it (raycast) or onto floor_y.

Real Studio screenshots of a model from several angles, framed automatically, returned as one labelled contact sheet.

Offline z-fight / floating audit of a part list before it is built (no Studio needed).

Render a part list offline as flat-shaded orthographic views (front/back/left/right/top/iso) -- see a model before it exists, or without Studio.

Which GUI objects are under a viewport pixel on the playtest client (top-most first) -- debug 'why does my click not land'.

Live UI audit in Studio on the real layout: OVERFLOW, TINY text, CONTRAST (WCAG vs the actual backdrop), NOBACKDROP, OFFSCREEN, CLIPPED, OVERLAP, TOUCH targets, FIXED pixel layouts, INVISIBLE buttons, plus a census of colours /...

Build a UI spec in Studio (validated against a whitelist checked against the live engine, so it cannot throw)

Click a GUI button BY PATH on the playtest client (finds its centre, clicks it)

Click the first visible button whose text contains a phrase (case-insensitive, plain text) on the playtest client -- e.g.

Turn a UI spec (or an existing GUI exported from Studio) into a standalone Luau file: build() plus a runtime that animates every control (hover/press, focus rings, toggles, draggable sliders, tabs, click-away dismiss, fade+scale...

The UI component library: list every component with its parameters, or expand one into plain spec nodes to see/modify exactly what it builds.

Delete a GUI (e.g.

Visual regression: compare two images (renders, previews, screenshots saved with save_to)

Export an existing GUI from Studio as a spec (only properties that differ from defaults) -- to restyle it, render it offline, audit it, or codegen it.

Real Studio screenshots of a GUI across device sizes (device simulator), optionally isolated from every other ScreenGui, as one contact sheet.

Render a UI spec OFFLINE (no Studio) at one or more screen sizes, with an automatic audit: text overflow, contrast, off-screen, clipping, overlaps, small tap targets.

Scan the Rojo repo's Luau for hard-coded UI style: colours (with near-duplicate clusters to merge into tokens), text sizes, fonts, corner radii, and which files hard-code the most -- the map for moving a game onto one theme.

Complete, responsive screens to start from: dialog, hud, inventory, leaderboard, loading, notifications, pause_menu, results, settings, shop, title_menu.

Design tokens: list presets, show one, check its contrast (WCAG), or save a custom theme (inline dict, may 'extends' a preset).

Compact outline of a GUI: class, name, absolute rect, hidden/disabled, text.

Type into a TextBox by path on the playtest client: clicks it to focus, then types the text (and Enter with submit=true).

Walk the local character to a position or instance with PathfindingService (waypoints, jumps), in a running playtest.

Bring the Roblox Studio window to the front (restoring it if minimised) so keyboard/mouse input reaches the game.

Walk the player to a point (or an instance) with real keys and mouse: faces the clearest heading toward the target (ray fan), walks/sprints in short legs, jumps or strafes when stuck.

Interact like a player: optionally face a target (instance path or point) first, then press the interact key (E by default).

Press keys like a player: a list of steps run in order.

Turn the player's view with the REAL mouse (OS-level, only while Studio is in front)

One call to see the game as the player does: a screenshot plus play_state.

Start a solo playtest and get into the game: waits for the client and character, focuses Studio, and clicks the title-screen button whose text contains `click_text` (default 'play'; '' to skip).

What the player is doing and what they can reach: position, speed, health, camera yaw/pitch, mouse mode, what the crosshair is on, nearby doors / slits / card rooms / prompts / loot / grabbables, and the player's and character's...

Stop the running playtest.

Several screenshots in a row as one contact sheet -- check an animation, a transition, a flicker or motion.

Author a KeyframeSequence from JSON against a rig's joint tree and save it (ServerStorage.ForgeAnimations by default); it is registered at once so anim_sample / anim_filmstrip / anim_trace can play it with no upload.

Render an animation as a filmstrip WITHOUT Studio rendering: the rig is sampled at N evenly spaced times and every pose is drawn offline (perspective, a floor at the rest foot level), one row per view.

Summarise an animation clip: length, loop, priority, keyframe times, which parts it poses and how often, and its markers.

Rig utilities for animation work.

Pose a rig at given times of an animation (no playtest needed -- a clone is stepped with Animator:StepAnimations in edit mode) and return every part's CFrame relative to the rig's root, plus joint Transforms in degrees.

Check a motion numerically: parts going through the floor (below the rest foot level), joints that POP (one step much faster than the rest of the clip), a loop whose last pose does not meet its first, and limbs passing through...

AnimationTracks playing on a Humanoid / AnimationController.

Build a KeyframeSequence from inline data under parentPath (flat form: keyframes = [{time, poses: {PartName: {cframe}}}]; poses are not nested -- use anim_build for a rig-aware sequence).

Play an animation on a Humanoid / AnimationController (a running game, or edit mode -- where it is stepped for `seconds` so the pose can be seen)

Stop a track started by animation_play.

Apply a HumanoidDescription to a Humanoid (server side of a playtest, or a rig in edit mode): description = {HeadColor: '#hex', Shirt: id, Pants: id, HatAccessory: 'id,id', BodyTypeScale: 0.3, ...}.

Lighting's properties and its post effects (Atmosphere, Bloom, ColorCorrection, Blur, SunRays, DoF, Sky).

The lighting presets lighting_set_preset knows.

Set Lighting properties in one undoable step: properties = {Brightness: 2, Ambient: '#404040', ClockTime: 14, Technology: 'Future', ...}.

Apply a lighting preset: day, dusk, night, horror, studio, backrooms.

Create a MaterialVariant (texture maps are asset ids).

Every MaterialVariant in MaterialService, and which base materials are overridden.

Make a MaterialVariant the default look of a base material (e.g.

Create a ParticleEmitter with all its properties in one call (sequences as [[t, v], ...], ranges as [min, max], colours as '#hex' or [[t, '#hex'], ...]).

Change properties on an existing ParticleEmitter (same formats as particle_create).

Find MaterialVariants by name (substring).

Create a persistent Sound under a parent from an asset id.

Play a sound by asset id through SoundService for a quick listen (removed after 60 s)

Add or update an EqualizerSoundEffect on a Sound (gains in dB).

Add or update a ReverbSoundEffect on a Sound.

Stop a preview started by sound_play_preview.

Configure TextChatService: chatVersion, createDefaultCommands, createDefaultTextChannels, bubbleChat {props}, chatWindow {props}.

Create a TextChatCommand (e.g.

TextChannels (and commands) under TextChatService.

Run a TweenService tween on an instance to judge timing and easing: tweenInfo = {time, style, direction, repeatCount, reverses, delay}, goal = {Property: value}.

Clear ALL terrain in the place (undoable in edit mode).

Fill a sphere of terrain.

Fill a block of terrain: cframe ([x,y,z] / 12 numbers / {position, rotation}), size [x,y,z], material (Enum.Material name).

Fill a cylinder of terrain (axis along the CFrame's Y).

Fill a wedge of terrain (like a WedgePart).

Every Enum.Material usable as a terrain material.

Read a region of terrain (min, max corners): material histogram and filled volume.

Use to compare viewport screenshots across up to six device settings.

Use to profile engine and game frame time on a live peer.

Use to capture the Studio viewport or map input coordinates.

Use to find Luau CPU hotspots on a running server or client.

Use to compare memory categories across Studio peers.

Use to attribute scene cost across instances and content.

Repeatable moving-fps test: glide the player in a straight line through fresh chunks at a fixed speed and report fps, worst frame, worst second, per-second fps and chunk arrivals.

Client frame numbers over a window: fps, worst frame, GPU / render-CPU ms, draw and shadow draw calls, triangles, instances, memory -- and a warning if Studio is unfocused (60 fps throttle).

One Stats snapshot: heartbeat / physics ms, instance and primitive counts, total memory and memory by tag, network kbps.

Sample Stats every intervalMs in the background (on that peer) until profile_stop.

Stop the Stats capture and return the samples with averages.

Script-profile a peer and summarise it: total Lua ms/s, ms/s per script, hottest lines.

Workspace streaming settings, plus every Model's ModelStreamingMode and LevelOfDetail (counts, and the non-default ones listed).

Use to save selected DataModel instances as a local .rbxm file.

Use to stage a Roblox model from text or an image.

Use to inspect a shortlisted Creator Store asset.

Use when an asset thumbnail would help with visual review.

Use to load a local, remote, or inline .rbxm under a chosen parent.

Use to sanitize and insert a Creator Store asset into a Studio place.

Insert a local file into the place: .rbxm/.rbxmx models (via SerializationService), or a script file (.lua/.luau; .server.lua -> Script, .client.lua -> LocalScript, else ModuleScript).

Search the Creator Store for a model and insert the best match (what Roblox's own Studio MCP offers)

Use to inspect an asset's hierarchy and media without inserting it.

Use to find public Creator Store assets by type or keyword.

Use to upload a local asset file to a Roblox user or group.

Create a build from compact rows and save it to the library: palette = [{color, mat}], parts = [[ox,oy,oz, sx,sy,sz, rx,ry,rz, paletteIndex, shapeIndex(0 Block,1 Cylinder,2 Ball,3 Wedge,4 CornerWedge)]].

Export a Model into the compact build format and save it in the local build library (library/<style>/<id>.json) for re-use, scenes and diffs.

Procedurally generate a build with JavaScript and save it to the library.

One build from the library: metadata, palette, rows, and its generator code if it has one.

Build a library build (by id, or inline build data) in Studio through model_build (validated first, audited after).

Place several library builds in one call: sceneData = {models: [{id, position [x,y,z], name?}]}, under targetPath.

Builds in the local library: id, style, part count, bounds.

Experience bans through Open Cloud user restrictions: op = list | get | ban | unban.

Live standard data stores through Open Cloud: op = list_stores | list_keys | get | set | delete | increment.

Publish a MessagingService message to every live server of a universe (needs confirm=true).

Universe info and operations through Open Cloud: op = get | restart_servers (shuts every live server down so players rejoin the latest version; needs confirm=true).

Publish (or save) a place file to Roblox through Open Cloud: file = a saved .rbxl or .rbxlx.