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 lessonsInstall Roblox Studio and learn to find your way around it before writing a single line of code.
What this course is, who it's for, and how to get the most out of it.
Download Roblox Studio, sign in, and open a fresh Baseplate project.
The Explorer, Properties, and Output panels — the three places you'll live in as a developer.
The toolbar across the top, the camera in the middle, and the windows you can rearrange — how to stop feeling lost in Studio.
Build your first objects — parts in the Workspace, and the three numbers that place anything in 3D space.
Press Play, run your first script, and learn why test changes don't stick around.
Read error messages like a pro — which script, which line, and what went wrong.
A calm first hunt — read the red text, spot the typo, fix the line, and press Play again.
Luau Basics
20 lessonsThe building blocks of every script: variables, types, functions, conditionals, loops, tables, timing, and events.
A short refresher over Studio, parts, playtesting, and reading errors before the real coding begins.
What a script actually is, the difference between Scripts and LocalScripts, and how instructions run top to bottom.
Store a number, a word, or an object in a named box called a variable, and change what's inside it.
The naming rules every variable follows, the camelCase style Roblox uses, and why good names beat good luck.
The kinds of values you can put in a variable, why "1" is not 1, and how to convert between them.
Add, subtract, multiply, divide, and find remainders — the arithmetic your game does a thousand times a day.
Quotes, concatenation with .., and building messages that include numbers — text is how your game talks to players.
Search inside strings, extract parts, and swap text with pattern matching — the tools that turn raw text into useful data.
True and false, comparing values with == and friends, and combining questions with and / or.
Wrap a job in a named function, give it inputs, and call it whenever you need that job done.
A function that computes a result and hands it to you with return — so calls become values.
Make your scripts decide things — check a condition, and run different code depending on the answer.
Run code forever, or until a condition changes — the heartbeat of every game.
When you know how many times to run, let for keep the counter — reward every player, spawn 5 obstacles, print 1 to 10.
List values in one box, count them, and pull values out by number — your first data structure.
Pause a script, schedule work for later, and run two things at once — the clock behind every animation.
Leave plain-English notes in your code with -- so you and anyone else can understand what a script does.
Instead of watching and waiting, let Roblox call your code when something happens — a touch, a click, a player joining.
Hunt down real bugs in variables, conditionals, loops, and functions — and type the one-line fixes.
Assemble working scripts from shuffled lines — functions, choices, loops, and events — without typing a thing.
Player Data & Security
13 lessonsLeaderboards, saving between visits, and why the server — never the client — is the source of truth.
Refresh variables, functions, conditionals, loops, tables, and events — the parts of the language you'll use all course long.
Show each player's stats at the top-right of the screen, and update them from scripts.
The Players service, the PlayerAdded event that greets everyone who joins, and why the server knows who's asking.
Player names change and get recycled — UserId is the number that identifies one person forever.
Give your game a real memory with DataStoreService, so a player's coins survive the game closing.
Wrap risky calls in pcall so a single DataStore error doesn't crash your entire game — the safety net every data script needs.
Pull a player's save on join, default brand-new players to zero, and hand the number to leaderstats.
Save on leave, and back that up with periodic autosaves so a crash can't wipe an hour of progress.
The secure bridge between player and server, and the pattern that keeps your economy safe.
Double-check everything a player types or sends — shape, length, and control characters — before the server acts on it.
Hunt down the classic save-and-load bugs — swapped keys, missing defaults, and a leaderboard that never appears.
Use player drop-off data to find where players leave or get stuck, then fix the one leak that costs you the most players.
Assemble load-on-join, save-on-leave, autosave, and the secure click flow from shuffled lines.
UI & Screens
7 lessonsBuild the player's interface from scratch — frames, text, cuts, input, shop panels, and menus that open and close.
Create ScreenGui, Frame, and TextButton elements from a script, and lay out a simple on-screen button.
The scale-and-offset coordinate system that keeps GUIs on the right spot at every screen size.
Colors, text styling, rounded corners, and transparency — the properties that turn boxes into an interface.
React to raw input from the keyboard, mouse, touch, and gamepad with UserInputService events.
Bind game actions to keys with ContextActionService so the same code works on keyboard, touch, and gamepad.
Build the upgrade shop's interface — a panel frame, a buy button, and a label that mirrors the server's data.
Turn the shop panel into a real menu with a toggle button, a close button, the Escape key, and a click-outside backdrop.
Game Systems
18 lessonsBuild a working clicker game: currency, upgrades, and the client-server bridge that keeps it secure.
Refresh leaderstats, saving with DataStores, and the rule that the server decides — before you build your first real game systems.
Build your first playable loop — click a big button, earn coins, watch your balance climb, all through the secure client-server bridge.
A server loop that pays every player every second — your first passive mechanic and a classic idle-game heart.
Build a shop where players buy click multipliers, and the server verifies the price before anything changes.
Split one giant script into reusable, readable pieces with ModuleScripts and require.
Use metatables to create reusable objects with constructors, methods, and inheritance — the pattern behind every Roblox API.
Use the Teams service to assign players to teams, show team colors, and build round-based gameplay with scores.
The modern way to let players interact with objects — a floating E prompt that works on every device, no ClickDetector needed.
Find the security slips, the runaway loops, and the silent failures in your clicker, idle income, and shop.
Assemble the buy button, the server's checkout counter, idle income, and the live UI updates from shuffled lines.
Detect gamepads, read their buttons and sticks, and let console players navigate your GUI with VirtualCursorMode.
Build a fall-damage system, a reusable damage function, and a health bar that updates in real time.
Build a close-range attack that uses raycasting to detect what you hit, applies damage through the server, and pauses between swings.
Build a slot-based hotbar UI, pick up items from the world, and equip them with a click.
Place checkpoint Parts that remember a player's position, then spawn them back there instead of at the start.
Move a multi-part vehicle forward with the keyboard by updating the model's CFrame, and steer by rotating it.
Move a player to another part of a map or into an entirely different place with TeleportService.
Design reusable objectives, progress tracking, and rewards with one engine — quests as data, a single progress funnel, and server-paid rewards.
World & Players
19 lessonsParts, attributes, sounds, players and their characters, and smooth tweens that make the world feel alive.
Refresh GUIs, the clicker loop, idle income, upgrades, and modules before you start building the world around them.
The two types that put anything anywhere in the world — position with Vector3, and position plus rotation with CFrame.
Meet the Player object — the account behind the name — and the two facts about it that matter most.
The body your player controls — when it spawns, how to grab it safely, and the Humanoid that keeps it alive.
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.
Load and play AnimationTracks so your characters run, jump, attack, and emote — not just stand around.
Create non-player characters that patrol, chase, and navigate around obstacles using PathfindingService.
Create parts at runtime, pin them with Anchored, and style them with materials — no Studio viewport required.
Attach your own data to any object with SetAttribute and GetAttribute, so parts describe themselves.
Add Sound objects, load audio with a SoundId, and play effects where the player can actually hear them.
Sparkle, smoke, and glow — add ParticleEmitters to parts so your game looks as good as it plays.
Animate parts and UI with TweenService instead of teleporting them, and feel the difference polish makes.
Point the camera anywhere you want with a LocalScript — the foundation of cutscenes, cinematic views, and locked-camera puzzles.
Choreograph scripted camera moves with tweens, shakes, and FOV punches — the director's toolkit for intros, reveals, and boss moments.
Use Lighting, Sky, Atmosphere, and PostEffects to turn a flat workspace into a world with time of day, fog, and bloom.
Fire an invisible ray from any point and read exactly what it hits — the tool behind line of sight, ground checks, and laser beams.
Hunt down the nil characters, the silent tweens, and the sounds nobody hears.
Assemble a tween, a safe character grab, a sound, and a coin pickup from shuffled lines.
Use Studio's built-in objects — SpawnLocation, ForceField, and SelectionBox — to add instant polish without re-inventing the wheel.
Publishing & Testing
5 lessonsPut your game online, enable real data store saves, and run the full persistence loop.
Refresh players, characters, instances, attributes, sounds, and tweens before you take your game live.
Take the clicker from a Studio test to a live Roblox experience, and handle the settings that matter.
Decide who can play your game, test safely with friends, and get the link into testers' hands.
Enable data stores in Studio, then watch your coins survive across restarts, sessions, and even other players.
Turn a popular game into income with game passes, developer products, and an approach that treats players like people.
Leveling Up
10 lessonsRead errors like a pro, debug systematically, and map what comes after this course.
Refresh publishing, permissions, and data store testing before the final stretch.
Turn scary red Output lines into a precise map of what's wrong, and fix errors in a set order.
Strategic print statements turn a black box into a story — and reveal exactly which step failed.
Match a symptom to its usual cause — nil indexing, string arithmetic, wrong-side changes — and fix in one line.
Make your game smooth — measure first, then attack the three biggest costs — parts, loops, and events.
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.
Roblox removes what you Destroy — until a reference quietly keeps it alive. Meet the three classic leaks and learn the habits that prevent them.
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.
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.
Take stock of the full system you've built, then chart your course beyond this course.
Final Project
2 lessonsAssemble every system into one complete, publishable clicker game — then run the playtest that proves it works.
One lap around the whole journey — the pipeline, the pillars, and the debugging habits — before the final project.
Build one complete game — a clicker or a pet-collecting game — with a shop, persistent saves, and polish. Every system in this course in one place.
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 lessonsRead the walls before the walls read you — optional safety and anti-cheat practice for the whole course.
Find every line where a claim from a player's machine becomes a decision on yours, and the three questions that audit each one.
A caller can name any id it likes — so the server has to prove who owns it before the row behind that id counts for anything.
Build a probe that plays the attacker against your own game — forge a completion, a guest id, and a row — log what the server did, and fix the boundary each failure points at.
Why the server is the only one who can give out coins, and what happens when you forget.
Stop request spam at the server with per-player limits, and learn why a client debounce can never protect your game.
Keep every rule on the server — recompute real prices, verify ownership, and let the client only report what it wants.
Walk your game with an exploiter's checklist — every remote, every trust boundary, every free-typed value — and harden each gap before you ship.
Advanced StudioOptional
2 lessonsGo beyond scripting the game: render live 3D previews with ViewportFrames and build your own Roblox Studio plugins.
Render a real 3D Roblox model inside a GUI element with ViewportFrame and a Camera, so UI can show a live preview of a vehicle, item, or character.
Automate repetitive Roblox Studio tasks by writing your own plugins — toolbars, buttons, the Plugin API, and how to keep them safe.