tufan-blox-bridge

Search the Source of all scripts for a Lua pattern. Returns path:line: text.

Ping a connected Studio place. Returns its place name + session.

Whether a simulation is running in the target Studio, and whether it's Run mode.

Execute Luau in the Studio plugin context (EDIT mode — runs against the edit DataModel, not a running playtest's server/client). Captures the return value and printed output. Full plugin API access.

List the Roblox Studio places currently connected to the bridge (placeId, name, gameId, project root). Use the placeId or name as the `place` arg on other tools to target a specific one.

Re-pull a connected place's full script tree into its local mirror folder (<project>/projects/<name>_<placeId>). Runs automatically on connect; use this to force a refresh.

Copy a script's Source from one connected place to another. The headline cross-place op — e.g. push a shared module from one game into another.

Get all (or chosen) properties of the instance at path.

Set one property. Value can be a primitive or {Vector3:[x,y,z]}, {Color3:[r,g,b]}, {UDim2:[xs,xo,ys,yo]}, {EnumItem:'Enum.Material.Wood'}.

Apply MANY different property edits in ONE call (and one undo entry): edits = [{path, name, value}, ...]. Use this instead of many set_property calls — far fewer round-trips (Roblox HttpService caps ~500 req/min, so bulk single-edits throttle).

Find instances under rootPath whose property equals value. For name/class search use search_objects instead; for the Roblox marketplace use search_assets.

All attributes of the instance at path.

Set an attribute on the instance at path (value may be primitive or a typed wrapper like {Vector3:[x,y,z]}).

Set MANY attributes across instances in ONE call + one undo entry: edits = [{path, name, value}, ...].

Spatial snapshot of the scene as the editor camera sees it: camera intrinsics (CFrame, FOV, viewport) + a curated list of visible objects, each with world position/orientation/size AND its on-screen pixel (x,y,depth,onScreen) via WorldToScreenPoint. This is what grounds a screenshot — it lets you say \"object X is at screen (px,py) = world (x,y,z)\". A Model counts as one object (bounding box); closest objects first. Pair with capture_screenshot. Read-only.

Raycast from a screen point into the scene and report what's under it: the hit instance (+ nearest Model ancestor), world position, surface normal, distance, and the part's CFrame/size/orientation. Give x,y in pixels OR nx,ny in 0..1 OR nothing for the viewport center. Powers \"what is that?\" and tracing (sample points along a screen path). Read-only.

List parts whose bounds overlap a region: a box (center+size), a sphere (center+radius), or 'around' an instance (its bounding box, optionally padded). Spatial query for \"what's near X / inside this area\". Returns part paths + world pos + size. Read-only.

Compute and apply an accurate placement: raycast to a surface (a screen point, a target instance's TOP via onTarget, or straight down via ground), then sit the object FLUSH on it — offset by the object's bounding box so it doesn't clip or float. Optional alignToNormal (rotate to the surface) and snap (grid studs). Use dryRun to get the computed CFrame without moving. Moves a Part (CFrame) or a Model (PivotTo, bbox-center flush). Write tool.

Full context of one instance in a SINGLE call: identity, key properties, attributes,

Read or change CollectionService tags on the instance at path. action='get' lists its tags;

All instances carrying a CollectionService tag, optionally filtered to a className (IsA).

Capture a PNG screenshot of the Roblox Studio 3D viewport only — cropped to the editor viewport, excluding the ribbon and docked panels (assumes the default layout: ribbon on top, Explorer/Properties docked right). Pass fullWindow:true to capture the entire Studio window instead. Server-side OS capture; errors if Studio isn't open/on-screen. Use this to visually verify UI/scene/VFX you just built. Windows-only.

Checkpoint a subtree before risky changes. Keeps an exact live clone in

Restore a snapshot: destroys whatever's currently at its original location and re-clones

List saved snapshots (name, origin, time, size).

Delete a saved snapshot.

Type-check Luau with luau-lsp (the Luau analyzer) over a place's synced script mirror — catches

One-look census of the whole place: instance / script / part counts, total Luau size,

Run MANY operations in ONE round-trip and ONE undo entry. The single biggest

Errors + warnings the plugin has pushed live (incl. during a playtest), read from

Recent Studio Output messages (edit mode). Optionally filter by severity.

FULL PIPELINE: turn a text prompt (or an image) into a game-ready asset in the open place —

Search the Roblox marketplace (Toolbox) for assets. Returns id + name, and flags assets that contain scripts (⚠ possible backdoor vector). Server-side. For instances already IN this place, use search_objects or search_by_property instead; for this place's own custom MaterialVariants, use search_materials.

Marketplace details for an asset id (name, creator, type, whether it contains scripts, mesh stats).

Fetch an asset's thumbnail as a PNG image so the AI can SEE what it looks like before using it. Uses Roblox's public thumbnail API (works for any public asset — no ownership needed, unlike insert_asset). Server-side.

List custom MaterialVariants defined in this place's MaterialService (name + base material), optionally filtered by name. For marketplace assets use search_assets instead; for other existing instances use search_objects/search_by_property.

Insert a marketplace asset by id under parentPath (default Workspace). NOTE: Roblox's LoadAsset only authorizes assets the logged-in user OWNS (or Roblox-made ones) — most third-party free models will fail unless you first take them (Toolbox → Add to Inventory). Tip: run scan_backdoors after inserting free models. For a LOCAL file you already have, use import_file instead; to AI-generate a new mesh, use generate_asset instead.

Create a new instance of className under parentPath, with optional name and properties.

Destroy the instance at path.

Clone the instance at path under parentPath (defaults to same parent).

Reparent the instance at path to newParentPath.

Rename the instance at path.

Build a whole nested instance subtree from ONE spec, in one call + one undo. Ideal for UIs (a panel + all its children at once). tree = { className, name?, properties?, children?: [tree, ...] }.

Undo or redo the last change in Studio (ChangeHistoryService). (Replaces undo + redo.)

Generate a 3D model with Meshy AI from a text prompt (two-stage: geometry preview → texture

Inspect or act on an existing Meshy task by id: status (poll progress), download (re-fetch

Inspect/edit a PUBLISHED game's saved data via the Open Cloud DataStore API (server-side HTTP, no

Audit the place for runtime frame-killers in one pass (part/physics load,

Fetch a URL (GET) and return the response body as text. For grabbing docs, JSON APIs, or reference data while working. Body is capped at ~100 KB; 15s timeout.

Generate a Rojo-style sourcemap.json from a place's synced script mirror — the file luau-lsp

Read OR write a script's Source. Omit `source` to READ the Source of a

Replace a line range in a script (1-indexed, inclusive) with newText — instead of re-sending the whole Source. Get line numbers from get_script_source/grep_scripts first. newText may be multi-line or empty (empties the range).

Project-wide plain-text find & replace across all scripts. Set dryRun=true first to preview which scripts + how many hits before applying.

Apply MANY anchored find/replace hunks to ONE script in one call — refactor-grade editing without resending the whole file. Each hunk is a LITERAL match (not a pattern), applied in order. ATOMIC: if a required hunk's `find` isn't present it errors and writes NOTHING (so a stale patch can't half-apply or silently no-op). Mark a hunk optional to skip it when absent. Set dryRun to validate the patch applies cleanly without writing.

Find scripts with IDENTICAL Source — copy-pasted code ripe for extracting into a shared

Run a canned headless-Blender operation on a local 3D file (.glb/.gltf/.fbx/.obj/.blend in;

POWER TOOL: run an arbitrary bpy (Python) script in headless Blender on this machine. The script

Working-tree status of a project.

Stage and commit changes in a project (all changes unless paths[] given).

Recent commits (default 20).

Diff. Default = working tree. Give from/to to compare commits/refs (e.g. from 'HEAD~1' to 'HEAD', or from a commit hash). Optionally scope to one path.

Restore a git-tracked file. Without source: discard working changes (restore to HEAD). With source (a commit/ref): recover that OLDER version of the file — use this to get back an edit you lost. (For restoring a non-git `snapshot` checkpoint of a live instance subtree, use restore instead.)

Recover a DELETED / lost file: finds the most recent commit where it still had content and restores it. The one-shot 'get my script back' tool.

Show a commit (metadata + changed-file stat) by ref, or a file's exact content at that ref when path is given.

Revert a commit — creates a new commit that undoes it (safe, keeps history). Use to roll back a bad change.

List branches, or create+switch when name given.

List remotes, or add one (action:'add' + name + url). Add a GitHub remote to back the place mirror up OFF-machine — the local mirror alone dies with the disk.

Push commits to the remote (set one up first with git_remote add). Off-machine backup.

Pull from the remote (fetch + merge). Restore/sync a mirror from its off-machine backup.

Make a UI subtree resolution-proof. Converts Offset→Scale across ALL the properties

Audit a UI subtree for what breaks on other resolutions — across the tree AND the scripts.

Tufan Power Tool: deep-scan a place for backdoors / exploits / obfuscation. Checks script source (require-of-Value, require-by-asset-id, loadstring, HttpGet, getfenv, exploit APIs, Discord webhooks, anti-debug, high-entropy blobs) AND the spots a script-only scanner misses — instance attributes and StringValues hiding encoded payloads. Findings sorted high→low severity. NOTE: this scans the PLACE tree; it cannot read installed Studio plugins' own source (a Roblox limit) — use list_studio_plugins to see what plugins are installed (the remote-code-plugin vector).

List Studio plugins installed locally on this machine (local .rbxm plugins + marketplace InstalledPlugins). Use this to spot the blind spot scan_backdoors can't reach: a third-party plugin running remote code. Server-side; no Studio call.

All descendants of path up to maxDepth (default 5).

Token-lean tree dump: runs of same-class siblings beyond `collapseMin` (default 6)

Find instances by name and/or className under rootPath. matchMode controls name matching: 'substring' (default), 'exact', 'wholeWord', or 'regex'. Use 'exact'/'wholeWord' to cut the noise that plain substring search produces.

Top-level services in the DataModel.

Format Luau on disk with StyLua (the standard Roblox formatter) over a place's synced script

Lint Luau with Selene (the standard Roblox linter) over a place's synced script mirror — catches

Run server-side Luau against your PUBLISHED game via the Open Cloud Luau Execution API — a fresh

What the user currently has selected in the Studio Explorer (paths + classes).

Select the given instances in the Studio Explorer.

Import a LOCAL file into Roblox: uploads it to the user's own account via the Open Cloud