📖 Comprehensive Usage Guide: Roblox VSCode

Welcome to the definitive manual for Roblox VSCode. This guide covers every feature, button, and hidden setting to help you achieve a high-performance development workflow.

✨ Key Features

Conflict Resolution UI

If a file changed in both VS Code and Studio since the last sync, the plugin used to just overwrite it with the VS Code version and move on. Now it holds that file back and prompts you: Compare & Choose (opens a real diff before you decide), Keep VS Code Version, or Keep Studio Version. Missed the prompt? Run Roblox Sync: Resolve Sync Conflicts from the Command Palette anytime to pick up where you left off.

Switch Active Project

Working across multiple games no longer means restarting the bridge. Run Roblox Sync: Switch Active Project to point the running server at a different previously-synced project — or browse to a new folder — without killing your connection. If Studio looks like it's mid-sync, you'll get a warning before it redirects.

Selective Sync

Roblox Sync: Manage Selective Sync (Exclude Rules) opens a checkbox picker over your project's folders (plus room for custom patterns), so you don't have to hand-edit ignorePatterns in settings.json anymore.

Shared Library

Reuse code across games without copy-pasting between VS Code windows. Right-click any file or folder in the Explorer → Export to Shared Library (or run it from the Command Palette), then use Roblox Sync: Import from Shared Library in any other project to drop it back in.

Failures Now Say Why

When a file can't sync — an unknown root folder, a class-creation error, a bad model import — the Studio activity log and VS Code's dashboard both now show the actual reason instead of just "❌ Failed: file".

First-Time Setup Check

The first time you open the Studio plugin, it now asks whether you already have the VS Code extension installed — with a copyable download link if you don't. It only shows once (unless you dismiss it with "Remind me next time"), so it won't nag you on every launch.

Teams

A Teams tab lets you create or join a team for the project you're currently in (one team per project). Add collaborators by their Roblox username, and everyone's activity — who pushed or pulled which file, and when — shows up in a shared feed, alongside a "last seen" timestamp per member so you can tell whether someone's bridge is actually being used. The owner can rename the team or disband it entirely. See the full breakdown under "Roblox Studio Plugin" below.

GitHub Integration for Teams (v2.0.0)

A Team's owner can link the project to a real GitHub repo from the Teams tab, push the currently synced files there with one click (VS Code does the actual work, using its own built-in GitHub sign-in — no token to manage), and grant teammates real GitHub collaborator access by entering their GitHub username. One repo per project, shared across every team member's bridge regardless of which machine connects. See How-To Guides for the full step-by-step.

Folders, Deletes, and Renames Sync Too

This isn't limited to individual script/GUI content:

• Folders sync both ways. Creating or deleting a folder — even an empty one — in either VS Code or Studio is reflected on the other side.
• Deletes sync both ways, for scripts, GUI .rbxmx files, and folders. Delete something in VS Code and it's removed from Studio; delete it in Studio and it's removed from VS Code.
• Renames are handled sensibly on both sides. A script rename produces a real rename on the other side. A folder or GUI rename resolves as a clean delete-of-the-old + create-of-the-new instead — not a single atomic rename message, but nothing gets orphaned or duplicated either.

GUI Sync Is Bidirectional

Editing a ScreenGui/BillboardGui/SurfaceGui (or anything inside one — frames, buttons, labels, UICorner, UIListLayout, and other common UI-utility instances) directly in Studio's UI editor now syncs to VS Code as a .rbxmx file, the same way GUI changes made in VS Code already synced to Studio. Click ⬆ PUSH TO VS CODE to pick up GUI changes made in Studio, same as for scripts.

🟢 Roblox Studio Plugin (The Bridge)

The Studio plugin acts as the client that speaks to your local VS Code environment. The tab bar only shows Main and Teams directly — everything else (Tutorial, Support, Debug, Settings, Credits) lives behind the More ▾ dropdown, so the bar stays uncluttered as the plugin's grown more pages over time.

Tab: Main

• Enter pairing code / 🔗 CONNECT TO VS CODE: Type the code shown in VS Code (see Step 4/5 of Getting Started) and click this to link up. This performs a full recursive scan of your game's scripts, builds a hash-map, and sends it to VS Code to check for differences.
  • Tip: Reconnect if you've done a lot of manual editing in Studio without VS Code open, so both sides agree on what's changed.
• ▶ START LIVE SYNC / ⛔ KILL CONNECTION: This is the heart of the tool. Once live sync is on, saving a .lua file in VS Code updates the matching script in Studio almost instantly. "Kill Connection" stops it without closing the plugin.
• ⬆ PUSH TO VS CODE: Scans for local changes made directly in Studio — script edits, GUI edits, new/deleted/renamed folders, and deleted/renamed scripts and GUIs — and sends them to VS Code.
• ⬆ FORCE PUSH TO VS CODE / 🔄 FORCE SYNC FROM VS CODE: Skips the usual hash comparison and forces a full resend in one direction — useful if the two sides ever look out of sync and you want one to just win outright.
• Quick Actions: 🔄 REBUILD CACHE rebuilds the plugin's internal script cache from scratch (it also does this automatically every 5 minutes during live sync, if that setting is on). 🧹 CLEAR LOGS wipes the activity log shown at the bottom of this tab.

Tab: Teams

Teams are scoped to a single project — one team per game. What you see here depends on what's already set up for the project you're in:

• No team yet: You'll see a "Create a Team" form. Enter a team name and your Roblox username (self-reported — there's no login, so type it carefully) and hit Create Team. You become the owner.
• A team already exists, but you haven't joined: You'll see the team's name and owner, plus a box to enter your Roblox username. Hitting Join Team only succeeds if the owner has already added your username to the roster — if not, it'll tell you to ask them.
• You're an active member: You'll see the full member roster — each with a "last seen" line pulled from when their plugin last successfully connected — a Recent Activity feed (who pushed or pulled which file, and when), and a Leave Team button. If you're the owner, you'll also see an "Add a teammate" box (type their Roblox username and hit Add — if that username has never been seen connecting through a Roblox VSCode bridge before, you'll get a warning that they may not have it set up yet, a best-effort signal, not a hard guarantee) and a ⚙️ Team Settings card: rename the team anytime, or 🗑️ Disband Team (click twice within a few seconds to confirm — this permanently deletes the roster and activity feed for everyone, so there's no accidental single-click delete).
• If you've signed in with Roblox from the VS Code side, your username here is filled in automatically and locked (shown with a ✅) instead of needing to be typed — Studio itself can't run that sign-in flow on its own, since it has no way to open a browser, so it only ever arrives secondhand from VS Code.

Since there's no shared live session, everyone on a team still runs their own local VS Code↔Studio bridge — Teams just adds the roster and activity feed on top so you can see who's been doing what.

More ▾ → Tutorial

A short, always-available 5-step recap of the whole setup — install both pieces, enable "Allow HTTP Requests," start the bridge, pair & connect, then start live sync. Good for a quick refresher without leaving Studio, or for pointing a teammate at instead of retyping the same steps in chat.

More ▾ → Support

A built-in support chat. Creating a ticket (or resuming your existing one, if you already have one open) connects you with the support team, and replies show up here in real time — no need to leave Studio to ask for help.

More ▾ → Debug

For diagnosing problems, not everyday use:

• Debug Controls: toggle verbose debug mode, or dump the plugin's full internal state to the log for troubleshooting.
• Connection Info: current status, auth token, server address, and time of the last successful poll.
• Cache Stats: how many entries are currently held in each of the plugin's internal caches.
• Currently Processing: what the plugin is actively working on right now, or "Idle."
• Sync Stats: running totals for changes applied, changes pushed, and conflicts encountered this session.

More ▾ → Settings

• Enable Analytics: opt-in only, and currently a no-op — no analytics endpoint is configured, so nothing is sent anywhere even when this is turned on. If that ever changes, it would only ever be your place ID and whether a sync succeeded or failed — no source code, ever.
• Show Verbose Logs: turns on the same debug logging as the Debug tab's toggle.
• Auto-Rebuild Cache (5 min): automatically rebuilds the script cache every 5 minutes while live sync is running, instead of only when you click Rebuild Cache manually.
• 📖 Open Documentation Site: shows a copyable link to this page — Studio plugins can't open your system browser directly, so you copy-paste it instead of it "just opening."

More ▾ → Credits

Who made this, the current version number, and copyable links to the Roblox community, the website, and the creator's Roblox profile — same copy-paste pattern as the documentation link above, for the same reason.

🔵 VS Code Extension (The Engine)

⌨️ Universal Keyboard Shortcuts

• Ctrl+Alt+R: Start the Local Bridge.
• Ctrl+Alt+X: Stop/Kill the Local Bridge.
• Ctrl+Alt+U: Push all modified files to Studio (Differential Sync).
• Ctrl+Alt+I: Toggle the Professional Dashboard.
• Ctrl+Alt+H: Open the Hosted Documentation.
• Ctrl+Alt+L: Check Connection Health.
• Ctrl+Alt+G: Generate AI Coding Rules.
• Ctrl+Alt+T: Show Team Members (everyone on this project's team).

🧭 Command Palette additions (Ctrl+Shift+P)

• Roblox Sync: Resolve Sync Conflicts — manually revisit any pending conflicts.
• Roblox Sync: Switch Active Project — redirect the bridge to a different project.
• Roblox Sync: Manage Selective Sync (Exclude Rules) — checkbox picker for ignore patterns.
• Roblox Sync: Export to Shared Library / Import from Shared Library — reuse code across games.

⚙️ Workspace Settings (settings.json)

• robloxSync.serverPort: Default is 8080. Change this if you have a port conflict.
• robloxSync.autoSyncOnSave: Set to true (default) for the best experience.
• robloxSync.ignorePatterns: Add regex/strings to ignore folders like node_modules or .git.

🛠️ Troubleshooting

Running into something unexpected? The FAQ page covers the common first-time issues in more depth — port conflicts, the "Allow HTTP Requests" setting, character-encoding quirks, what a "Failed" log entry means, and more — plus general questions about privacy, Teams, and how the tool works day to day.

❓ How-To Guides

Every action you can take with Roblox VSCode — in Roblox Studio, in VS Code, or on this website — answered as its own short recipe. Each card is tagged with where the action happens: Studio VS Code Website. New to the tool entirely? Start with Getting Started first — this page assumes both pieces are already installed.

🔌 Connecting & Live Sync

🐙 GitHub Integration (new in v2.0.0)

👥 Teams

🪪 Identity & Verification

🤖 AI Tools & Code Reuse

🌐 Website

📚 Dashboard & In-Plugin Info Pages

⚙️ Settings & Debugging (Studio Plugin)

Roblox VSCode vs Rojo

Rojo has defined professional Roblox development for years, and it deserves credit for that — it's the tool that first proved external editors could work for Roblox at all. This page is an honest comparison, not a takedown: where Rojo is genuinely stronger, we say so.

This also isn't a "Roblox VSCode is better than Rojo" pitch, and if that's what you came for, you won't find it here. The two tools have different design goals. Rojo treats your filesystem as the single source of truth and pushes it into Studio. Roblox VSCode is built around a two-way relationship, where Studio-side edits sync back too. The real question isn't which one is better — it's which one fits how you actually build.

Two developers, one project

Picture two people working on the same game. One is a programmer, sitting in VS Code writing PlayerData.server.lua — they want Git, search, extensions, a real editor for actual code. The other is a builder, sitting in Studio, hand-placing buttons and frames on a UI until it looks right — they want to visually manipulate objects, not describe them in code.

A strict code-first workflow quietly forces one of them into the other's tools — either the builder fights Studio's script editor, or the programmer's Studio-side work never makes it back to the project. Rojo is excellent for the first developer's half of that problem. Roblox VSCode is built so both of them keep working exactly where they're best, with their changes meeting in the middle instead of one side winning by default.

Head-to-head

Where Rojo's real friction points are

These aren't hypothetical — they're what shows up repeatedly in community discussion:

• Manifest upkeep. default.project.json needs continuous manual editing as a project's structure changes, and environment-based folder routing (server/client/shared) can force heavy context-switching just to gather the files for one feature.
• Sync latency. Local HTTP request limits, plus antivirus/endpoint protection scanning rapid file changes over Rojo's port, can cause real syncing delays or timeouts unless exclusions are configured by hand.
• Split source of truth. Because physical assets and GUI often stay managed in Team Create rather than the filesystem, a Git revert can silently desync from something that was changed a different way.

What Roblox VSCode does differently

• Bidirectional by design. A local Express server (bound to 127.0.0.1 only — never reachable off your machine) and the Studio plugin both push and pull, with conflict detection when both sides changed the same file.
• Fast, cheap hashing. Differential sync uses 32-bit FNV-1a hashing on both sides, so only files that actually changed get sent — implemented to exactly match between the Lua and TypeScript sides, byte for byte.
• State persists across restarts. A local .sync_state.json means reopening a project reconciles against what was last confirmed synced instead of re-hashing and re-pushing everything from scratch.
• Multi-window aware. The first VS Code window to connect becomes the host; additional windows detect this and mirror its state instead of fighting over the same port.
• Zero-config path mapping. .server.lua, .client.lua, and .lua map to Script, LocalScript, and ModuleScript automatically, with duplicate-named instances disambiguated the same way on both sides.
• Built-in team tooling. A Teams tab tracks who pushed or pulled what, Selective Sync replaces hand-edited ignore-pattern JSON with a checkbox picker, and Shared Library lets you export a script or folder from one project and import it into another.

Where we're honestly behind (for now)

• No CI/CD story. Rojo's rojo build is a mature, headless way to produce a testable .rbxl. We don't have an equivalent — this tool is built for syncing a live Studio session, not building standalone place files.
• Limited asset sync. Only GUI trees sync as .rbxmx today. Audio, decals, and 3D models aren't synced at all yet.
• Smaller ecosystem. Rojo has years of community tooling behind it. We're newer, and it shows in maturity, not ambition.

So which one should you use?

If your filesystem really is your source of truth — you write Lua in VS Code and that's the whole project — Rojo is an excellent choice, and switching gains you little. If a meaningful part of your project happens inside Studio itself, and you want that work to actually reach your dev environment instead of staying stranded there, that's what Roblox VSCode is for. Plenty of teams will find the honest answer is "both," on different projects or even the same one. Use whichever fits how you actually build.

Have thoughts on this comparison, or found something inaccurate? Open an issue on GitHub.

❓ Frequently Asked Questions

Quick answers, grouped by topic. If you're setting up for the first time, the Getting Started page is a better place to begin — come back here once something's confusing or not working the way you expected.

General

What does Roblox VSCode actually do?

It keeps a folder on your computer and your Roblox Studio game in sync. Edit a script in VS Code and save it — it appears in Studio almost instantly. Edit a script directly in Studio instead, and it flows back into the matching file in VS Code. Both directions work at the same time.

Is this an official Roblox tool?

No. It's an independent project (by Glitch Work Studios / CodingJeff) that uses Roblox Studio's plugin system and Roblox's own APIs — it isn't made or endorsed by Roblox Corporation.

Do I need to know Rojo or any other syncing tool first?

No. Unlike tools built around writing your own JSON project files and build scripts, Roblox VSCode works as soon as you connect the two sides — no project config to hand-write.

Is Roblox VSCode better than Rojo?

Wrong question, honestly. Rojo and Roblox VSCode have different design goals. Rojo treats your filesystem as the single source of truth and pushes it into Studio, one-way — that's exactly right if your workflow really is "I write Lua in VS Code and that's the whole project." Roblox VSCode is built around a two-way relationship instead: a GUI you build by hand in Studio, or a model you position visually, syncs back into your VS Code project as a real file, instead of staying stuck in Studio. If your project is mostly Studio-side building and you want those changes to actually reach your dev environment, that's the problem this tool is solving. See the full Roblox VSCode vs Rojo comparison for specifics on where each one is genuinely stronger.

Does it work with Team Create?

Yes. Everyone on the team who wants VS Code editing installs both pieces themselves and connects their own bridge — there's no single shared session. It won't interfere with teammates who aren't using it; it just makes your own editing experience better. If you want visibility into who's syncing what, see the Teams questions below — that's a separate, optional feature layered on top.

Setup & Installation

What exactly do I need to install?

Two things: the VS Code extension (a .vsix file from the Download page) and the Roblox Studio plugin (from the Creator Store). Both are required — one without the other can't do anything, since they're the two ends of the same bridge.

I installed the Studio plugin but VS Code says nothing's there / connect fails immediately.

Make sure you actually installed the VS Code extension too, and that you started the bridge (Ctrl+Alt+R) before trying to connect from Studio. If you skip the VS Code side entirely, the plugin's first-launch popup should have warned you about exactly this — if you dismissed it too quickly, it won't show again automatically, but you can still visit the Download page directly.

Where do I get the pairing code, and why does the plugin need it?

Starting the bridge in VS Code (Ctrl+Alt+R) generates a short numeric code, shown in a notification and kept visible in the sync dashboard (Ctrl+Alt+I) the whole time the bridge runs. The Studio plugin needs it once, so that a random webpage or another program on your machine can't quietly connect to your local sync server and pull your project without your say-so. You can turn this requirement off in VS Code settings (robloxSync.requirePairing), though we don't recommend it.

"Allow HTTP Requests must be enabled" — what does this mean?

Roblox Studio blocks scripts from making network requests by default, and the plugin needs to talk to your local VS Code server. Go to Home → Game Settings → Security in Studio and turn on Allow HTTP Requests. This is a per-place setting, so a new game will need it turned on too.

"Server already running on port 8080"

This isn't actually an error you need to fix. If you have more than one VS Code window open on the same project, the first one becomes the "Host" running the actual server, and every other window automatically becomes a "Client" that forwards its changes to the Host. Nothing extra to configure.

Using It Day to Day

Do I need to keep VS Code open the whole time?

Yes, for as long as you want live syncing. Closing VS Code (or stopping the bridge with Ctrl+Alt+X) just pauses syncing — your files and your game are both left exactly as they were, and reconnecting later picks back up.

What happens if I close Studio or lose my internet connection mid-sync?

Nothing gets corrupted. The sync engine tracks what's already been applied on each side using file hashes, so when you reconnect, it only needs to catch up on whatever actually changed while you were disconnected — not resend everything from scratch.

I edited the same script in both VS Code and Studio before they had a chance to sync. What happens?

That's a conflict, and it's held back rather than silently overwritten. You'll be prompted to Compare & Choose (opens a real diff), Keep VS Code Version, or Keep Studio Version. If you miss the prompt, run Roblox Sync: Resolve Sync Conflicts from the Command Palette anytime to pick it back up. An unresolved conflict auto-resolves to the VS Code version after two minutes, so a forgotten prompt can't hold a file forever.

Can I sync more than one game at a time?

Each VS Code window/bridge is tied to one project at a time, but you can switch which project it's pointed at without restarting anything — run Roblox Sync: Switch Active Project from the Command Palette.

Can I exclude certain folders or files from syncing?

Yes — run Roblox Sync: Manage Selective Sync (Exclude Rules) for a checkbox picker over your project's folders, instead of hand-editing the robloxSync.ignorePatterns setting.

Can I reuse a script across different games?

Yes — right-click any file or folder in VS Code's Explorer → Export to Shared Library, then run Roblox Sync: Import from Shared Library in any other project to pull it back in. No manual copy-paste between windows.

A file shows "❌ Failed" in the activity log. Why?

The log line itself now tells you the actual reason (an unknown root folder, a class-creation error, a bad model import, the wrong instance type, etc.) instead of just saying "failed." If it keeps failing after a few retries, VS Code's dashboard shows one final message with the last known reason too.

Why aren't accented characters (like á or ñ) syncing correctly?

Make sure the file is saved with UTF-8 encoding in VS Code (check the encoding indicator in the bottom-right status bar). The tool normalizes paths and content carefully, but it can only work with what the file actually contains.

Teams

What is the Teams feature, exactly?

A roster and activity feed, scoped to one project. Create a team (or join one someone else already made) from the Studio plugin's Teams tab, and add collaborators by their Roblox username. From then on, everyone's pushes and pulls — who touched which file, and when — show up in a shared feed, so you can see what teammates have been doing without asking.

Is this the same as Roblox's own Team Create?

No, and you don't need Team Create to use it. It's a separate, lightweight feature specific to this tool — think of it as a shared activity log layered on top of everyone's individual sync bridges, not a replacement for Roblox's own collaboration tools.

How does it know who I am? Do I need to log in?

Identity is a self-reported Roblox username by default — there's no login, so type it carefully when you join or create a team. If you'd rather have it verified automatically, sign in with Roblox from the VS Code side (see the "Roblox Identity" section of the sync dashboard); the Studio plugin picks up a verified identity automatically the next time it connects, since Studio itself can't run a browser-based sign-in on its own.

I added a teammate but got a warning that their install "hasn't been seen." Is that a problem?

Not necessarily — it just means nobody has seen that Roblox username connect through a Roblox VSCode bridge before, which usually means they haven't finished setting up their own side yet. It's a best-effort heads-up, not a hard error; check in with them if you're not sure.

Privacy & Security

Does my code get uploaded anywhere?

No. The sync server runs entirely on your own computer, bound to 127.0.0.1 (your machine only) — nothing on your network, let alone the internet, can reach it. Your source code never leaves your computer as part of the syncing process itself.

What does the "Auth Token" on the dashboard do?

Every sync session generates a random token that the Studio plugin has to send with every request. It's there so that nothing else running on your machine can quietly talk to the sync server and pull your files — you shouldn't need to touch it unless auto-sync fails to detect it itself.

Is the Teams feature or support ticket system sending my data somewhere?

Team rosters, activity feeds, and support tickets are stored in a shared database so they can be seen across your own devices and by teammates you've added — that's the point of those specific features. Your actual game code and script contents are not part of that; syncing itself stays entirely local to your machine.

Still stuck?

Open a ticket from the Support page, or ask in the Glitch Work Studios Roblox community — include what you tried, what you expected, and what actually happened (a copy of the Studio plugin's activity log helps a lot).

✨ Why Choose Roblox VSCode? (Layman's Terms)

If you've ever felt frustrated by the Roblox Studio code editor—or found tools like Rojo too complicated to set up—Roblox VSCode is for you.

🌉 A Bridge, Not a Rival

Unlike other tools that require you to learn JSON project structures and build scripts, Roblox VSCode works instantly.

1. Open your game.
2. Press Connect.
3. Start Coding.

This isn't about replacing Rojo. If your whole project already lives in your filesystem, Rojo does that job well - no reason to switch. Roblox VSCode is for when part of your project happens inside Studio too, like a UI you built by hand or a model you positioned visually, and you want that work to actually reach VS Code instead of staying stuck where you made it.

🎨 The Magic Bridge: How it feels

Imagine you're painting a mural on a wall (Roblox Studio), but you'd rather be using your professional iPad (VS Code).

• Every stroke you make on the iPad is instantly projected onto the wall in real-time.
• If someone else paints on the wall, it shows up on your iPad automatically.
• That's exactly how our sync engine works!

🤝 What if the wall and the iPad both change?

Every so often, you and the wall paint over the same spot at the same time — you edited a script in VS Code, but Studio also changed since you last looked. v1.0.0 stops guessing for you: it pauses that one spot and asks which version to keep, showing you both side-by-side first if you want a closer look. Nothing gets silently painted over anymore.

🛡️ Built for Professional Developers

We didn't just build a "copy-paster." We built a developer suite.

• Stats: See how much work you've done today.
• Safety: Everything you sync can be "undone" with the standard Undo button in Studio.
• Privacy: Your code is yours. We don't have servers that store your code; everything stays on your computer.

👥 Great for Teams

Even if you work with multiple people in Team Create, you can use Roblox VSCode. It won't interfere with your teammates; it just makes your life easier.

🛠️ Technical Deep Dive: Roblox VSCode Architecture

Roblox VSCode is built on a state-reconciliation model using a decoupled client-server architecture. It prioritizes data integrity and low latency over simple file-copying.

1. Transport Layer: Node.js + Express

The system operates on a local REST API hosted at 127.0.0.1:8080.

• Server discovery: the first VS Code window to bind the port becomes the Host, running the actual Express server. Any additional window either fails to bind the port (EADDRINUSE) or proactively checks an internal status endpoint, and falls back to Client mode — forwarding its own local changes to the Host's queue via /internal/queue instead of running a second server.
• Polling loop: the Roblox Studio plugin performs incremental POST requests to /poll, sending a lightweight JSON map of its current script hashes (FNV-1a).
• Response handling: the server compares the received hashes against its own in-memory cache. If a mismatch is found, only the modified files are returned in the response body.

flowchart LR
    A["VS Code window starts"] --> B{"Port 8080 already bound?"}
    B -- No --> C["Becomes the Host<br/>runs the Express server"]
    B -- Yes --> D["Becomes a Client<br/>forwards changes via /internal/queue"]
    C --> E["Studio polls /poll<br/>with current file hashes"]
    D --> E
    E --> F["Server diffs against<br/>known hashes"]
    F --> G{"Any mismatch?"}
    G -- Yes --> H["Return changed files<br/>in the response"]
    G -- No --> E

2. Change Detection: FNV-1a & Delta-Rebuilds

Instead of MD5 or SHA-256 — unnecessarily heavy for what's really just "did this file's bytes change" — the engine uses FNV-1a (32-bit). Collision resistance in the cryptographic sense was never the goal; the point is a hash that's cheap enough to recompute on every poll cycle for every tracked file, with enough uniqueness that an accidental collision is a non-issue for detecting real content changes.

• State persistence: sync state is written to .sync_state.json in the project root. Reopening a project reconciles against this instead of re-hashing and re-pushing everything blind.
• Exact cross-side matching: both the Lua and TypeScript implementations use the exact same FNV-1a algorithm (matched down to Math.imul-equivalent 32-bit wraparound behavior on the Lua side) so a hash computed on one side always matches the same content hashed on the other.

flowchart LR
    A["File saved"] --> B["Hash with FNV-1a (32-bit)<br/>fast, not cryptographic"]
    B --> C["Compare against<br/>.sync_state.json"]
    C --> D{"Hash changed?"}
    D -- Yes --> E["Queue for sync"]
    D -- No --> F["Skip - already synced"]
    E --> G["Update .sync_state.json<br/>once delivery is confirmed"]

3. Canonical Path Mapping

Roblox and the filesystem use different hierarchies (Instance tree vs. directory tree).

• The mapper: .lua, .server.lua, and .client.lua map to ModuleScript, Script, and LocalScript respectively, so Path/To/Script.server.lua resolves to a Script at game.Path.To.Script.
• Path sanitization: filesystem-illegal characters are stripped from instance names, and a name of exactly . or .. is rejected outright rather than passed through — both sides had a real path-traversal gap here at one point, since a crafted name could otherwise escape the project root.
• Duplicate-name disambiguation: Roblox allows two siblings with the same name (its own default for a newly-inserted instance). Same-named-and-same-type siblings are ranked by GetChildren() order and given a _2, _3… suffix, computed identically on both sides so they never drift apart.

flowchart LR
    A["Instance in the Roblox tree"] --> B{"Class type?"}
    B -- Script --> C[".server.lua"]
    B -- LocalScript --> D[".client.lua"]
    B -- ModuleScript --> E[".lua"]
    C --> F["Sanitize name<br/>strip illegal characters"]
    D --> F
    E --> F
    F --> G{"Duplicate sibling name + type?"}
    G -- Yes --> H["Append _2, _3...<br/>by GetChildren() order"]
    G -- No --> I["Final file path"]
    H --> I

4. Local Security Model

Nothing here is encrypted in transit or at rest — the actual model is access control, not cryptography:

• Localhost binding: the Express server binds explicitly to 127.0.0.1, not 0.0.0.0 — nothing on the local network, let alone the internet, can reach it.
• Per-session bearer token: every /init handshake issues a fresh 32-character hex token (crypto.randomBytes(16).toString('hex')), which the Studio plugin must send on every subsequent request.
• Pairing code: the first connection additionally requires a short numeric pairing code shown in VS Code, with failed attempts rate-limited against brute force — so a random local process can't just guess its way onto an already-running bridge.

flowchart LR
    A["Local security model"] --> B["Localhost binding<br/>127.0.0.1 only"]
    A --> C["Per-session bearer token<br/>32-char hex"]
    A --> D["Pairing code on first connect<br/>rate-limited"]
    C --> E["Every Studio request<br/>must include the token"]

5. Conflict Resolution

A conflict exists when the hash VS Code has on file for a script no longer matches what Studio reports and VS Code independently has a pending outgoing change for that same file — meaning both sides moved since the last sync.

• Held, not dropped: the outgoing VS Code change is excluded from the poll response until the conflict is resolved, instead of being sent blind.
• On-demand content fetch: choosing "Compare & Choose" or "Keep Studio Version" adds the file to a requestContent list returned on the next /poll; Studio resolves the instance, reads its current Source, and pushes it back through the normal /push path. A file is only re-requested once its previous request has actually resolved, so a slow round trip doesn't trigger duplicate diffs.
• Diff before commit: "Compare & Choose" opens an in-memory virtual document against the local file in a VS Code diff view — no temporary file is ever written to disk (an earlier version did this via a real temp file, which leaked unboundedly; that's been replaced).
• Fail-safe timeout: an unresolved conflict auto-resolves to the VS Code version after 2 minutes so a forgotten prompt can't hold a file forever; the timer resets whenever you make a choice, so it only fires on conflicts nobody ever answered.

flowchart LR
    A["Hash mismatch AND<br/>pending outgoing change"] --> B["Hold the change<br/>excluded from poll response"]
    B --> C{"User picks"}
    C -- Keep VS Code --> D["Deliver the held change"]
    C -- Keep Studio --> E["Request Studio's content<br/>via requestContent on next poll"]
    C -- Compare and Choose --> F["Show virtual diff document<br/>no temp file, in-memory only"]
    C -- No response --> G["Auto-resolve to VS Code<br/>after 2 minutes"]
    E --> H["Apply chosen version"]
    F --> H
    D --> H
    G --> H

🎉 What's New: Roblox VSCode v2.0.0

📍 How to Get It & See What's New

• VS Code extension: grab roblox-vscode-2.0.0.vsix from the v2.0.0 release (or the Download page), then in VS Code open the Extensions panel → ··· menu → Install from VSIX... and pick the file. It installs over the old version automatically — no need to uninstall first.
• Studio plugin: the Creator Store auto-updates it for you, so if Studio was closed you likely already have it next time you open it. If not (or if Studio was open during the update), reinstall from the Creator Store listing and restart Studio.
• See exactly what changed, right inside Studio: open the plugin panel → More ▾ → What's New. It always shows the notes for whichever version you're currently running, so you can check it any time without leaving Studio.

Added

• GitHub repo integration for Teams. From Studio's Teams tab (owner-only), link your project to a real GitHub repo, push the synced files there with one click, and grant teammates real GitHub collaborator access by entering their GitHub username — a real invite goes out via GitHub's own API, not just an in-app permission. One repo per project, shared across every team member's bridge regardless of which machine connects. See 🐙 How to Link a GitHub Repo below for the full walkthrough.
• Roblox account verification is now actually real. The "Connect Roblox Account" flow was quietly unverifiable before (it redirected to Roblox's real OAuth screen, but the site had no backend that could ever complete the token exchange, so it silently fell back to trusting whatever username someone typed and labeled it "Verified" anyway). Replaced with a profile-code ownership check: paste a one-time code into your Roblox profile's About section, we confirm it against Roblox's own public API. The "Verified" badge on the site now means something.

Fixed

• A real Studio crash, and reconnecting afterward doing nothing. The full project tree walk (on Connect, and on every automatic reconnect) ran with zero yields — on a large project this could run long enough to hit Studio's script execution-time limit, which force-kills the thread mid-work. That skips straight past the line that frees up the Connect button for next time, permanently freezing it — so "reconnecting crashes it again" was really "the button silently stopped working after the first crash." Fixed both: the tree walk now yields periodically, and both reconnect paths are pcall-wrapped with a guaranteed reset regardless of what happens.
• Every custom icon in the plugin was invisible, including the main Studio toolbar button — all 7 icon asset IDs turned out to not be real uploaded images. Replaced with emoji everywhere; no Roblox upload/moderation needed.
• The Connect button always said "Ensure Server is running" even when the real problem was a wrong or expired pairing code. Now reads the actual server response and says so specifically (wrong/expired code, rate-limited after too many attempts, etc.) instead of sending you toward the wrong fix.
• Copy-to-clipboard links had no fallback when setclipboard was blocked or unavailable — previously just logged the URL to the Output window for manual copy-paste. Now swaps in a real selected text field so Ctrl+C works regardless.
• The auto-generated AI coding-guidelines file (Ctrl+Alt+G) was named .cursorules (missing a letter) — Cursor's actual convention is .cursorrules, so it was silently never picked up by the one tool it was made for. Also corrected a stale claim in its content ("VS Code always wins conflicts" — hasn't been true since the interactive conflict picker was built).

Changed

• Live usage stats on the homepage and the Roblox-verification flow above no longer depend on Firebase Cloud Functions (which require a paid billing plan for any function that calls an external API) — moved to reading the Realtime Database directly and a Cloudflare Worker (free tier) respectively.

🐙 How to Link a GitHub Repo

New in v2.0.0: a Team can push its synced project straight to a real GitHub repo, and the owner can grant teammates real collaborator access — all from Studio's Teams tab. This only works for a project that already has a Team (see the Teams tab if you haven't created one yet), and only the team owner sees these controls.

1. Create the repo on GitHub first. Roblox VSCode links an existing repo — it doesn't create one for you yet. Make an empty (or existing) repo on github.com under your account or org.
2. Link it from Studio. Open the plugin panel → Teams tab → 🐙 GitHub Integration card (owner-only). Type the repo as owner/repo (e.g. someuser/my-roblox-game) and click Link. Only one repo can ever be linked per project — if you need to change it, unlink first.
3. Push your project. Click 🚀 Push Project to GitHub. This sends the request to your running VS Code bridge, which does the actual work: on the very first push, VS Code will ask you to sign in with GitHub (its own built-in sign-in — no separate account or token to manage). Every push after that creates one real commit on the linked repo's default branch containing your current synced files.
4. Grant a teammate access. Still in the GitHub Integration card, type their GitHub username (not their Roblox username) and click Grant. This is recorded as "pending" immediately; the next time the owner's VS Code is running and connected, it sends a real GitHub collaborator invite via GitHub's API, and the status updates to "✅ invited" (or "⚠️ failed" if GitHub rejects it — e.g. the signed-in GitHub account isn't actually an admin on that repo). Your teammate gets a normal GitHub invite notification/email and accepts it on github.com like any other repo invite.
5. Unlinking. The same card has an "Unlink Repo" button (click twice to confirm) if you ever need to point the project at a different repo.

Note: pushing and inviting collaborators both require the team owner's VS Code to actually be running and connected — Studio's plugin only ever reads/writes the shared record in Firebase, the GitHub API calls themselves always happen from VS Code.

🚀 Previous Release: v1.0.2

Added

• Folders now sync both ways — creating or deleting even an empty folder in either VS Code or Studio is reflected on the other side. Previously a folder's existence was purely incidental to the files inside it.
• New Team tools — see when a teammate's plugin was last actually seen connecting, rename your team, or disband it entirely (owner-only, click-twice-to-confirm).

Fixed

• Pushing an updated GUI from VS Code could leave a duplicate behind in Studio instead of updating it in place — the GUI import path was missing the same cache bookkeeping every other apply path already had, which is what stops a just-applied change from being seen as "new" and echoed right back.
• Deletes and renames only ever covered scripts, Studio → VS Code — a folder or GUI deleted or renamed directly in Studio had no way to reach VS Code at all. Now handled the same way scripts already were.
• A real "Out of local registers" crash some users hit on load, from the What's New tab added in 1.0.1 pushing the Studio plugin's script past Luau's 200-local ceiling.
• Conflict diffs could look far noisier than the real change — a line-ending mismatch between a local CRLF file and Studio's LF content made every line show as changed even when nothing meaningful differed. Now normalized to match the local file.
• The Studio plugin's Tutorial tab skipped the pairing code and "Allow HTTP Requests" — the two things people actually get stuck on. Rewritten from 3 steps to 5 accurate ones; the website's matching section was fixed the same way.

🚀 Previous Release: v1.0.1

Added

• GUI edits made directly in Studio now sync to VS Code as .rbxmx files — previously only VS Code → Studio worked; a GUI built or changed straight in Studio had no way to reach VS Code at all.
• A new "What's New" tab in the Studio plugin, so you can see what changed without leaving Studio.

Fixed

• Pushing from both sides in quick succession could silently override the other's edit, in either direction. Both the conflict-detection baseline and Studio's own Push now correctly catch a genuine clash instead of one side quietly discarding the other.
• Cross-side content hashes rarely actually matched, due to a floating-point precision bug in the Studio plugin's hashing — a very plausible root cause behind conflicts that shouldn't have been flagged. Fixed.
• Renaming a script in Studio could leave a duplicate behind or lose the file.
• Two instances sharing a name (Roblox's own default for a new script/folder) no longer silently overwrite each other's synced file, on either sync direction.
• A path-traversal gap in project setup, hardened.
• Deleting a script in Studio and pressing "Push to VS Code" did nothing — deletions now sync correctly.
• A pending conflict could get silently stomped by a manual Push, and a conflict that resolved itself before you picked a side used to leave a stale prompt behind — both fixed.
• The conflict diff view's "Studio" side showed a cryptic temp file path. Replaced with a clear "VS Code (left) ↔ Studio (right)" label.
• A second open VS Code window's dashboard always showed an empty/disconnected state, even while sync was working fine elsewhere.
• Push / Force Sync could fail or hang for a full 2 minutes on a machine missing a VS Code internal component — sync no longer depends on it.

🚀 Previous Release: v1.0.0

We're out of Alpha! This release comes from actually testing the full push/pull/conflict workflow end-to-end for the first time and fixing what that turned up, plus a full visual redesign of the Studio plugin, the extension, and the website into one shared "Studio Light" cream/tan look.

💎 What's New in v1.0.0

• Studio Light redesign — the Studio plugin, all three VS Code panels, and the website now share one pastel palette, with a restructured tab bar (Main/Teams up front, everything else behind "More ▾") and a Credits page.
• Roblox OAuth sign-in for a verified Teams identity instead of typing your username by hand — approved by Roblox and live.
• A Conflicts tab in the Studio plugin — a real line-by-line diff of exactly what a sync conflict overwrote, with a heads-up banner, so it's not just a VS Code-side notification.
• "Show Team Members" command / Ctrl+Alt+T to see everyone on the current project's team without opening the full dashboard.
• Smarter Teams — ownership now transfers automatically if the owner leaves, owners can remove members, and joining a team no longer gets blocked by a stale membership record left over from a different project.

🛠️ What We Fixed

• Conflict resolution used to loop forever. Answering the "which version do you want" prompt didn't actually end it — the exact same prompt reopened on the next check, indefinitely, and the version you picked often never got delivered. Now answering it actually resolves it.
• "Keep Studio Version" used to silently do nothing. Studio was already overwriting the file with the VS Code version before you got a chance to choose, so asking to keep the Studio version just handed back the VS Code version in disguise. Studio now preserves your edit before that happens.
• Scripts needed to be closed and reopened to show a synced update. An already-open Script Editor tab wasn't refreshing on its own. Fixed by writing through the proper Studio API instead of a raw property write.
• A push could get permanently stuck. If delivery failed, the file looked "already synced" to every future push attempt — the only fix was editing it again. Now a failed delivery is retried automatically.
• Two never-saved places could silently overwrite each other's synced files. Each unsaved place now gets its own stable identity.
• A real crash the first time a conflict occurred (and a related permanent "stuck processing" state for that file afterward) — both fixed.
• Admins locked out of the admin panel if their role was ever stored with different capitalization. Now it's checked case-insensitively everywhere.

🚀 Previous Release: v0.11.0-Alpha

This update was about trust and control over your sync sessions: conflicts get a real resolution flow instead of a silent coin-flip, failures tell you why, and you get direct control over what syncs and how projects/code move between games.

🌐 Project Links

• Official Website: roblox-vscode.wasmer.app
• Roblox Community: Glitch Work Studios
• Documentation: Full Manual

💎 Detailed Overview

1. Conflict Resolution UI

Previously, if a file changed in both VS Code and Studio since the last sync, VS Code's version silently won. Now the conflicting change is held back and you're prompted to Compare & Choose, Keep VS Code Version, or Keep Studio Version — with a real diff view before you decide. Anytime a conflict is dismissed, revisit it with "Roblox Sync: Resolve Sync Conflicts".

2. Switch Active Project

Juggling multiple games no longer means restarting the bridge. "Roblox Sync: Switch Active Project" redirects the running server at a different previously-synced project (or a folder you browse to), with a warning if Studio looks like it's actively syncing right now.

3. Selective Sync

"Roblox Sync: Manage Selective Sync (Exclude Rules)" gives you a checkbox picker over your project's folders (plus custom patterns) instead of hand-editing ignorePatterns in settings.json.

4. Shared Library — Reuse Code Across Games

Export any script or folder to a local Shared Library (via the command palette or right-click in the Explorer), then import it into any other project with "Import from Shared Library." No more copy-pasting between VS Code windows.

5. Failures Now Say Why

When Studio can't apply a file — an unknown root folder, a class-creation error, a bad model import, the wrong instance type — the activity log used to just say "❌ Failed: file". It now includes the actual reason, that reason is reported back to VS Code's dashboard, and a file that's permanently given up on after repeated failures gets one clear final message instead of silently vanishing from the queue.

6. A Proper First-Time Setup Check

Installing just the Studio plugin without the VS Code extension used to mean your first "Connect" attempt failed with a bare "Connection Error" and no clue why. The plugin now shows a one-time welcome popup on first launch asking whether you already have the VS Code extension — with a copyable download link if you don't.

7. Teams

A new Teams tab in the Studio plugin. Create a team for the project you're working on (one team per project) and add your collaborators by Roblox username — or join one that already exists. Every person still runs their own local VS Code↔Studio bridge (there's no shared live session), but Teams adds a shared roster and a "who did what" activity feed on top of that, so you can see who pushed or pulled which file and when. Identity is a self-reported Roblox username (the same trust model the support ticket system already uses), and if you add someone whose install has never been seen connecting before, you'll get a heads-up so you know to check in with them.

8. What We Removed

• The Discord server. We're now on Roblox itself — join Glitch Work Studios instead. Bonus: Discord invite links were getting filtered by Roblox's own text moderation on the plugin listing; an in-platform community link doesn't have that problem.
• Dead OAuth scaffolding that never actually did anything — it read a settings key that didn't exist and had no route wired up to use it.
• The cors() middleware on the local sync server (see below — nothing needed it, and it was a real, if narrow, risk).

9. What We Fixed

• Stored XSS in the webviews. Ticket/chat messages were previously rendered as raw HTML, so a message could execute a script in another user's VS Code. Everything shared-backend-sourced is HTML-escaped now.
• Update checks that could silently stop working. Versions used to be compared as minor × 10, which breaks the moment a two-digit minor/major ships or a "-Alpha" tag is present. Now it's a real major.minor.patch comparison.
• A brute-forceable pairing code. /init had no rate limit, so a malicious local webpage could hammer it with 6-digit guesses. Now it locks out after repeated failures.
• Wide-open CORS on the local server — removed. Nothing legitimate ever needed it, and it let any locally-running webpage read the server's responses.
• Two ways the Shared Library feature could delete your project or write outside its folder. Both closed.
• Duplicate conflict pop-ups when Studio was slow to respond, and an auto-resolve timer that could silently override your "Keep Studio Version" choice if Studio took more than 2 minutes to answer. Both fixed.
• A broken release banner on the homepage and broken share-link previews on every page of the site — both were pointing at image files that didn't exist. Fixed.
• A real secret shipping inside every VSIX. .vscodeignore never excluded the admin tool's folder, so an encryption key was bundled into every release build, including ones already downloaded. It's excluded now, and the key has been rotated.
• A broken update-notification feature. The code that shows "Update Available" referenced the plugin's own panel before it existed in the script, which threw an error every time an update was detected instead of showing anything. Also fixed the notification's claim that a download page "opened in your browser" — Studio plugins can't do that, so it now shows a copyable link instead of pretending.
• The dashboard now keeps a rolling log of recent errors instead of only ever showing the last one.

📦 Download & Installation

1. Get the VS Code Extension from the Official Release Page.
2. Install the Roblox Plugin from the Roblox Creator Store.
3. Follow the interactive tutorial that will automatically launch when you first open the tools!

Developed with ❤️ by CodingJeff © 2026