How to Fix 'Expected Near' Syntax Errors in Roblox Luau

Last updated: October 20, 2026

Quick answer: The 'expected near' error is a Luau syntax (parse) error: the script is compiled before it runs, so one broken construct stops everything, and the token after 'near' is where the parser choked. It is almost always a missing or misplaced end, a JavaScript-style operator like && or != that Luau does not have, or a quote or bracket that never got closed.

The Roblox error 'end' expected near 'if' — or any 'something' expected near 'something' message — is Luau telling you the script has a syntax error. Luau parses the entire script before executing a single line, so one broken construct prevents the whole script from running at all. The word before "expected" is the token the parser needed at that point, and the word after "near" is the token it actually found. In practice the cause is one of a handful of things: a missing or misplaced end, an operator Luau does not support, or a string or bracket that was never closed.

What does "expected near" actually mean?

Luau reads a script in two stages. First the parser turns the text into code it can run (compilation), then the runtime executes it. 'X' expected near 'Y' is a parse-stage error, which means the mistake is about the shape of your code, not its logic: the parser reached a token that cannot legally continue the current statement or block and gave up. Common shapes you will see in the Output window:

• 'end' expected near 'eof' — a block was never closed and the file ended.
• ')' expected (to close '(' at line 8) near 'then' — a parenthesis opened on line 8 and is still open here.
• '=' expected near 'do' — the parser read a bare name and expected an assignment after it.
• unexpected symbol near '&' — a character Luau does not use at all.

The parenthetical "(to close '(' at line 8)" is gold when you get it: it names the line of the opening bracket, so the mistake is somewhere between there and the reported line.

Why do I get "'end' expected" when my end is already there?

Every block opener pairs with exactly one closer, and the parser matches them strictly in order:

• function ... end (including anonymous function() ... end callbacks)
• if ... then ... end
• for ... do ... end and while ... do ... end
• do ... end
• repeat ... until — closed by until, not by end

If your end keyword really is in the file, one of two things is happening. Either a block above it is missing its own end, so the parser hands yours to that block and then runs out at end of file — that shows up as 'end' expected near 'eof'. Or an extra end higher up closed an outer block early, and everything after it is now floating outside where it belongs.

local function giveReward(player)
	if player:GetAttribute("Level") >= 10 then
		print("reward for " .. player.Name)
	-- 'end' for the if and 'end' for the function are both missing

local function onPlayerAdded(player)
	giveReward(player)
end

The parser reports the error at or after the next thing it cannot accept — often a later local function or the end of the file — even though the real mistake is several lines up. The fix is to balance the blocks:

local function giveReward(player)
	if player:GetAttribute("Level") >= 10 then
		print("reward for " .. player.Name)
	end
end

local function onPlayerAdded(player)
	giveReward(player)
end

Two keyword traps live here. elseif continues an existing if and shares its single end, while else if opens a brand-new nested if that demands an end of its own — one missing end later, the whole file fails to parse. And a repeat ... until block that you close with end leaves the until dangling, which produces exactly the class of error this guide is about.

Which operators does Luau not have?

If you are coming from JavaScript, C, or Java, muscle memory will write operators Luau simply does not have. The parser hits the first foreign symbol and reports something like unexpected symbol near '&' or '=' expected near '|'. Here is the translation list:

• x && y becomes x and y — logical and
• x || y becomes x or y — logical or
• x != y becomes x ~= y — not equal
• x++ becomes x += 1 — increment by one
• => becomes function(x) ... end — there are no arrow functions
• // comment becomes -- comment — in Luau // is floor division, not a comment

Note that += itself is valid modern Luau: x += 1, x *= 2, and x ..= "!" are all compound assignments Luau adds on top of Lua. What does not exist is ++ as an increment statement, and the -- case is sneakier still: in Luau it starts a comment, so a stray count-- comments out the rest of the line and chops your statement in half.

local score = 0
local alive = true
local name = "Player"

if alive && name != "Guest" then -- wrong: && and != are not Luau
	score++
end

local score = 0
local alive = true
local name = "Player"

if alive and name ~= "Guest" then
	score += 1
end

Related: string concatenation is .., never +. "score: " .. tostring(score) is the correct way to join text and numbers — and writing that line with a stray quote in the middle (see the next section) is one of the most common ways a concatenation turns into a syntax error.

Why does my string or table break the rest of the file?

An unterminated string or bracket does not fail where you typed it — it swallows everything that follows until the parser finds a matching closer or gives up. Watch for these four:

• Unclosed quote. local msg = "hello has no closing double quote, so Luau reads the next quote character it finds on some later line as the end of the string, and reports the error there. If there is no later quote at all you get 'unfinished string near eof'.
• An apostrophe inside a single-quoted string. print('It's fine') closes the string at the apostrophe in "It's", leaving the tail as garbage tokens — and the same trap wrecks concatenations the moment a label contains an apostrophe. Either escape the quote or use double quotes for strings containing apostrophes: print("It's fine").
• Unclosed parenthesis, brace, or bracket. The message names your culprit directly: ')' expected (to close '(' at line 8) near 'then'. Jump to line 8 and close what you opened there. Table constructors and function calls nested three or four deep are where this happens.
• Unterminated long comment or long string. --[[ opens a comment that runs until the closing double bracket. If you forget the closer, the rest of your file becomes a comment and the error lands on eof — a missing 'end' report for code the parser never even saw. The same applies to long strings [[ ... ]] and to Luau interpolated strings written with backticks, which must be closed with a matching backtick.

Why is the error line number not where the mistake is?

Because the parser reports where it gave up, not where you typed the problem. It consumes tokens as long as they could still form valid code, so the reported line is the first place the story stopped making sense. Three predictable shifts:

1. Missing end reports at end of file, or at the next keyword that cannot continue the open block.
2. Unclosed string reports at the next matching quote character, sometimes ten lines below your typo.
3. Extra end reports at that end itself as an unexpected token, or makes the following code fail with a different message.

The reliable method is to start at the reported line and scan upward for the nearest unclosed construct — the last function, if, for, brace, or quote that never got its closing token. The mistake sits between the last chunk that parsed cleanly and the line the error names. When the message includes "(to close '(' at line N)", start your search at line N instead.

One more property to remember: Luau reports syntax errors one at a time. Fix the first error and re-run — the next one only appears once the first is gone, so a short cascade of parse errors is normal and does not mean your script got worse.

The 30-second syntax error checklist

1. Read the word after "near". That is where the parser choked; read the word before "expected" to see what it wanted.
2. Check the line above the reported line and scan upward for the first unclosed block or quote.
3. Count openers against end: every function, if, for, while, and do needs exactly one; repeat needs an until.
4. Search the file for &&, ||, !=, ++, =>, and // — these are not Luau.
5. Verify quotes and brackets on the reported line, especially apostrophes inside single-quoted strings.
6. Near eof? Then an unclosed block, quote, bracket, or --[[ comment is hiding anywhere in the file — search for openers instead of staring at the bottom.
7. Confirm then after every if condition and do after every for and while.
8. Fix one error at a time and re-run: the parser stops at the first problem.

Common mistakes that produce 'expected near'

• Writing else if instead of elseif. The nested if eats the end that the outer one needed.
• JavaScript operators (&&, ||, !=, ++, =>) and // comments pasted in from another language.
• Forgetting then or do after an if condition or loop header.
• An apostrophe in a single-quoted string ("It's") terminating the string early and wrecking the concatenation that follows.
• Copy-paste leaving an extra end — or a duplicated function body whose first half already closed the block.
• Closing repeat ... until with end.
• Expecting pcall to catch any of this. pcall protects against runtime errors; a script that does not parse never runs at all, so wrapping it in pcall changes nothing. Runtime failures like nil values are a different family — see the attempt to index nil guide once your script actually compiles.

Learn Luau by doing

Syntax errors are the fastest errors to fix once your eye is trained, and that training only comes from writing real Luau. On Luablox you can practise in the browser through /theory, drill individual skills on /problems, and follow structured Luablox lessons that start from the very first script and build up to full gameplay systems.

Master arithmetic, relational, and logical operators in Luau to compute expressions and conditions.