RoCourse

Lessons

Work through the course in order, or jump straight to a topic. Lessons build on each other, so following the sequence works best.

Getting Started

8 lessons

Install Roblox Studio and learn to find your way around it before writing a single line of code.

Luau Basics

20 lessons

The building blocks of every script: variables, types, functions, conditionals, loops, tables, timing, and events.

Recap — a quick tour of the start

A short refresher over Studio, parts, playtesting, and reading errors before the real coding begins.

Scripts — where code lives and runs

What a script actually is, the difference between Scripts and LocalScripts, and how instructions run top to bottom.

Variables — remembering things

Store a number, a word, or an object in a named box called a variable, and change what's inside it.

Naming variables well

The naming rules every variable follows, the camelCase style Roblox uses, and why good names beat good luck.

Types — numbers, strings, and booleans

The kinds of values you can put in a variable, why "1" is not 1, and how to convert between them.

Numbers and math

Add, subtract, multiply, divide, and find remainders — the arithmetic your game does a thousand times a day.

Strings — text in code

Quotes, concatenation with .., and building messages that include numbers — text is how your game talks to players.

String patterns — finding and replacing text

Search inside strings, extract parts, and swap text with pattern matching — the tools that turn raw text into useful data.

Booleans — yes, no, maybe

True and false, comparing values with == and friends, and combining questions with and / or.

Functions — reusable instructions

Wrap a job in a named function, give it inputs, and call it whenever you need that job done.

Getting answers back — return

A function that computes a result and hands it to you with return — so calls become values.

Conditionals — if this, then that

Make your scripts decide things — check a condition, and run different code depending on the answer.

Loops — doing things over and over

Run code forever, or until a condition changes — the heartbeat of every game.

Counting with for loops

When you know how many times to run, let for keep the counter — reward every player, spawn 5 obstacles, print 1 to 10.

Tables — boxes that hold many things

List values in one box, count them, and pull values out by number — your first data structure.

Timing — task.wait and friends

Pause a script, schedule work for later, and run two things at once — the clock behind every animation.

Comments — notes for your future self

Leave plain-English notes in your code with -- so you and anyone else can understand what a script does.

Events — reacting to the world

Instead of watching and waiting, let Roblox call your code when something happens — a touch, a click, a player joining.

Bug hunt — the language core

Hunt down real bugs in variables, conditionals, loops, and functions — and type the one-line fixes.

Drag and drop — arrange the code

Assemble working scripts from shuffled lines — functions, choices, loops, and events — without typing a thing.

Player Data & Security

13 lessons

Leaderboards, saving between visits, and why the server — never the client — is the source of truth.

Recap — the Luau toolbox

Refresh variables, functions, conditionals, loops, tables, and events — the parts of the language you'll use all course long.

leaderstats — the player leaderboard

Show each player's stats at the top-right of the screen, and update them from scripts.

Players — who is in your game

The Players service, the PlayerAdded event that greets everyone who joins, and why the server knows who's asking.

UserId — the permanent key

Player names change and get recycled — UserId is the number that identifies one person forever.

DataStores — saving between visits

Give your game a real memory with DataStoreService, so a player's coins survive the game closing.

pcall — running code that might fail

Wrap risky calls in pcall so a single DataStore error doesn't crash your entire game — the safety net every data script needs.

Loading a player's data

Pull a player's save on join, default brand-new players to zero, and hand the number to leaderstats.

The save loop and autosave

Save on leave, and back that up with periodic autosaves so a crash can't wipe an hour of progress.

RemoteEvents — the client asks, the server decides

The secure bridge between player and server, and the pattern that keeps your economy safe.

Input validation — never trust a string

Double-check everything a player types or sends — shape, length, and control characters — before the server acts on it.

Bug hunt — player data

Hunt down the classic save-and-load bugs — swapped keys, missing defaults, and a leaderboard that never appears.

Funnel analysis — find where players leave

Use player drop-off data to find where players leave or get stuck, then fix the one leak that costs you the most players.

Drag and drop — the save loop

Assemble load-on-join, save-on-leave, autosave, and the secure click flow from shuffled lines.

UI & Screens

7 lessons

Build the player's interface from scratch — frames, text, cuts, input, shop panels, and menus that open and close.

Game Systems

18 lessons

Build a working clicker game: currency, upgrades, and the client-server bridge that keeps it secure.

Recap — player data and trust

Refresh leaderstats, saving with DataStores, and the rule that the server decides — before you build your first real game systems.

The clicker game — clicks become coins

Build your first playable loop — click a big button, earn coins, watch your balance climb, all through the secure client-server bridge.

Idle income — coins without clicking

A server loop that pays every player every second — your first passive mechanic and a classic idle-game heart.

Upgrades — spending coins with the server checking the bill

Build a shop where players buy click multipliers, and the server verifies the price before anything changes.

ModuleScripts — organizing your code

Split one giant script into reusable, readable pieces with ModuleScripts and require.

OOP with metatables — building classes in Luau

Use metatables to create reusable objects with constructors, methods, and inheritance — the pattern behind every Roblox API.

Teams — splitting players into sides

Use the Teams service to assign players to teams, show team colors, and build round-based gameplay with scores.

ProximityPrompt — walk up and interact

The modern way to let players interact with objects — a floating E prompt that works on every device, no ClickDetector needed.

Bug hunt — game systems

Find the security slips, the runaway loops, and the silent failures in your clicker, idle income, and shop.

Drag and drop — the shop

Assemble the buy button, the server's checkout counter, idle income, and the live UI updates from shuffled lines.

Controller support — gamepads and the virtual cursor

Detect gamepads, read their buttons and sticks, and let console players navigate your GUI with VirtualCursorMode.

Health and damage — keeping score

Build a fall-damage system, a reusable damage function, and a health bar that updates in real time.

Melee combat — click-to-hit with a cooldown

Build a close-range attack that uses raycasting to detect what you hit, applies damage through the server, and pauses between swings.

Inventory and hotbar — collect, store, equip

Build a slot-based hotbar UI, pick up items from the world, and equip them with a click.

Checkpoints — respawn where you left off

Place checkpoint Parts that remember a player's position, then spawn them back there instead of at the start.

Vehicles — drive a welded model

Move a multi-part vehicle forward with the keyboard by updating the model's CFrame, and steer by rotating it.

Teleporting — jump between zones and places

Move a player to another part of a map or into an entirely different place with TeleportService.

Quest Systems — design reusable objectives, progress tracking, and rewards

Design reusable objectives, progress tracking, and rewards with one engine — quests as data, a single progress funnel, and server-paid rewards.

World & Players

19 lessons

Parts, attributes, sounds, players and their characters, and smooth tweens that make the world feel alive.

Recap — your first game systems

Refresh GUIs, the clicker loop, idle income, upgrades, and modules before you start building the world around them.

Vector3 and CFrame — points in 3D space

The two types that put anything anywhere in the world — position with Vector3, and position plus rotation with CFrame.

Players — the people in your game

Meet the Player object — the account behind the name — and the two facts about it that matter most.

Characters and Humanoids

The body your player controls — when it spawns, how to grab it safely, and the Humanoid that keeps it alive.

Custom Movement — beyond the default character

Build movement mechanics beyond default Roblox character movement — tune speed and jump height, add a sprint, a dash, and a double jump, and keep the final say on the server.

Animations — making characters move

Load and play AnimationTracks so your characters run, jump, attack, and emote — not just stand around.

NPCs and PathfindingService — making the world walk

Create non-player characters that patrol, chase, and navigate around obstacles using PathfindingService.

Instances — building the world in code

Create parts at runtime, pin them with Anchored, and style them with materials — no Studio viewport required.

Attributes — sticky notes on objects

Attach your own data to any object with SetAttribute and GetAttribute, so parts describe themselves.

Sounds — giving the world a voice

Add Sound objects, load audio with a SoundId, and play effects where the player can actually hear them.

Particle effects — making the world feel alive

Sparkle, smoke, and glow — add ParticleEmitters to parts so your game looks as good as it plays.

Tweens — smooth movement and polish

Animate parts and UI with TweenService instead of teleporting them, and feel the difference polish makes.

Custom cameras — taking control

Point the camera anywhere you want with a LocalScript — the foundation of cutscenes, cinematic views, and locked-camera puzzles.

Cutscenes — directing the camera

Choreograph scripted camera moves with tweens, shakes, and FOV punches — the director's toolkit for intros, reveals, and boss moments.

Lighting and atmosphere — setting the mood

Use Lighting, Sky, Atmosphere, and PostEffects to turn a flat workspace into a world with time of day, fog, and bloom.

Raycasting — asking the world what's in the way

Fire an invisible ray from any point and read exactly what it hits — the tool behind line of sight, ground checks, and laser beams.

Bug hunt — the world around you

Hunt down the nil characters, the silent tweens, and the sounds nobody hears.

Drag and drop — polish and objects

Assemble a tween, a safe character grab, a sound, and a coin pickup from shuffled lines.

Built-in features — spawns, force fields, highlights

Use Studio's built-in objects — SpawnLocation, ForceField, and SelectionBox — to add instant polish without re-inventing the wheel.

Publishing & Testing

5 lessons

Put your game online, enable real data store saves, and run the full persistence loop.

Leveling Up

10 lessons

Read errors like a pro, debug systematically, and map what comes after this course.

Recap — taking your game live

Refresh publishing, permissions, and data store testing before the final stretch.

Debugging — reading errors like a pro

Turn scary red Output lines into a precise map of what's wrong, and fix errors in a set order.

Print debugging — narrating your code

Strategic print statements turn a black box into a story — and reveal exactly which step failed.

The classic errors — and their smell

Match a symptom to its usual cause — nil indexing, string arithmetic, wrong-side changes — and fix in one line.

Optimization — speed without guessing

Make your game smooth — measure first, then attack the three biggest costs — parts, loops, and events.

Client performance — running smooth on the player's machine

Performance is measured on the player's machine — learn the frame budget, the per-frame work that eats it, and how to measure before you optimize.

Memory leaks — why dead things stick around

Roblox removes what you Destroy — until a reference quietly keeps it alive. Meet the three classic leaks and learn the habits that prevent them.

Refactoring — same game, cleaner code

Read a messy script, spot the smells, and restructure it in small safe steps until the code matches the plan — without changing a single pixel of gameplay.

Testing fundamentals — claims that prove code works

Turn "I think it works" into a claim the machine checks every run — cover happy paths, edge cases, and invalid input, and lock in every fix with a regression test.

Next steps — the map of what you've learned

Take stock of the full system you've built, then chart your course beyond this course.

Final Project

2 lessons

Assemble every system into one complete, publishable clicker game — then run the playtest that proves it works.

Optional lessons

These sections sit past the end of the main course. The first lesson of each one is open right away, so you can start there whenever the topic interests you — no progress needed.

Anti-Cheat & SafetyOptional

7 lessons

Read the walls before the walls read you — optional safety and anti-cheat practice for the whole course.

Advanced StudioOptional

2 lessons

Go beyond scripting the game: render live 3D previews with ViewportFrames and build your own Roblox Studio plugins.