All lessons

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.

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.

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.

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.

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.

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.

Why the server is the only one who can give out coins, and what happens when you forget.

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

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

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

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

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.

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.

Build the upgrade shop's interface — a panel frame, a buy button, and a label that mirrors the server's data.

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

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.

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

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.

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.

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

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.

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.

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.

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

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.