Variables and Data Types
Variables store information that your script can use later. In Luau, you declare them with local. The main data types you will use are numbers (local health = 100), strings (local name = "Warrior"), booleans (local isAlive = true), and nil, which represents the absence of a value. Luau is dynamically typed, so a variable can hold any type, but you can add optional type annotations for clarity: local damage: number = 25. Use local variables whenever possible. Global variables pollute the environment and cause hard-to-find bugs. If you need to share data between modules, return it from a ModuleScript.
Functions and Events
Functions are reusable blocks of code. You define them with the function keyword and call them by name. Events are how Roblox tells your code that something happened. The most common pattern is connecting a function to an event: part.Touched:Connect(function(hit) print(hit.Name) end). Key events to learn early include Players.PlayerAdded, Workspace.ChildAdded, UserInputService.InputBegan, and the Touched event on BaseParts. Understanding the event-driven model is critical because Roblox is not like a traditional game loop. Your code responds to events rather than running in a continuous while loop.
Tables, Loops, and Conditionals
Tables are Luau's only data structure, and they serve as both arrays and dictionaries. An array table looks like local fruits = {"apple", "banana", "cherry"}, while a dictionary table uses key-value pairs: local stats = {health = 100, speed = 16}. You iterate over arrays with for i, v in ipairs(list) do and over dictionaries with for key, value in pairs(dict) do. Conditionals use if, elseif, and else to branch your logic. Combine these with comparison operators (==, ~=, <, >, <=, >=) and logical operators (and, or, not) to build complex decision trees. These three concepts, tables, loops, and conditionals, account for the vast majority of game logic you will write.
Instance Manipulation and the Data Model
Everything in a Roblox game is an Instance: parts, scripts, UI elements, sounds, lights. You create new instances with Instance.new("Part"), set their properties like part.Position = Vector3.new(0, 10, 0), and parent them into the hierarchy with part.Parent = workspace. You find existing instances with workspace:FindFirstChild("Door") or workspace:WaitForChild("Door") when the object might not exist yet. Destroying instances is done with instance:Destroy(), which removes the object and disconnects all events. Understanding how the data model tree works, and how parent-child relationships affect replication, rendering, and garbage collection, is foundational to Roblox development.
Common Patterns You Will Use Constantly
Certain code patterns come up in almost every Roblox project. The debounce pattern uses a boolean flag to prevent a function from firing multiple times in rapid succession. The module pattern uses ModuleScripts to organize reusable logic that multiple scripts can require(). The event-cleanup pattern stores connections in a table and disconnects them all when an object is destroyed to prevent memory leaks. The WaitForChild pattern ensures you do not reference objects that have not replicated to the client yet. Learning to recognize and apply these patterns will make your code significantly more reliable and maintainable.
- Debounce: local debounce = false; if debounce then return end; debounce = true; task.delay(1, function() debounce = false end)
- Module pattern: local Module = {}; function Module.DoThing() end; return Module
- Connection cleanup: local connections = {}; table.insert(connections, event:Connect(fn)); for _, conn in connections do conn:Disconnect() end
- WaitForChild: local gui = player.PlayerGui:WaitForChild("MainUI") to avoid nil references on the client
Where to Go From Here
Once you are comfortable with these basics, the next step is learning the client-server model: understanding what runs on the server versus the client, how RemoteEvents send data between them, and why you should never trust the client with game logic. The Roblox Creator Hub documentation is the best reference for API details. For hands-on practice, pick a simple project like a tycoon, obby, or combat system and build it from scratch. If you want to accelerate your learning by studying production-quality code, KitsBlox assets include well-structured, commented source code that demonstrates professional patterns in action.