Quickstart: your first game

In this quickstart you’ll make your own copy of an obstacle course, add a glowing beacon that reacts when players touch it, test it with one and then two players, and publish it so friends can play. It takes about 15 minutes.

You need a Rally account — sign in at rally.place — and a computer with a keyboard and mouse: Rally Studio runs in your browser, and you’ll use the mouse to look around.

1. Create a game from a template

1. On rally.place, click Games in the column of icons on the far left (the game controller).
2. On the Games page, click Create a game.
3. Fill in the form:
   • Name: anything you like, for example My First Obby.
   • Description: optional — one line about what players do.
   • Dimension: 3D.
   • Start from: Sky Obby, a floating obstacle course with checkpoints, lava and moving platforms.
4. Click Create game.

You land on your game’s page. The template is already published as your game’s first version, so Play works right away — try it if you like. New games are Private: only you can see and play them until you change that in step 7.

Other ways to start

There are ten templates to start from: an obby, freeze tag, kart racing, a physics arena, capture the flag, zombie survival, a candy factory tycoon and tower defense in 3D, and in 2D a side-scrolling platformer (Coin Dash) and a top-down dungeon (Lost Crypt). Each is a small multiplayer game you can tune without code: select ReplicatedStorage › Settings in Studio and change its attributes. The Empty option creates a game with no version yet: open it in Studio and you start from a baseplate and a spawn point.

2. Open Rally Studio

On your game’s page, click Open in Studio. Studio opens full screen in your browser:

• The toolbar runs along the top: tools, Part and Insert, then Play and Publish on the right.
• The viewport in the middle shows your world. Under it, the Output panel shows what your scripts print and any errors.
• On the right, the Explorer shows the game tree, and Properties shows the selected object’s properties.

To look around the viewport, hold the right mouse button and drag. Use W A S D and Q E to fly, scroll to zoom, and press F to frame whatever is selected. Press ? any time to see every shortcut.

Studio saves your work as you go — the line under your game’s name says Saved automatically. Nothing you change reaches players until you publish.

In the Explorer, look inside Workspace. The obby is built from folders — Checkpoints, Course, KillBricks and Movers — plus a FinishPad part and some clouds. Click the arrow next to a folder to see what’s in it.

Leave the template’s scripts as they are

The template’s two scripts — main in ServerScriptService and hud in StarterPlayer › StarterPlayerScripts — were published as compiled JavaScript, so they’re hard to read, but they work. They find the obby’s pieces by name, so don’t rename or delete Checkpoints, KillBricks, Movers, FinishPad, the remote events in ReplicatedStorage or the HUD in StarterGui. Add your own scripts next to them instead, as you will in step 4.

3. Change the world

Add a beacon to the course:

1. Press Esc to clear the selection, so the new part goes straight into Workspace.
2. Click Part in the toolbar. A gray block appears where you’re looking, already selected.
3. Press F2, type Beacon and press Enter to rename it.
4. In Properties:
   • Under Transform, set size to 4, 4, 4.
   • Under Appearance, pick a color and set material to neon.
5. Press 2 for the Move tool and drag the arrows to put the beacon somewhere along the course, where players will run into it.

New parts are anchored (you’ll find it under Physics), so the beacon stays exactly where you put it — even in mid-air. Building worlds covers every building tool.

4. Add a script

1. In the Explorer, right-click Beacon and choose Insert Object › Script. A Script appears inside the beacon.
2. Double-click the Script to open it. It opens in a tab next to World (the viewport), with a line of starter code that prints Hello from the server!.
3. Replace all of its code with this:

Workspace/Beacon/Script.server.ts

import { Character, Color3, Part, Players, print, script, TweenService, Vector3 } from '@rally/sdk';

// This script lives inside the Beacon part, so its parent is the part.
const beacon = script.parent;
if (!(beacon instanceof Part)) throw new Error('Put this script inside a Part');

// Spin forever: one full turn every 4 seconds.
TweenService.create(
  beacon,
  { time: 4, easing: 'linear', repeatCount: -1 },
  { rotation: beacon.rotation.add(new Vector3(0, 360, 0)) },
).play();

// When a player's character touches the beacon, change its color and say who it was.
beacon.touched.connect((other) => {
  if (!(other instanceof Character)) return;
  const player = Players.getPlayerFromCharacter(other);
  beacon.color = Color3.fromHSV(Math.random(), 0.8, 1);
  print(`${player?.displayName ?? 'Someone'} touched the beacon!`);
});

Here’s what it does:

• import { … } from '@rally/sdk' brings in the parts of the game API this script uses.
• script is the Script that’s running, so script.parent is the beacon. The instanceof check makes sure it’s a part — and tells TypeScript so.
• TweenService.create(…).play() animates the beacon’s rotation by a full turn every 4 seconds, repeating forever.
• beacon.touched fires on the server whenever something starts touching the beacon. The handler ignores everything but characters, gives the beacon a random bright color, and prints who touched it.

The bar under the editor says Runs on the server. If you mistype something, the editor underlines it in red as you type — hover over it to see why.

Reading code titles

Code titles in these docs show where a script lives and what kind it is: .server.ts is a Script, .client.ts is a LocalScript, and a plain .ts is a ModuleScript. In Studio you’ll see just the name: this one is the Script named Script inside Beacon.

5. Test it

Press Play in the toolbar (or F5). Studio compiles your scripts and runs the whole game right in the viewport, with you as the player:

• Click the game, then move with W A S D and jump with Space. Clicking locks the mouse so you can look around; press Esc to get it back.
• Run into the beacon. It changes color, and Output shows <your name> touched the beacon!.

Press Stop (or Shift+F5) to go back to editing. Edits you make while a playtest runs apply the next time you press Play.

If a script has a mistake that stops it from compiling, Studio says A script has an error and lists it in Output — click the error to jump to the line. Errors while the game runs show up in Output too, in red. See Debugging.

Test with two players

Play runs everything in your browser. To see your game the way players will — on a real game server, with more than one player — click the arrow next to Play and choose Test on a real game server › 2 players. Studio starts a private server and shows both players side by side, named Player1 and Player2; click a player’s view to control them. Move one of them into the beacon: both see it change color, because the server changed it. In Output, lines from the server start with [server].

Nothing is saved on a test server. Press Stop when you’re done. Testing has more on both ways to test.

6. Publish

Click Publish at the right end of the toolbar. Studio compiles the game and publishes it as a new version; a message confirms Published version 2 and that players get it the next time they join. The button reads Published until you change something again.

Only the game’s owner can publish, and Studio won’t publish while a script has errors. Every version is kept: Version history in the toolbar lets you restore an old one. See Publishing and versions.

7. Choose who can play, and share

1. Click the arrow at the far left of Studio’s toolbar (Back to the game page).
2. Under Settings, choose who can play:
   • Private — only you, and anyone you’ve added as a collaborator, can see and play it.
   • Unlisted — anyone with the link can play.
   • Public — listed in Games for everyone.
3. Click Save changes.
4. Copy the game page’s address from your browser’s address bar and send it to a friend. They sign in to Rally, open the link and press Play.

Settings is also where you change the game’s name and description, and Max players per server — how many people can play together in one copy of your game (1 to 100).

Next steps

You’ve made a change, written a script, tested it and shipped it. From here:

• Understand the moving parts in How Rally games work.
• See where everything belongs in How games are organized.
• Learn the language of the engine, starting with Scripts and modules.
• Build a complete game step by step in Build an obby.