How to use Cursor (or VS Code) with Roblox Studio

The two ways Cursor works with Roblox Studio

A Roblox place is not a folder of files. Scripts, parts and UI all live inside the place, which Studio opens and saves. Cursor and VS Code edit files. So either your scripts become files (a sync tool keeps them matched with Studio), or the editor's AI agent talks to Studio directly over the Model Context Protocol (MCP).

Which one should you use?

• Script Sync when you want your own editor and version control for code, and Studio for everything else. Roblox notes it also works with Studio's built-in collaboration tools, which third-party tools often do not.
• Rojo when you want the entire project in version control, or the file system as the source of truth. That is Roblox's own guidance on its Script Sync page.
• Add MCP to either when you want Cursor's agent to see the place, build things files cannot hold, or start a playtest and read the result.

Pick one sync tool per project. Neither Roblox's nor Rojo's documentation describes running Script Sync and Rojo on the same scripts.

Option 1a: Sync scripts to files with Script Sync

Script Sync is built into Studio. It mirrors the scripts under an Explorer item to a folder on your disk: edit a file in Cursor and the script changes in Studio, edit the script in Studio and the file changes. Roblox's Script Sync page names Visual Studio Code and Cursor among the editors you can use with it. These steps follow Roblox's coding harness guide.

1. Make a project folder, for example my-game, and inside it one folder per service you want to sync, named exactly like the service: ServerScriptService, ReplicatedStorage and StarterPlayerScripts.
2. Open your place in Studio. In the Explorer, right-click ServerScriptService and choose Script Sync > Sync to.
3. Pick the top-level my-game folder, not the ServerScriptService folder inside it. Because the inner folders already have the services' names, Script Sync matches each service to its own folder.
4. Repeat for ReplicatedStorage and StarterPlayerScripts.
5. If Studio shows a conflict dialog, read it before you click. It lists the scripts that would be added, changed or deleted on each side for Keep Studio and Keep Disk. Choose the side that holds your work.
6. In Cursor, choose File > Open Folder and open my-game.

To check it works, ask Cursor's agent for a throwaway file, as Roblox's harness guide does: Create ServerScriptService/Test.server.luau that prints a hello message. A script named Test should appear under ServerScriptService in the Explorer. Delete the file afterwards and the script goes too.

What Script Sync does and does not sync

• Only Script, LocalScript, ModuleScript and Folder instances. Anything else in a synced folder is ignored, and Roblox advises against syncing folders that hold scripts alongside other instances. If a service in an existing place already holds models or RemoteEvents, sync a folder of scripts inside it instead of the whole service.
• Do not sync scripts that carry attributes or tags. Script Sync ignores both, which can lose data when scripts are created or deleted, or when you start from an older copy of the files.
• Script names must work as file names: no duplicate names in the same folder and no characters your file system rejects.
• Up to 10,000 scripts per synced root and 128 synced roots.
• You set it up once per place. When you reopen the place, Studio resumes syncing, and if files changed while Studio was closed it asks you how to resolve them.
• It works with Team Create, but two people editing the same synced script at the same time can overwrite each other.
• You cannot drive Studio's debugger from an external editor. Breakpoints stay in Studio.

Option 1b: Keep the whole project in files with Rojo

Rojo is a community tool, not maintained by Roblox, that Roblox's third-party tools page describes as a file system first approach. A server on your computer watches your project folder, and a Studio plugin connects to it and applies your changes to the open place. These steps are from Rojo's own documentation.

1. Install Rokit, the toolchain manager from the Rojo team, by following its README.
2. In a terminal, add and install Rojo with the two Rokit commands below. Roblox's third-party tools page explains that Rokit keeps tool versions in a rokit.toml file, so everyone on a team uses the same version.
3. Install the Studio plugin with rojo plugin install, or get the Rojo plugin from the Creator Store. Rojo has a separate plugin for each major version, so match it to the server you installed.
4. Create a project and build a place file from it, then open that file in Studio.
5. Start the live sync server from the project folder. In Studio, click the Rojo button on the toolbar and press Connect.
6. Open the project folder in Cursor. Saving a file now updates the place in Studio.

rokit add rojo-rbx/rojo
rokit install
rojo plugin install

rojo init my-game
cd my-game
rojo build -o my-game.rbxlx
rojo serve

rojo serve listens on localhost, port 34872 by default (a servePort field in the project file changes it). rojo init writes a project file named default.project.json. This is the part of it that maps code, from Rojo's current place template:

{
  "name": "my-game",
  "tree": {
    "$className": "DataModel",
    "ReplicatedStorage": {
      "Shared": { "$path": "src/shared" }
    },
    "ServerScriptService": {
      "Server": { "$path": "src/server" }
    },
    "StarterPlayer": {
      "StarterPlayerScripts": {
        "Client": { "$path": "src/client" }
      }
    }
  }
}

Each $path turns a folder into an instance. src/server contains init.server.luau, so Server becomes a Script and every other file in that folder becomes its child. src/client works the same way with a LocalScript, and src/shared stays a Folder.

Limits to know

• Not every property can live-sync from the plugin. Rojo's docs name binary data such as Terrain and CSG parts, MeshPart.MeshId and HttpService.HttpEnabled, and suggest building a place file and opening it for those. Rojo 7.6 added a fallback that deletes and recreates instances it cannot update in place, which its changelog says should make MeshParts and unions syncable, at the cost of breaking references to them that Rojo does not know about.
• Rojo works from your files into Studio. To bring instances you built in Studio back into the project, Rojo 7.7 added rojo syncback, which reads a saved place file.
• There is no lock-in: Roblox and Rojo both note that you can stop using Rojo and keep editing the place in Studio.

A folder layout that works in Cursor and Studio

This layout syncs the same three folders as Roblox's coding harness project and, as Roblox's script locations page recommends, keeps as much code as possible in ModuleScripts, with shared modules in ReplicatedStorage. The files at the top level are for your tools; they sit outside the synced folders.

my-game/
  .gitignore                     keeps place files out of Git
  .luaurc                        settings for luau-lsp and Luau tools
  AGENTS.md                      instructions for Cursor's agent
  my-game.rbxlx                  only if you save the place as a file
  ServerScriptService/
    Cooldown.luau                ModuleScript
    HealPads.server.luau         Script
  ReplicatedStorage/
    Shared/                      Folder
      Settings.luau              ModuleScript
  StarterPlayerScripts/
    Controls.local.luau          LocalScript

The file name tells the sync tool what to create in Studio. Script Sync and Rojo mostly agree, with one difference that catches people out:

The .luaurc file sets options for Luau tools and the language server in that folder and below. This one turns on strict type checking:

{
  "languageMode": "strict"
}

Roblox's Script Sync page does not say that Studio reads .luaurc, so also start each script with --!strict. The comment is part of the script, so it travels into Studio and Studio's type checker uses it too. To make strict the default for every script in the place instead, set Workspace.LuauTypeCheckMode to Strict in the Properties window.

Example: a typed ModuleScript and the script that uses it

Two files that put the layout to work. Cooldown is a ModuleScript with an exported type. HealPads is a server Script that uses it: tag any part HealPad in Studio, and touching it heals 25 health, at most once every 3 seconds per player. The parts stay in Studio and only the code lives in files: Roblox's script locations page recommends tagging instances and handling them through CollectionService instead of putting scripts inside parts in Workspace. The server also checks that the character is really at the pad, because Roblox's security guidance warns that an exploiter can trigger Touched events at any range or frequency.

--!strict
-- Remembers when each player last used something, so server code can
-- ignore repeats that arrive too fast. Server-only: it never runs on a client.

export type Tracker = {
	ready: (player: Player) -> boolean,
	forget: (player: Player) -> (),
}

local Cooldown = {}

function Cooldown.new(seconds: number): Tracker
	assert(seconds > 0, "Cooldown.new needs a positive number of seconds")
	local lastUse: { [Player]: number } = {}

	-- true (and starts a new cooldown) if this player is allowed to act now
	local function ready(player: Player): boolean
		local now = os.clock()
		local last = lastUse[player]
		if last ~= nil and now - last < seconds then
			return false
		end
		lastUse[player] = now
		return true
	end

	-- call when the player leaves, so the table does not keep old players
	local function forget(player: Player)
		lastUse[player] = nil
	end

	return { ready = ready, forget = forget }
end

return Cooldown

--!strict
local CollectionService = game:GetService("CollectionService")
local Players = game:GetService("Players")

type Tracker = { ready: (player: Player) -> boolean, forget: (player: Player) -> () }
type CooldownModule = { new: (seconds: number) -> Tracker }

-- Cooldown.luau sits in the same folder as this file, so it is a sibling in Studio
local folder = script.Parent :: Instance
local Cooldown = require(folder:WaitForChild("Cooldown")) :: CooldownModule

local TAG = "HealPad"
local HEAL_AMOUNT = 25
local REACH = 10 -- studs of slack beyond the pad's size, for lag and the character's height
local healCooldown = Cooldown.new(3)

local function onTouched(pad: BasePart, hit: BasePart)
	local character = hit:FindFirstAncestorOfClass("Model")
	local player = character and Players:GetPlayerFromCharacter(character)
	if not (character and player) then
		return
	end
	local humanoid = character:FindFirstChildOfClass("Humanoid")
	if not humanoid or humanoid.Health <= 0 or humanoid.Health >= humanoid.MaxHealth then
		return
	end
	-- An exploiter can fire Touched from any distance, so check the character is at the pad
	local root = humanoid.RootPart
	if not root or (root.Position - pad.Position).Magnitude > pad.Size.Magnitude / 2 + REACH then
		return
	end
	if not healCooldown.ready(player) then
		return -- Touched fires many times a second; heal at most once per cooldown
	end
	humanoid.Health = math.min(humanoid.Health + HEAL_AMOUNT, humanoid.MaxHealth)
end

local connections: { [Instance]: RBXScriptConnection } = {}

local function addPad(instance: Instance)
	if not instance:IsA("BasePart") or connections[instance] then
		return
	end
	local pad = instance :: BasePart
	connections[pad] = pad.Touched:Connect(function(hit: BasePart)
		onTouched(pad, hit)
	end)
end

local function removePad(pad: Instance)
	local connection = connections[pad]
	if connection then
		connection:Disconnect()
		connections[pad] = nil
	end
end

for _, pad in CollectionService:GetTagged(TAG) do
	addPad(pad)
end
CollectionService:GetInstanceAddedSignal(TAG):Connect(addPad)
CollectionService:GetInstanceRemovedSignal(TAG):Connect(removePad)

Players.PlayerRemoving:Connect(function(player: Player)
	healCooldown.forget(player)
end)

1. Save both files. With Script Sync running (or rojo serve connected), they appear under ServerScriptService in the Explorer.
2. Add a Part to Workspace and anchor it. In the Properties window, scroll to Tags, click + and enter HealPad.
3. Press Play. At full health the pad does nothing, by design. To test it, click the Client/Server toggle to switch to the server view, select your character's Humanoid in the Explorer, set Health to 50, switch back to the client view and step on the pad.

Luau autocomplete and type checking in Cursor and VS Code

Studio's script editor has linting, type checking and autocomplete built in. A plain editor knows neither Luau nor Roblox's API. Roblox's Script Sync page recommends the Luau Language Server extension for VS Code together with its companion Studio plugin, and says to install both.

• What it gives you. Its README lists diagnostics including type errors, autocomplete, hover, signature help, go to definition, find references, rename and inlay hints. The latest Roblox type definitions and documentation are preloaded by default. Formatting is not included: the README points to StyLua for that.
• In VS Code. Install it from the Visual Studio Marketplace (ID JohnnyMorganz.luau-lsp).
• In Cursor. Cursor installs third-party extensions from the Open VSX registry, and the luau-lsp README lists an Open VSX build. Open Extensions (Cmd+Shift+X on Mac, Ctrl+Shift+X on Windows), search for Luau Language Server and check that the publisher is JohnnyMorganz: Cursor's help warns that the same extension name can point to a different publisher on Open VSX.
• With Rojo. The language server reads a Rojo sourcemap to understand your instance tree. By default the extension generates it by running rojo sourcemap --watch default.project.json --output sourcemap.json, which needs Rojo 7.3.0 or later on your machine. Keep sourcemap.json out of Git; Rojo's template .gitignore already lists it.
• With Script Sync. Install the Luau Language Server Companion plugin in Studio, set luau-lsp.studioPlugin.enabled to true in the editor's settings, then click Connect on the plugin in Studio. The plugin sends your place's instance tree to the language server. Roblox says that with the extension and the plugin, language features work correctly while you use Script Sync.
• Settings. The README says general configuration comes from .luaurc files (strictness, lints and require aliases), like the one in the folder layout above. Settings specific to the server live under luau-lsp in the editor's settings.
• Checks outside the editor. The same tool runs on its own as luau-lsp analyze, for type and lint warnings in a CI job.

Roblox's Script Sync page also lists selene for linting and StyLua for formatting. Roblox notes that the community maintains these extensions and that it cannot guarantee their performance or security, so install extensions only from publishers you trust.

Option 2: Connect Cursor to Studio over MCP

Files give Cursor your code. MCP gives it the place: Studio's built-in MCP server lets a client read the instance tree, edit scripts, run Luau, start playtests and read the Output in the Studio window you have open. Cursor is one of seven clients with Quick connect. The full setup, the tool list and safety advice are in the Studio MCP guide; this section covers only what is specific to Cursor.

Quick connect

1. In Studio, click Assistant at the top right, then … > Manage MCP Servers, and turn on Enable Studio as MCP server.
2. Expand Quick connect and turn on Cursor. The list shows only supported clients that are installed on your computer.
3. If you installed Cursor while Studio was open, restart Studio, Cursor or both. A green indicator in the same panel shows how many clients are connected.

Manual setup in Cursor's mcp.json

Cursor's MCP documentation reads servers from .cursor/mcp.json inside a project, or from ~/.cursor/mcp.json in your home folder for every project. The Studio entry points at a file on your own computer, so the home folder file is the better place for it: a project's .cursor/mcp.json usually goes into Git, and a teammate's path may differ.

{
  "mcpServers": {
    "Roblox_Studio": {
      "type": "stdio",
      "command": "/Applications/RobloxStudio.app/Contents/MacOS/StudioMCP"
    }
  }
}

{
  "mcpServers": {
    "Roblox_Studio": {
      "type": "stdio",
      "command": "cmd.exe",
      "args": [
        "/c",
        "%LOCALAPPDATA%\\Roblox\\mcp.bat"
      ]
    }
  }
}

These are Roblox's documented entries with one addition: Cursor's docs list a type of "stdio" for local command-line servers. If the file already lists other servers, add the Roblox_Studio entry inside the existing mcpServers object, with a comma between entries. Then restart Cursor, which Roblox says is needed for the client to pick up the change.

Check it, and keep approvals on

• Start with a request that only reads, so a wrong setup cannot change anything: Using the Roblox Studio MCP tools, list what is in Workspace. Do not change anything. On a fresh Baseplate the answer lists Camera, Terrain, Baseplate and SpawnLocation.
• Cursor asks for approval before it uses an MCP tool, by default. Click the arrow next to the tool name to see its arguments before you approve a script edit or a Luau run.
• If no Roblox tools appear, open the Output panel (Cmd+Shift+U on Mac, Ctrl+Shift+U on Windows) and choose MCP Logs from the drop-down. It shows server start-up, tool calls and errors.
• To pause the connection without deleting it, turn the server off from Customize in Cursor's sidebar.
• Roblox warns that MCP clients can read and modify content in your open places. Save a version of the place before an agent session, and close places you do not want touched.

Visual Studio Code is on the Quick connect list too. Roblox's coding harness guide notes that Cursor has its AI assistant built in, while VS Code needs an extension such as Claude Code.

A safe workflow: Git, review, playtest

An agent that edits files can change many of them in one go. These habits keep every change visible and easy to undo.

1. Put the project folder under Git. rojo init sets up a repository for you (Rojo 7.6 added a flag to skip it). With Script Sync, run git init in the folder yourself.
2. Keep place files and generated files out of Git with a .gitignore like the one below. Studio keeps the place; Git keeps the code.
3. Tell the agent your conventions once. Cursor reads project instructions from an AGENTS.md file, or from rule files in .cursor/rules, according to Cursor's rules documentation.
4. Commit before each agent session, so you have a clean point to go back to.
5. Review before you keep anything. git diff shows every line the agent changed, and git restore <file> throws away changes you do not want.
6. Playtest in Studio yourself. Script Sync and Rojo move code; they do not run it. Over MCP, Cursor's agent can start a playtest and read the Output, but it only checks what it chose to check.
7. Back up the place as well. Git only covers your files: parts, UI and anything else built in Studio live in the place. Use File > Save to Roblox with Notes before big changes.

# Place files and lock files: Studio keeps the place, Git keeps the code
*.rbxl
*.rbxlx
*.rbxl.lock
*.rbxlx.lock

# Generated by the Luau language server or Rojo
sourcemap.json

# Notes for the agent

- This is a Roblox game in Luau. Start every new file with --!strict and add types.
- Files sync into Studio with Script Sync:
  Name.server.luau is a server Script, Name.local.luau is a LocalScript,
  Name.luau is a ModuleScript. Never use .client.luau in StarterPlayerScripts.
- Server code goes in ServerScriptService. Shared modules go in ReplicatedStorage/Shared.
- The server decides. Validate every RemoteEvent argument on the server and
  never trust an amount, price or position sent by a client.
- Use task.wait, task.spawn and task.delay, never wait, spawn or delay.
- Wrap DataStore and HTTP calls in pcall and handle the failure.
- Do not edit .rbxlx files or anything outside the synced folders.

git add .
git commit -m "Checkpoint before agent session"

For how the server and client split work, which is where most agent-written Roblox code goes wrong, see Script vs LocalScript vs ModuleScript and the RemoteEvents guide.

Troubleshooting

The problems below come up most often when an editor and Studio share the same scripts. Check Studio's Output window first, and for MCP problems, Cursor's MCP Logs.

Another route: RoCode, without files or MCP

RoCode (RoCode.app) skips the editor, the sync tool and the MCP server. It is an independent AI agent for Roblox Studio: you describe a change in a web chat at rocode.app, and a free RoCode plugin from the Creator Store carries it out in the place you have open. It does not use Studio's MCP server and needs no desktop app, command line or config file. You pair the chat and the plugin once with the 8-character code shown in the plugin panel.

The trade-offs, stated plainly. It works on the place, not on files, so Git and Cursor are not part of it. It runs third-party models through OpenRouter: DeepSeek V4 Flash and GPT-OSS 120B on every plan, more models on paid plans, and the free Starter plan includes 3 credits a day. It works in edit mode only and does not start playtests. For how it compares with other tools, see Roblox AI tools compared.

Press Play yourself to test what it changed: RoCode does not start playtests. The prompt is an example written by us; the steps use the real tool names. How the plugin and pairing work. RoCode is an independent product, not affiliated with, endorsed by or sponsored by Roblox Corporation. Roblox and Roblox Studio are trademarks of Roblox Corporation.

Questions

Sources and further reading

• Roblox Creator Docs: Script Sync. setup, limits, conflicts, Team Create, file naming, settings and recommended extensions
• Roblox Creator Docs: Build with a coding harness. Cursor or VS Code with Script Sync, MCP Quick connect and Git
• Roblox Creator Docs: Third-party tools. Rojo with Rokit, the Rojo plugin, Wally and version control
• Roblox Creator Docs: Script types and locations. RunContext, where client and server code should go
• Roblox Creator Docs: Connect to the Roblox Studio MCP server. enabling the server, Quick connect clients, JSON configuration and troubleshooting
• Roblox Creator Docs: Security tactics. why the server checks the distance before trusting a Touched event
• Roblox Engine API: InstanceFileSyncService. checking the Script Sync status of an instance
• Rojo docs: Installation. installing the server with Rokit and the Studio plugin
• Rojo docs: Creating a new game. rojo init, rojo build, rojo serve and connecting in Studio
• Rojo docs: Porting an existing game. why you are not locked into Rojo
• Rojo docs: Project format. $path, servePort and $ignoreUnknownInstances
• Rojo docs: Sync details. file names and what they become, and live-sync limits
• Rojo on GitHub: changelog and place template. .luau support, rojo syncback in 7.7, the default.project.json template
• Luau Language Server (luau-lsp) on GitHub. features, Open VSX build, Rojo sourcemaps, .luaurc and the companion Studio plugin
• Luau RFC: Configure analysis via .luaurc. languageMode and the other .luaurc keys
• Cursor Docs: Model Context Protocol. mcp.json locations, stdio fields, tool approval and MCP Logs
• Cursor Docs: Rules. project rules and AGENTS.md
• Cursor Help: Extensions. Open VSX and checking extension publishers

How the code was checked: every script on this page passes Luau's strict type checker against Roblox's API definitions (luau-lsp, 9 October 2026). A type check catches misspelt APIs and wrong types, not game logic, so playtest in Studio before you publish.