How to make a game in Roblox Studio, step by step

What you will build

The game is a short course. Players start at the SpawnLocation, jump between platforms over a lava floor, pick up coins and touch a green Finish pad. The Finish gives a Win only to a player who picked up at least 3 coins since they last spawned or finished, and then sends them back to the start. Coins and Wins show on the player list, and every rule runs on the server.

Workspace
  Baseplate Part
  SpawnLocation SpawnLocation
  Course Folder new
    Platform Part new
    Lava Folder new
      Lava Part new
    Coins Folder new
      Coin Part new
    Finish Part new
ServerScriptService
  PlayerStats Script new
  CourseService Script new

You build everything in Workspace by hand in Step 2. The two scripts go in ServerScriptService. Roblox never sends the scripts in that container to players, so nobody can read or change them from their own device.

Step 1: Install Studio and open a Baseplate

1. Download Roblox Studio from Roblox's Creator Hub and run the installer (RobloxStudio.exe on Windows, RobloxStudio.dmg on Mac). Studio is a free app for Windows and Mac.
2. When it opens, sign in with your Roblox account. If you do not have one, create one at roblox.com first.
3. In the Open a Template section, pick Baseplate. It starts with only two objects: a SpawnLocation, where characters appear and respawn, and the Baseplate, a floor with a 4 by 4 grid texture that lines up with studs, Roblox's unit of length.
4. Open three windows you will use all the time. Explorer lists every object in your game, and Properties changes the object you select; both open from the Window menu or the Home tab. Output shows errors from your scripts, and opens from the Window menu or the Script tab.

Step 2: Build the course

1. In the Explorer, hover over Workspace, click the + button (or press Ctrl+I, Cmd+I on a Mac) and insert a Folder. Rename it Course.
2. Hover over Course, click +, and insert two more Folders inside it. Name them Lava and Coins.
3. Build the lava floor. Click Part on the Home or Model tab to insert a block, then use the Scale tool to stretch it into one big, flat slab that will lie under the whole course, with plenty of room on every side. In Properties, set its Color to red and its Material to Neon, tick Anchored, and drag it into the Lava folder. Now a player who falls off anywhere lands in lava, not on the Baseplate.
4. Build the platforms. Insert more parts the same way and use the Move and Scale tools to place them on top of the lava, each one standing a few studs clear of it, with gaps to jump between them. In Properties, make sure Anchored is ticked on each one, and drag them into Course.
5. Build the coins. Hold the small arrow on the Part button and choose Cylinder. Make it small and yellow, tick Anchored, and untick CanCollide so players walk through it instead of bumping into it. Put it in the Coins folder, then press Ctrl+D (Cmd+D on a Mac) to duplicate it until you have at least 3, and spread them above the platforms along the course.
6. Build the finish. Insert one more part on top of the lava at the far end, big enough to land on, colour it green, tick Anchored, name it exactly Finish, and drag it directly into Course, not into one of the folders.
7. Move the SpawnLocation onto the lava at the start of the course, next to your first platform, so it sits on top of the slab. Keep it directly in Workspace, not inside Course: CourseService looks for it there to send players back to the start.

Names matter

CourseService finds the course by name: a folder called Course directly in Workspace, the folders Lava and Coins inside it, and a part called Finish inside it. Spell them exactly, with the same capital letters. The names of the lava parts and the coins do not matter: every part directly inside Lava is lava, and every part directly inside Coins is a coin.

Step 3: Add Coins and Wins to the player list

In the Explorer, hover over ServerScriptService, click +, insert a Script and name it PlayerStats. Replace everything in it with this:

-- Script in ServerScriptService named PlayerStats.
-- Gives every player a Coins and a Wins stat. A folder named leaderstats inside the
-- player makes Roblox show these values in the player list at the top right.

local Players = game:GetService("Players")

local function onPlayerAdded(player: Player)
	local leaderstats = Instance.new("Folder")
	leaderstats.Name = "leaderstats" -- must be spelled exactly like this

	local coins = Instance.new("IntValue")
	coins.Name = "Coins"
	coins.Value = 0
	coins.Parent = leaderstats

	local wins = Instance.new("IntValue")
	wins.Name = "Wins"
	wins.Value = 0
	wins.Parent = leaderstats

	leaderstats.Parent = player
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do -- anyone who joined before this line ran
	onPlayerAdded(player)
end

Each player gets a Folder named leaderstats with two IntValue objects in it. An IntValue holds a whole number, which is all a coin count needs. The loop at the end sets up any player who joined before the PlayerAdded line ran, so nobody is missed.

The leaderboard guide builds the same folder in more detail, and later adds saving and a global top 10.

Step 4: Make the lava, coins and finish work

Insert a second Script into ServerScriptService, name it CourseService, and paste this in. It is the only place Coins and Wins change. The two settings at the top are the numbers you are meant to change.

-- Script in ServerScriptService named CourseService.
-- Runs the course on the server, so every player sees the same thing and nobody can
-- give themselves coins: lava parts reset players, coins pay 1 Coin and come back,
-- and the Finish pad gives a Win to players who collected enough coins on this run.

local Players = game:GetService("Players")

local COINS_TO_FINISH = 3 -- coins a player must collect on a run before Finish counts
local COIN_RESPAWN_SECONDS = 10

local course = workspace:WaitForChild("Course")
local lavaFolder = course:WaitForChild("Lava")
local coinFolder = course:WaitForChild("Coins")
local finish = course:WaitForChild("Finish") :: BasePart
local spawnLocation = workspace:FindFirstChildOfClass("SpawnLocation")
if not spawnLocation then
	warn("CourseService: no SpawnLocation directly in Workspace, so the Finish cannot send players back")
end

-- Coins collected on this run: since the player last spawned or reached the Finish
local runCoins: { [Player]: number } = {}

-- Finds the player whose character touched a part, or nil for anything else
local function playerFromHit(otherPart: BasePart): Player?
	local character = otherPart:FindFirstAncestorOfClass("Model")
	return if character then Players:GetPlayerFromCharacter(character) else nil
end

local function addStat(player: Player, statName: string, amount: number)
	local leaderstats = player:FindFirstChild("leaderstats")
	local stat = leaderstats and leaderstats:FindFirstChild(statName)
	if stat and stat:IsA("IntValue") then
		stat.Value += amount
	end
end

-- Lava: any part in the Lava folder resets the player who touches it
for _, lava in lavaFolder:GetChildren() do
	if lava:IsA("BasePart") then
		lava.Touched:Connect(function(otherPart: BasePart)
			local character = otherPart:FindFirstAncestorOfClass("Model")
			local humanoid = character and character:FindFirstChildOfClass("Humanoid")
			if humanoid and humanoid.Health > 0 then
				humanoid.Health = 0
			end
		end)
	end
end

-- Coins: the first player to touch a coin gets it, then it hides until it respawns
for _, coin in coinFolder:GetChildren() do
	if coin:IsA("BasePart") then
		local shownTransparency = coin.Transparency
		local taken = false
		coin.Touched:Connect(function(otherPart: BasePart)
			local player = playerFromHit(otherPart)
			if not player or taken then
				return -- not a player, or this coin was already taken
			end
			taken = true
			coin.Transparency = 1
			addStat(player, "Coins", 1)
			runCoins[player] = (runCoins[player] or 0) + 1
			task.delay(COIN_RESPAWN_SECONDS, function()
				coin.Transparency = shownTransparency
				taken = false
			end)
		end)
	end
end

-- Finish: a Win for players who did the course, then back to the start
finish.Touched:Connect(function(otherPart: BasePart)
	local player = playerFromHit(otherPart)
	if not player or (runCoins[player] or 0) < COINS_TO_FINISH then
		return
	end
	runCoins[player] = 0 -- set first, so touching the pad again does not count twice
	addStat(player, "Wins", 1)
	local character = player.Character
	if character and spawnLocation then
		character:PivotTo(spawnLocation.CFrame + Vector3.new(0, 4, 0))
		player:SetAttribute("MovementCheckSkip", true) -- for a speed check script, if you add one
	end
end)

-- A new character (after a reset or a fall) starts a new run
local function onPlayerAdded(player: Player)
	runCoins[player] = 0
	player.CharacterAdded:Connect(function()
		runCoins[player] = 0
	end)
end

Players.PlayerAdded:Connect(onPlayerAdded)
for _, player in Players:GetPlayers() do -- anyone who joined while this script waited for Course
	onPlayerAdded(player)
end

Players.PlayerRemoving:Connect(function(player: Player)
	runCoins[player] = nil
end)

The lava sets Health to 0, as Roblox's own lava tutorial does. A new character has a ForceField for 10 seconds after spawning at a SpawnLocation, by default, and Humanoid:TakeDamage does nothing while one protects it. Setting Health directly ignores ForceFields, so the lava works even right after a respawn.

The Finish moves the character with character:PivotTo(...), which Roblox's reference calls the primary way to move a model from a script. Setting the position of the character's root part instead moves that one part away from the rest of the body.

The MovementCheckSkip line does nothing on its own. It is there for the server speed check in the sprint guide: if you add that check later, the Finish teleport is not flagged as speeding.

Why the rules run on the server

Every rule on this course lives in CourseService, a server Script, on purpose. If a LocalScript added the coin, the new Coins value would exist only on that player's device: the server and the other players would never see it. And anything on a player's device can be changed. Roblox's security guide says an exploiter "has complete control over their local state and network traffic", so the server has to make every decision that matters.

So the coin rule stops the simplest cheat, a jump straight to the end, and not much more. That is normal for a first game. The next layers are a server check that a character is actually near a coin or the Finish before it pays, the way Roblox's security guide checks a player's distance from a shop; checkpoints that must be reached in order, as in the obby checkpoints guide; and a movement check like the one in the sprint guide. What replicates and what does not explains the client and server split in more detail.

Step 5: Playtest it

1. Make sure Test is selected in the test mode dropdown, then press Play (F5). Your name appears on the player list with Coins 0 and Wins 0.
2. Walk into a coin. Coins goes to 1 and the coin disappears. Wait 10 seconds and it comes back. Walk into it again: Coins goes up to 2.
3. Touch the lava. Your character is knocked out and appears at the SpawnLocation again after 5 seconds, Roblox's default respawn time. Coins on the player list stays the same, but your count for this run starts again at 0.
4. Touch the Finish with fewer than 3 coins on this run: nothing happens. Collect 3 coins, then touch it: Wins goes to 1 and you drop back onto the SpawnLocation.
5. Press Stop (Shift+F5). Choose Server & Clients in the dropdown, set 2 clients and press Play (or F7). Take a coin in one client window and look at the other: the coin is gone there too, because the server hid it for everyone.

Keep the Output window open the whole time. These two scripts print nothing when they work, so any warning or red error from PlayerStats or CourseService is a real problem. See Common errors.

Step 6: Publish your game

1. Open the File menu and choose Publish. The Game details window opens.
2. Type a Name, pick a Genre (the Subgenre is optional) and write a short Description of what players do. You can also upload an icon and a thumbnail here.
3. Click Save. Roblox publishes the game to the cloud and connects it to your account, so you can open it from any computer.
4. The game is now published but private. Only you, people with Edit access and group members with the right roles can play it.
5. Want feedback before you release it? Choose File > Invite early testers and pick up to 10 similar-aged friends. If you have not completed an age check yet, Roblox asks you to do one first. Testers see a watermark that tells them the game is a preview.

From now on, saving to Roblox from the File menu keeps a version of your place in the cloud. File > Publish is what changes the version players get. Now and then, play the published copy from Roblox, outside Studio, to check it matches what you tested.

Step 7: Release it (make your game public)

Releasing is how you make your game public, so people other than you and your collaborators can play it. Before you start, check the requirements: your account must be in good standing and at least 2 days old, and you need an age check, done through facial age estimation or a government ID.

1. Open the File menu and choose Publish again. The Publish window opens.
2. Click Continue. (The Invite button next to it invites early testers instead.)
3. Answer the first question of Roblox's Maturity & Compliance Questionnaire: does your game contain age-restricted content? Answer for what your game actually contains. If you answer Yes, you complete the whole questionnaire.
4. Click Publish.

To let only your friends in, open the Creator Dashboard, select the game, go to Publish settings > Manage Audience, click Manage access, turn on Friends on the Public tab and click Save Changes. With Friends on, only your friends and the people on the Playtest tab can play.

The same requirements apply to every release action: the first release, releasing a new version of a game that is already out, releasing to another game with Publish As, and changing who can play.

Make it with friends

Studio's collaboration tools let you and a friend edit the same place at the same time. For a game you own:

1. With the game open in Studio, click Collaborate on the right side of the mezzanine, the bar whose left side holds the Play button.
2. Search for your friend, select them, choose Edit in the permissions dropdown and click Save. For a game you own, only Roblox friends can get Edit access.
3. Your friend opens the game from the Creator Dashboard, and you both work in the same place at once.

To collaborate with other creators, you first complete an age check, by ID or facial age estimation. After that, by default, Studio lets you collaborate only with creators in compatible age groups. You can use Team Create on your own without an age check. During a collaborative session, Studio saves the place to the cloud every four minutes.

Make it a real game

The course is a complete loop: play, collect, finish, win. Each of these guides adds one system on top of it.

• New to scripts? How to script in Roblox Studio covers variables, functions, events and loops, the pieces CourseService is made of.
• Save Coins and Wins between sessions with Step 3 of the leaderboard guide. Its saving script replaces a Coins and Wins script like PlayerStats, so delete PlayerStats when you add it. The DataStore tutorial explains saving in depth.
• Checkpoints in order, with a Stage stat and respawning at the last checkpoint: the obby checkpoints guide. Its script makes its own leaderstats folder, so copy the Coins and Wins lines from PlayerStats into that folder and delete PlayerStats. Two scripts that each make leaderstats give every player two folders, and Coins and Wins can stop changing.
• Spend the Coins in a shop GUI. It uses the Coins value in leaderstats, so skip its Leaderstats script: PlayerStats already makes Coins.
• A title screen with a Play button: the main menu guide.
• Rounds with an intermission, random maps and a timer: the round system guide, which adds to the same Wins value. Skip its leaderstats script, because PlayerStats already makes Wins.
• An intro cutscene with camera shots, captions and a Skip button: the cutscene guide.
• A door to a secret area that opens with E, with an optional key lock: the door guide.
• Teleporter pads between parts of the map, or a teleport menu: the teleporter guide.
• A speed check on the server: the sprint guide's movement check, which reads the MovementCheckSkip attribute the Finish sets.

Common errors and fixes

Open the Output window (Window menu or Script tab) before you press Play. Most problems on this course either print a warning or an error there, or come from a name that does not match.

Build it with RoCode

If you would rather describe the game than build every piece by hand, RoCode can build it in the place you have open. RoCode is an independent AI agent for Roblox Studio, not made by Roblox: you describe the feature in its web chat, and its Studio plugin creates the parts and the scripts in your Explorer, so you are not copying code out of a chat window.

With plugin 3.9 or newer RoCode can run a short playtest and read the errors, but it does not move a character through the course, so you play it yourself. Building a whole game with RoCode works one system per prompt like this. How RoCode connects to Studio.

Questions

Sources and further reading

• Roblox Creator Docs: Roblox Studio setup. Studio is a free app for Windows and Mac; installing and signing in
• Roblox Creator Docs: Create and publish games and places. templates, File > Publish, private by default, early testers, releasing to the public, release requirements, the daily limit and Manage Audience
• Roblox Creator Docs: Templates. what the Baseplate template contains
• Roblox Creator Docs: Explorer window. inserting objects, folders and duplicating
• Roblox Creator Docs: Parts. inserting parts, cylinders, moving, scaling and colour
• Roblox Creator Docs: Deadly lava tutorial. a lava part that sets Health to 0 on touch
• Roblox Creator Docs: Create a coin collection mechanic. coin parts with CanCollide off and Anchored on
• Roblox Creator Docs: Score points tutorial. the leaderstats folder and its exact name
• Roblox Creator Docs: BasePart.CanTouch. connecting Touched to a part with CanTouch off throws an error
• Roblox Creator Docs: Studio testing modes. Test, Play (F5), Stop and Server & Clients
• Roblox Creator Docs: Humanoid:TakeDamage. ForceField protection, and setting Health directly
• Roblox Creator Docs: PVInstance:PivotTo. the way to move a model from a script
• Roblox Creator Docs: Version History. saved versions and the published versions players get
• Roblox Creator Docs: Security tactics and cheat mitigation. never trust the client; Touched events at any range
• Roblox Creator Docs: Network ownership, movement validation, and physics. a client can teleport and fly its own character
• Roblox Creator Docs: Defensive design. the obby teleport-to-the-end case
• Roblox Creator Docs: Collaboration. the Collaborate button, Edit access, the age check and autosave

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