2.1.2 Variables

Why Variables Matter in Roblox Lua

When you script in Roblox, you constantly need to remember values. A player’s score, their current level, the price of an item, or whether a door is open or closed are all pieces of information your game must keep track of. Variables are how you store and use those pieces of information in Lua.

A variable is a named box in memory that holds a value. You give the box a name, put a value in it, and then you can read or change that value later in your script. Lua looks at the name and finds the value inside.

In Roblox Lua, you use variables for almost everything. You store references to parts in the Workspace, connections to events, numbers for points, and strings for messages you want to show to the player. Learning to use variables comfortably is the first real step to writing useful code.

Declaring and Assigning Variables

To create a variable in Lua, you write the variable name, an equals sign, and then the value you want to store. This is called assignment.

For example, to store a player’s score as 0, you might write:

local score = 0

The word local will be discussed in the chapter on scope, but for now you should always use local when you create variables at the top of your scripts. It helps keep your code cleaner and avoids many hard to find bugs.

You can assign many types of values to a variable. These will be explored fully in the data types chapter, but you will already see a few of them here.

A few simple examples are:

local playerName = "Alice"
local coins = 10
local isDoorOpen = false
local speedMultiplier = 1.5

On the left of = you have the variable name. On the right you have the value that gets stored in the variable. Lua reads this line and puts the value into that named box.

If you later want to change the value inside a variable, you simply assign to it again:

coins = 20
isDoorOpen = true

Lua now remembers the new values and forgets the old ones for those variables.

Naming Variables Clearly

Variable names should tell you what the variable is used for. This makes your scripts much easier to read, especially as they grow larger.

Lua lets you use letters, digits, and underscores in names, but your variable name cannot start with a digit. Also, Lua is case sensitive, so coins, Coins, and COINS are three different variables.

Some good and bad examples:

-- Good names
local playerHealth = 100
local jumpPower = 50
local checkpointReached = false
-- Bad names
local x = 100           -- What is x?
local a1 = 50          -- Meaning is not clear
local flag = false     -- Flag for what?

In Roblox projects people often use lowerCamelCase or snake_case for variable names. For example, playerHealth or player_health. Choose one style and stay consistent in a project.

There are a few names you must never use for variables. Lua has reserved words such as if, then, end, function, local, and others. These are part of the language itself. You cannot use them as variable names.

Updating Variables and Using Them in Expressions

Variables are only useful if you use them in calculations and logic. Once a variable holds a value, you can read that value wherever you need it.

Here is a simple Roblox style example. Imagine you want to give the player 5 coins:

local coins = 0
-- Player collects a coin worth 5
coins = coins + 5

The right side reads the current value of coins, adds 5, and then the result is stored back into coins. This pattern is extremely common in game code. You increment scores, reduce health, or increase speed this way.

You can also use variables together in expressions:

local baseSpeed = 16
local speedMultiplier = 1.25
local finalSpeed = baseSpeed * speedMultiplier

Now finalSpeed holds the product of the other two variables. You do not need to remember the raw numbers any more. If you later change baseSpeed or speedMultiplier, the calculation will adjust the next time it runs.

Variables with Roblox Objects

In Roblox you often store references to objects such as Parts or GUIs in variables. This allows you to read or change their properties multiple times without constantly searching the game hierarchy.

Here is a basic example:

local part = workspace.MyPart
part.BrickColor = BrickColor.new("Bright red")
part.Anchored = true

The part variable now points to the MyPart object. Any time you use part, Lua knows which object you mean. This is much cleaner than writing workspace.MyPart over and over again, and it also makes it easier to change your code later if you rename or move the part.

You will often see this pattern in scripts that work with players:

local Players = game:GetService("Players")
local player = Players.LocalPlayer  -- in a LocalScript

Now player is a variable that refers to the current player. You can then use player to get their character, stats, or GUI without retyping the long expression every time.

Multiple Variables and Swapping Values

Lua lets you assign multiple variables in one line. This feature can make some patterns very compact and readable.

For example:

local x, y, z = 10, 20, 30

After this line, x is 10, y is 20, and z is 30. The variables on the left are matched with the values on the right in order.

One common use of multiple assignment is swapping two values without a temporary variable. For example:

local a = 1
local b = 2
a, b = b, a

Now a is 2 and b is 1. You gave Lua a new pair of values and it assigned them to the names in sequence.

If you give more values than variables, the extra values are ignored. If you provide fewer, the remaining variables become nil. nil is a special value that means “no value” and is covered more fully in the data types chapter.

Variables and Default Values

Variables in Lua only exist after you assign them. If you try to read a variable that was never assigned, Lua will treat it as nil. This often leads to errors when you expect a number or an object.

For example:

print(score)        -- If score was never set, this prints nil

In practical Roblox scripts, you should always give variables a sensible default value. For a number this is often 0. For a boolean it is usually false. For references to parts you typically assign them right away from workspace or game.

Here is a simple pattern:

local score = 0
local hasKey = false
local door = workspace.Door

If you forget to set a variable and then use it inside a calculation or method call, you will usually see an error in the Output window. Learning to recognize this kind of “attempt to index nil” or “attempt to perform arithmetic on nil” error is part of debugging, which you will study in a later chapter.

Reassigning vs Creating New Variables

When you use local in front of a variable name, you are creating that variable in the current scope. If you assign to the same name again without local, you are not creating a new variable, you are updating the existing one.

For example:

local coins = 10     -- create local variable coins
coins = 20           -- update the existing coins variable

If you accidentally write local coins = 20 again in the same scope, you can shadow the earlier variable, which often leads to confusing behavior. This topic belongs to scope and will be fully explained there, but you should already keep in mind that you normally only use local the first time you introduce a variable in a block of code.

Variables in Simple Roblox Scripts

To see variables in action in a small Roblox context, imagine a Part that changes color every time a player touches it. You might write:

local part = script.Parent
local touchCount = 0
local function onTouched(otherPart)
    touchCount = touchCount + 1
    if touchCount % 2 == 0 then
        part.BrickColor = BrickColor.new("Bright green")
    else
        part.BrickColor = BrickColor.new("Bright blue")
    end
end
part.Touched:Connect(onTouched)

Here part stores the reference to the Part that owns the script, and touchCount stores how many times the part has been touched. Every time onTouched runs, it updates touchCount and decides which color to use. Without variables, you would have no memory of how many touches happened so far.

Even though the if statement, function, and event connection will be fully explained in later chapters, you can already see how variables hold the data that makes this logic possible.

Building Good Habits with Variables

As you start to write your own scripts, treat variables as the main way your game remembers what happened. Store numbers that change over time, like health or coins. Keep references to important objects like doors, buttons, and UI elements. Use clear names so that when you come back to a script days later, it still makes sense.

If you get into the habit of always declaring variables with local, giving them descriptive names, and initializing them with good default values, your Roblox scripting will be much smoother and you will avoid many common beginner problems.

Later chapters will build on this foundation. When you learn about data types, control structures, and Roblox specific APIs, you will constantly combine them with variables to create real gameplay features.