How to Fix 'Attempt to Call a Nil Value' in Roblox

Last updated: October 20, 2026

Quick answer: The 'attempt to call a nil value' error means the value right before a pair of parentheses is nil, so Luau has no function to call — the usual causes are passing the result of a function instead of the function itself (Connect(myFunc())), a typo, a function used before it was defined, or a ModuleScript that forgot to return its value.

The Roblox error 'attempt to call a nil value' means exactly what it says: somewhere there is a pair of parentheses — something() or obj:method() — and the value right before those parentheses is nil. Luau can only call functions, so the thread crashes at that line with a message like attempt to call a nil value (global 'giveCoins'). The fix is not at the crash line but wherever that value became nil: a call made too early, a name that does not exist, a callback you passed the wrong way, or a module that returned nothing.

What does 'attempt to call a nil value' actually mean?

Calling something in Luau means writing a value followed by (...). If that value is nil at the moment the call runs, you get this error — the call itself is the crime, not whatever the function was supposed to do. The parenthetical hint in the message tells you where the nil came from, and reading it saves you most of the debugging:

• (global 'giveCoins') — a global named giveCoins was nil: a typo, or a name defined later than the call.
• (local 'handler) — a local variable was nil: declared but never assigned, or assigned from something that failed.
• (upvalue 'startRound') — a variable captured from an enclosing function was nil when the inner function ran.
• (method 'FireClient') — that method does not exist on the object you called it on (here: a wrong method name for that class).
• (field 'onHit') — a table field you expected to hold a function is nil, like a callback that was never assigned.

local function giveCoins(player, amount)
	player:SetAttribute("Coins", (player:GetAttribute("Coins") or 0) + amount)
end

local reward = nil -- never assigned
reward() -- attempt to call a nil value (local 'reward')

giveConis(game.Players.Stefano, 5) -- typo: attempt to call a nil value (global 'giveConis')

Why does Connect(myFunc()) throw this error?

Because the trailing parentheses in Connect(myFunc()) call myFunc immediately, and hand whatever it returns to Connect — not the function itself. Two things go wrong at once. If myFunc is nil at that moment (typo, defined lower down, or a failed require), then the call myFunc() is itself "attempt to call a nil value", and that is the error you see. And even when myFunc exists, you are running it right now at connect time and registering its return value (usually nil) as the callback, so the event never actually runs your code.

local function onClick()
	print("clicked")
end

-- Wrong: calls onClick NOW and passes its return value (nil) to Connect
button.MouseButton1Click:Connect(onClick())

-- Right: passes the function itself, so the event can call it later
button.MouseButton1Click:Connect(onClick)

-- Right when you need extra arguments:
button.MouseButton1Click:Connect(function()
	onClick("fast")
end)

The same trap appears everywhere a function is expected as a value: task.spawn(startGame()) calls startGame immediately and tries to spawn its return value, task.delay(1, respawn()) does the same to respawn. Write task.spawn(startGame), task.delay(1, respawn) — no parentheses when you mean "here is the function", parentheses when you mean "call it now".

Why does my function work when I call it directly but not from an event?

Because a direct call happens at a moment you control — usually after all your setup code has run, with arguments you chose. An event callback runs whenever the engine decides, and two things differ. First, timing: if the event fires before the line that created your value, the lookup finds nil exactly once, at the worst moment. Second, arguments: the engine passes its data (the part that touched, the player who joined), and any lookup built on that data can return nil which you then call.

local handlers = {
	sword = function(player)
		print(player.Name .. " swings a sword")
	end,
	-- no 'shield' handler registered yet
}

tool.Activated:Connect(function()
	local handler = handlers[tool.Name]
	handler(game.Players.LocalPlayer) -- attempt to call a nil value (local 'handler') for a shield
end)

The fix is to guard the call and connect only once everything exists:

tool.Activated:Connect(function()
	local handler = handlers[tool.Name]
	if handler then
		handler(game.Players.LocalPlayer)
	else
		warn("No handler registered for " .. tool.Name)
	end
end)

If the value is created by another script, make the ordering explicit: put shared functions in a ModuleScript that everyone requires, and do not connect listeners until the data they depend on has been loaded.

Do typos and dot-vs-colon mistakes cause this error?

Constantly. A misspelled name does not always fail loudly at the definition — it fails at the call, as (global 'onPlayerAded') or (method 'FireClient'). The hint is your fastest search term: grep your scripts for the exact name in the parentheses and compare it letter for letter with the definition.

Dot-versus-colon mistakes produce the same family of errors. obj:method() is sugar for obj.method(obj); if method is not defined on that object — wrong class, renamed API, lowercase legacy spelling — the call is "attempt to call a nil value (method 'method')". Calling BindableEvent:FireServer() instead of :Fire(), or :InvokeClient() on a BindableFunction instead of :Invoke(), are classic examples. And when you define with a colon but call with a dot (or the reverse), every parameter shifts by one: self receives whatever you passed first, and the callback field you expected to find on self can come back nil.

local Weapon = {}
Weapon.__index = Weapon

function Weapon.new(name)
	return setmetatable({ name = name, onHit = nil }, Weapon)
end

function Weapon:swing(target)
	-- Wrong if onHit was never assigned:
	self.onHit(target) -- attempt to call a nil value (field 'onHit')

	-- Safe:
	if self.onHit then
		self.onHit(target)
	end
end

Note that with OOP based on setmetatable and __index — the current standard in Luau — a missing field gives "attempt to call a nil value (field '...')" while a missing object (a nil self) gives "attempt to index nil" instead. That distinction tells you whether the object exists and the callback is missing, or the object itself is gone.

Can a ModuleScript cause 'attempt to call a nil value'?

Yes, and it is one of the most confusing sources because the crash happens far from the module. When a ModuleScript falls off its last line without a return, require gives back nil. If your convention is that the module returns a function, the very next line calls nil:

-- ServerStorage/Modules/SetupPlayer (ModuleScript)
local function setup(player)
	print("setting up " .. player.Name)
end

return setup -- without this line, require(...) returns nil

local ServerStorage = game:GetService("ServerStorage")
local setup = require(ServerStorage.Modules.SetupPlayer)

setup(game.Players.LocalPlayer) -- attempt to call a nil value (local 'setup')

Check the bottom of the module for a missing or conditional return, and make sure the returned shape matches how you use it: a module returning a table gives you "attempt to index nil" at module.thing() (see the attempt to index nil guide) while a module meant to return a function gives you this call error instead. A return that sits inside an if branch that did not run causes exactly the same thing.

How do I find which value is nil?

Use the error hint first — the name in parentheses points at the variable to inspect. Then, right before the crashing line, print what the value actually is:

print("handler is", typeof(handler)) -- expect "function"
if type(handler) == "function" then
	handler()
end

typeof is the Roblox-aware version of type: it reports "nil" for missing values, "function" for callbacks, "Instance" for game objects, and so on. A one-line print(typeof(x)) before each suspect call turns "something is nil" into "the handler is nil here, but was a function up there" — which is exactly the information you need. For deeper stacks, print(debug.traceback()) shows which call path reached the crash, and temporarily wrapping risky calls in pcall lets the script keep running while you add prints around the failure.

Common mistakes that produce 'attempt to call a nil value'

• Connect(myFunc()) instead of Connect(myFunc) — calling the function now and passing its return value (nil) as the callback.
• Using a function before its definition runs. Scripts execute top to bottom; calling a local above its declaration, or before the module that defines it is required, hits nil.
• Misspelled names — globals and methods fail at the call site, not at the typo.
• Wrong method for the class — :FireServer() on a BindableEvent, :InvokeClient() on a BindableFunction, or a lowercase legacy spelling that no longer exists.
• A ModuleScript with no return, so require hands you nil and your very next line calls it.
• A callback field never assigned before something invokes it, common in OOP objects built with setmetatable.
• Calling a handler-map lookup without a fallback, so any unexpected event argument turns into a nil call.

Learn Luau by doing

Nil errors stop being scary once you can read the hint in the message and inspect values in flight — and that is a skill built by writing code, not by reading about it. On Luablox you can practise in the browser through /theory, drill error-reading on /problems, and follow structured Luablox lessons that build from your first script up to full gameplay systems with events and modules.

Learn how to share code and architect clean, modular Roblox systems using ModuleScripts and require().