Learn what Rojo is, why Roblox developers use it, and how to set up a professional development workflow with Visual Studio Code and Git.

Difficulty: Beginner
Estimated Reading Time: 15–20 minutes

Table of Contents

• What Is Rojo?
• Why Should You Use Rojo?
• Should Beginners Learn Rojo?
• How Rojo Works
• Installing Rojo
• Creating Your First Rojo Project
• Understanding the Project Structure
• VS Code and Git Workflow
• Common Beginner Mistakes
• Frequently Asked Questions
• Final Thoughts

What Is Rojo?

As your Roblox games become more complex, writing every script directly inside Roblox Studio can become difficult to manage. Large projects often contain hundreds of scripts, modules, and assets, making organization and collaboration increasingly challenging.

That’s where Rojo comes in.

Rojo is an open-source synchronization tool that allows you to develop Roblox games using files stored on your computer instead of keeping all of your code inside a Roblox place file.

Instead of writing scripts only inside Roblox Studio, you can use a professional code editor like Visual Studio Code, organize your project into folders, and let Rojo synchronize everything back into Studio automatically.

Think of Rojo as a bridge between your local project and Roblox Studio.

Without Rojo

Roblox Studio
├── ServerScriptService
│   └── Main Script
├── ReplicatedStorage
└── StarterPlayer

All of your scripts live inside the Roblox place file.

With Rojo

MyGame
├── src
│   ├── ServerScriptService
│   │   └── Main.server.lua
│   ├── ReplicatedStorage
│   ├── StarterPlayer
│   └── StarterGui
├── default.project.json
└── README.md

Your code is now stored as regular files on your computer, making it much easier to organize, edit, and track changes.

It’s important to understand that Rojo does not replace Roblox Studio. You’ll still use Studio to build maps, create user interfaces, test gameplay, and publish your experience. Rojo simply improves how you manage your source code.

Why Should You Use Rojo?

If you’re creating a small practice project, Roblox Studio‘s built-in editor is often enough. However, once your projects become larger or you start working with other developers, Rojo provides several major benefits.

Better Organization

A typical Roblox game can quickly grow to include dozens or even hundreds of scripts. Keeping everything inside Roblox Studio’s Explorer becomes increasingly difficult.

Rojo lets you organize your project using a familiar folder structure.

src
├── ServerScriptService
├── ReplicatedStorage
├── StarterGui
└── StarterPlayer

This makes it much easier to navigate your project and keep related files together.

Use Professional Development Tools

Rojo allows you to write code using modern editors such as Visual Studio Code.

Compared to Roblox Studio’s built-in editor, you’ll gain access to features like:

• Intelligent code completion
• Faster navigation
• Project-wide search
• Git integration
• Automatic code formatting
• AI coding assistants
• Extension support

These tools can significantly improve your productivity.

Version Control with Git

Because your scripts are stored as normal files, Git can track every change you make.

This makes it easy to:

• Restore previous versions
• Create feature branches
• Collaborate with teammates
• Review code changes
• Keep a complete history of your project

Without Rojo, Git mainly sees changes to the entire Roblox place file rather than individual scripts.

Better Team Collaboration

When multiple developers work on the same game, Rojo makes collaboration much easier.

Each developer can work on different files without constantly overwriting each other’s changes. Combined with Git, this creates a workflow that’s similar to modern game engines like Unity or Unreal Engine.

Should Beginners Learn Rojo?

Yes—but not on your first day.

If you’re completely new to Roblox development, start by learning the basics inside Roblox Studio.

Focus on understanding:

• Variables
• Functions
• Loops
• Events
• Services
• ModuleScripts
• The Explorer window

Once you’re comfortable creating small projects, learning Rojo becomes much easier.

A good learning path looks like this:

1. Learn Roblox Studio.
2. Learn Luau scripting.
3. Build a few simple games.
4. Learn the basics of Git.
5. Install Visual Studio Code.
6. Start using Rojo.

This progression allows you to understand why Rojo exists before adding it to your workflow.

How Rojo Works

Rojo synchronizes files between your computer and Roblox Studio.

The workflow is straightforward:

VS Code
    ↓
Local Files
    ↓
Rojo
    ↓
Roblox Studio

Whenever you save a file in Visual Studio Code:

1. Rojo detects the change.
2. The updated file is synchronized.
3. Roblox Studio refreshes automatically.
4. You can immediately test your game.

This allows you to write code in a professional editor while continuing to use Roblox Studio for building and testing.

Installing Rojo

Now that you understand what Rojo is and why developers use it, it’s time to install it and create your first Rojo project.

The setup process isn’t complicated, but it does involve a few tools working together. Once everything is configured, your development workflow becomes much faster and more enjoyable.

By the end of this section, you’ll have:

• Rojo installed
• Visual Studio Code ready for Roblox development
• Your first Rojo project created
• Live synchronization with Roblox Studio

Prerequisites

Before installing Rojo, make sure you already have:

• Roblox Studio
• A Roblox account
• Visual Studio Code installed
• A stable internet connection

Although it’s optional for this guide, installing Git is highly recommended since most professional Roblox developers use it alongside Rojo.

Step 1: Install Rojo

The recommended way to install Rojo today is by using Rokit, the official Roblox toolchain manager.

Using Rokit makes it easy to install and update Rojo without manually downloading executable files.

Note: Older tutorials may recommend downloading the Rojo executable directly or installing it through Cargo. While those methods may still work, Rokit is the approach recommended by the Rojo project for new users.

After installing Rojo, open a terminal and verify the installation:

rojo --version

If you see a version number, you’re ready to continue.

Step 2: Install the Rojo Studio Plugin

The command-line application isn’t enough by itself.

Roblox Studio also needs the official Rojo Studio Plugin so it can communicate with the running Rojo server.

To install it:

1. Open Roblox Studio.
2. Open the Creator Store.
3. Search for Rojo.
4. Install the official plugin.
5. Restart Roblox Studio if necessary.

After installation, you’ll see the Rojo plugin in Studio’s toolbar.

Step 3: Create Your Project Folder

Create a new folder anywhere on your computer.

For example:

MyFirstRojoGame

Open this folder in Visual Studio Code.

At the moment, it’s completely empty.

We’ll build the project structure ourselves.

Step 4: Create default.project.json

Every Rojo project starts with a configuration file called:

default.project.json

Create this file inside the project’s root folder.

Add the following configuration:

{
    "name": "MyFirstRojoGame",

    "tree": {
        "$className": "DataModel",

        "ReplicatedStorage": {
            "$path": "src/ReplicatedStorage"
        },

        "ServerScriptService": {
            "$path": "src/ServerScriptService"
        },

        "StarterGui": {
            "$path": "src/StarterGui"
        },

        "StarterPlayer": {
            "$path": "src/StarterPlayer"
        }
    }
}

Don’t worry if this configuration doesn’t make complete sense yet.

We’ll explain each part later in the guide.

Step 5: Create the Source Folder

Next, create a folder called:

src

Inside it, create folders for the Roblox services you’ll use.

Your project should now look like this:

MyFirstRojoGame
│
├── default.project.json
│
└── src
    ├── ReplicatedStorage
    ├── ServerScriptService
    ├── StarterGui
    └── StarterPlayer

This structure mirrors the services you’ll see inside Roblox Studio.

Step 6: Create Your First Script

Inside the ServerScriptService folder, create a file named:

Main.server.lua

Add a simple script:

print("Hello from Rojo!")

At this point, the script exists only on your computer.

The next step is connecting it to Roblox Studio.

Step 7: Start the Rojo Server

Open VS Code’s integrated terminal and navigate to your project folder.

Run:

rojo serve

If everything is configured correctly, Rojo will start listening for connections.

Leave this terminal open while you develop.

Whenever you save a file, Rojo will automatically synchronize your changes.

Step 8: Connect Roblox Studio

Open your Roblox place in Studio.

Launch the Rojo plugin.

Connect it to the running Rojo server.

If the connection succeeds, you’ll immediately see your folders appear inside the Explorer.

For example:

ServerScriptService
    Main.server.lua

ReplicatedStorage

StarterGui

StarterPlayer

Although these scripts appear inside Roblox Studio, they’re actually managed from the files stored on your computer.

Test Live Synchronization

Let’s confirm everything is working.

Open:

Main.server.lua

Change:

print("Hello from Rojo!")

to:

print("Rojo is working!")

Save the file.

Switch back to Roblox Studio.

Within a second or two, the script should update automatically.

Congratulations! You’ve successfully synchronized your first Roblox script using Rojo.

Understanding What’s Happening

It’s easy to think that Roblox Studio is reading your code directly from your hard drive.

That’s not quite how it works.

Instead, the process looks like this:

VS Code
    │
    ▼
Local Files
    │
    ▼
Rojo Server
    │
    ▼
Roblox Studio

Whenever you save a file:

1. VS Code writes the changes to disk.
2. Rojo detects the modification.
3. Rojo synchronizes the updated script.
4. Roblox Studio refreshes the corresponding instance.

This process is fast enough that it usually feels instant.

Common Setup Problems

'rojo' is not recognized

This usually means:

• Rojo isn’t installed correctly.
• Your terminal hasn’t been restarted.
• The executable isn’t available in your system’s PATH.

Restart your terminal after installation and try again.

The Plugin Can’t Connect

If Roblox Studio can’t connect to Rojo:

• Make sure rojo serve is still running.
• Verify that the Studio plugin is installed.
• Check for errors in the terminal.
• Confirm that your default.project.json file is valid.

Nothing Appears in Explorer

This is usually caused by one of the following:

• The src folder doesn’t exist.
• Folder names don’t match your configuration.
• default.project.json contains an error.
• The project wasn’t connected successfully.

What You’ve Learned

At this point, you’ve successfully:

• Installed Rojo
• Installed the Studio plugin
• Created your first Rojo project
• Built a basic project structure
• Connected Roblox Studio
• Tested live synchronization

Your development environment is now ready.

The next step is learning how to organize your project so it stays clean and maintainable as it grows. We’ll look at where different types of scripts belong, how to structure folders, and the conventions used by experienced Roblox developers.

Organizing Your Rojo Project

One of the biggest advantages of Rojo is that it encourages a clean, scalable project structure.

When you’re building your first game, it might not seem important where you place your scripts. But as your project grows, good organization can save you countless hours of debugging and maintenance.

Instead of keeping everything in one place, organize your project by responsibility.

A Simple Project Structure

A beginner-friendly Rojo project might look like this:

MyGame
│
├── default.project.json
├── README.md
├── .gitignore
│
└── src
    ├── ReplicatedStorage
    ├── ServerScriptService
    ├── StarterPlayer
    ├── StarterGui
    └── Workspace

This mirrors Roblox Studio while keeping your source code organized on your computer.

Understanding Each Folder

Let’s look at what each folder is typically used for.

ReplicatedStorage

ReplicatedStorage is shared between the server and all clients.

It’s the best place for code and data that both sides need to access.

Common examples include:

• ModuleScripts
• RemoteEvents
• RemoteFunctions
• Shared configuration
• Utility modules

Example:

ReplicatedStorage
│
├── Modules
├── Config
├── Shared
└── Remotes

If both your server and client need access to something, ReplicatedStorage is usually the right place for it.

ServerScriptService

Everything inside ServerScriptService runs only on the server.

Players cannot directly execute these scripts.

Typical examples include:

• Data saving
• Combat validation
• NPC AI
• Matchmaking
• Economy systems
• Leaderboards
• Quest systems

Example:

ServerScriptService
│
├── Services
├── Systems
├── NPC
└── Main.server.lua

As a general rule, anything that should remain secure belongs on the server.

StarterPlayer

Scripts inside StarterPlayerScripts run on the client when a player joins the game.

They’re commonly used for:

• Camera controls
• Input handling
• Client-side effects
• UI interactions
• Character-related logic

Example:

StarterPlayer
└── StarterPlayerScripts
    ├── CameraController
    ├── SprintController
    └── Client.client.lua

StarterGui

StarterGui contains your game’s user interface.

Examples include:

• Main Menu
• HUD
• Inventory
• Shop
• Settings
• Dialogue

A clean UI structure might look like this:

StarterGui
│
├── HUD
├── MainMenu
├── Inventory
├── Shop
└── Settings

Grouping related UI together makes future updates much easier.

Workspace

Workspace contains the objects that exist in the game world.

Examples include:

• Buildings
• Terrain
• Spawn locations
• NPCs
• Interactive objects
• Decorative props

Although Rojo can synchronize Workspace, many developers prefer to build environments directly in Roblox Studio because it’s faster and more convenient for level design.

Where Should ModuleScripts Go?

One of the most common beginner questions is where ModuleScripts should live.

In most projects, shared modules belong inside ReplicatedStorage.

Example:

ReplicatedStorage
└── Modules
    ├── Inventory
    ├── Weapons
    ├── MathUtil
    └── UI

Keeping reusable code in one location makes it easier to find and maintain.

Organize by Feature

As your game grows, organizing files by feature instead of script type often works better.

For example:

Modules
│
├── Combat
│   ├── DamageCalculator
│   ├── WeaponData
│   └── HitDetection
│
├── Inventory
│   ├── InventoryManager
│   ├── ItemDatabase
│   └── ItemData
│
└── Pets
    ├── PetData
    ├── PetManager
    └── PetStats

This approach keeps related code together, making it easier to understand each system.

Use Clear File Names

Good file names make your project easier to navigate.

Examples:

InventoryService
QuestService
PlayerData
WeaponConfig
DamageCalculator

Avoid generic names like:

Script1
Test
Module
NewScript
Stuff

A descriptive name tells you what a file does without opening it.

Keep Configuration Separate

Avoid scattering configuration values throughout your scripts.

Instead, create a dedicated configuration folder.

Example:

ReplicatedStorage
└── Config
    ├── Weapons.lua
    ├── Enemies.lua
    ├── Items.lua
    └── GameSettings.lua

This makes balancing your game much easier later.

Common Beginner Mistakes

Putting Everything in One Folder

This quickly becomes difficult to manage.

Instead of:

ServerScriptService
├── Script1
├── Script2
├── Script3
├── Script4
├── Script5

Use folders:

ServerScriptService
├── Services
├── Systems
├── NPC
├── Data
└── Main.server.lua

Mixing Client and Server Code

Server code belongs in ServerScriptService.

Client code belongs in StarterPlayerScripts or StarterGui.

Keeping them separate improves security and makes your project easier to understand.

Creating Deep Folder Structures

Avoid nesting folders unnecessarily.

For example:

Modules
└── Folder1
    └── Folder2
        └── Folder3
            └── Folder4
                └── Module.lua

If you struggle to remember where a file is, your structure is probably too deep.

Aim for a layout that’s easy to scan.

Best Practices

As your projects become more complex, these habits will help keep your codebase manageable:

• Mirror Roblox services inside your src folder.
• Group related scripts together.
• Keep reusable modules in one place.
• Use descriptive file names.
• Avoid unnecessary folder nesting.
• Separate client and server code.
• Build a structure that can grow with your game.

Remember, there isn’t a single “correct” project structure. The best structure is one that’s consistent, easy to understand, and works well for your team.

VS Code and Git Workflow

Now that your project is organized, it’s time to look at the tools that make Rojo so powerful.

Rojo isn’t just about synchronizing files—it’s about enabling a modern development workflow.

Most Roblox developers using Rojo also use:

• Visual Studio Code for writing code.
• Git for version control.
• GitHub for backups and collaboration.

Together, these tools create a workflow that’s similar to those used in Unity, Unreal Engine, and other professional game development environments.

In the next section, we’ll see how these tools work together and how you can start using them in your own Roblox projects.

VS Code and Git Workflow

Rojo becomes truly powerful when you combine it with Visual Studio Code and Git. Together, these tools create a modern development workflow that’s faster, more organized, and better suited for both solo developers and teams.

Instead of writing code directly inside Roblox Studio, you’ll spend most of your time in VS Code, while Rojo keeps everything synchronized behind the scenes.

Why Use Visual Studio Code?

Visual Studio Code (VS Code) is one of the most popular code editors among Roblox developers.

Compared to Roblox Studio’s built-in script editor, VS Code offers:

• Faster performance
• Better code navigation
• Intelligent auto-completion
• Powerful search and replace
• Built-in Git support
• AI coding assistants
• Thousands of useful extensions

As your project grows, these features can save a significant amount of time.

A Typical Development Workflow

Once your project is set up, your daily workflow becomes simple.

1. Open your Rojo project in VS Code.
2. Start the Rojo server.
3. Connect Roblox Studio.
4. Write or edit your scripts.
5. Save the file.
6. Test the changes in Roblox Studio.

The process looks like this:

Edit Code
     │
     ▼
Save File
     │
     ▼
Rojo Synchronizes
     │
     ▼
Roblox Studio Updates
     │
     ▼
Press Play and Test

There’s no need to manually copy and paste scripts between applications.

Using Git with Rojo

Git is a version control system that records changes to your project over time.

Think of it as a “save history” for your entire codebase.

With Git, you can:

• Undo mistakes
• Restore older versions
• Experiment safely
• Work on new features without affecting the main project
• Collaborate with other developers

Because Rojo stores your scripts as regular files, Git can track changes to each file individually.

This is one of the biggest reasons professional Roblox developers choose Rojo.

Creating a Git Repository

Inside your project folder, initialize Git:

git init

Git will create a hidden .git folder that stores your project’s history.

Next, create a .gitignore file.

A simple example might look like this:

*.rbxl
*.rbxlx

sourcemap.json

This prevents temporary or generated files from being committed accidentally.

Tip: The exact contents of your .gitignore may vary depending on the tools you use. Always review what Git is tracking before committing.

Making Your First Commit

Once you’ve created your project files, you can save your first snapshot.

git add .

Then create a commit:

git commit -m "Initial Rojo project setup"

A commit acts like a checkpoint.

If something breaks later, you can return to this version.

Why Small Commits Are Better

Many beginners make one huge commit after hours of work.

Instead, commit after completing a small task.

For example:

✅ Good commit messages

• Add inventory system
• Fix NPC pathfinding
• Create shop interface
• Update weapon configuration

❌ Less helpful commit messages

• Update
• Stuff
• Changes
• Fix

Clear commit messages make your project’s history much easier to understand.

Working with GitHub

Although Git works perfectly on your computer, many developers also upload their repositories to GitHub.

This provides several benefits:

• Cloud backup
• Team collaboration
• Pull requests
• Issue tracking
• Access from multiple computers

GitHub isn’t required to use Rojo, but it’s highly recommended for long-term projects.

Recommended VS Code Extensions

You don’t need dozens of extensions to get started.

These are some of the most useful ones for Roblox development.

Install only what you need. Too many extensions can slow down your editor.

Common Beginner Mistakes

Editing Scripts Inside Roblox Studio

When using Rojo, your source of truth should be the files on your computer.

If you frequently edit synchronized scripts inside Roblox Studio, those changes can be overwritten the next time Rojo synchronizes.

Whenever possible, make your code changes in VS Code.

Forgetting to Commit

It’s easy to become absorbed in development and forget to save your progress with Git.

Making regular commits creates restore points and protects your work.

Committing Everything

Before committing, check which files Git is about to include.

Temporary files, build artifacts, and generated files usually don’t belong in your repository.

Reviewing your changes before each commit helps keep your project clean.

Best Practices

As you continue building Roblox games with Rojo, these habits will make your workflow smoother:

• Write your code in VS Code.
• Use Roblox Studio for building, testing, and publishing.
• Commit your work frequently.
• Use descriptive commit messages.
• Keep your project structure organized.
• Back up important projects using GitHub.

Following these practices from the beginning will make it much easier to maintain your projects as they grow.

Frequently Asked Questions

Is Rojo required for Roblox development?

No.

You can build complete Roblox games using only Roblox Studio.

However, Rojo provides a more professional workflow that becomes increasingly valuable as your projects become larger or involve multiple developers.

Does Rojo replace Roblox Studio?

No.

Rojo is a synchronization tool, not a game engine or editor.

You’ll still use Roblox Studio to:

• Build maps
• Create UI
• Test gameplay
• Publish your experience

Rojo simply manages your source code outside of Studio.

Is Rojo difficult to learn?

Not really.

If you’re already comfortable with Roblox Studio and basic Luau scripting, most developers can learn the fundamentals of Rojo in a few hours.

Understanding Git alongside Rojo may take a little longer, but it’s a worthwhile investment for anyone serious about Roblox development.

Can I use Rojo for solo projects?

Absolutely.

While Rojo is excellent for team collaboration, many solo developers use it because of its better organization, Git integration, and support for professional code editors.

Should I learn Git before Rojo?

It’s not required, but having a basic understanding of Git will help you get more out of Rojo.

Even learning simple commands like git init, git add, and git commit is enough to get started.

Final Thoughts

Rojo has become an essential tool in the Roblox development ecosystem because it brings modern software development practices into game creation.

Instead of keeping all of your scripts inside a single Roblox place file, Rojo lets you organize your code into a structured project, edit it with professional tools like Visual Studio Code, and track every change using Git.

If you’re just starting out, focus on learning Roblox Studio and Luau first. Once you’re comfortable building small games, adding Rojo to your workflow is a natural next step that will make your projects easier to manage as they grow.

The sooner you adopt good development habits, the easier it becomes to build larger, more maintainable Roblox experiences—whether you’re working alone or as part of a team.