Your first line of Lua

Build it

resources/qu_first_line_of_lua

resources/qu_first_line_of_lua/
fxmanifest.lua
server.lua

fx_version 'cerulean'
game 'gta5'
 
server_script 'server.lua'

RegisterCommand('first_line_of_lua', function()
print('[qu_first_line_of_lua] proof line')
end, true)

ensure qu_first_line_of_lua

restart qu_first_line_of_lua

first_line_of_lua

How it works

You ran it and the line appeared. Now take the code apart so the next time you write Lua you are deciding, not copying. There are really only two lines that matter, and one piece of punctuation that trips up everyone at the start.

The string you printed

Look at the text inside the parentheses on the print line:

'[qu_first_line_of_lua] proof line'

That is a string: a run of text that Lua treats as a single value. The single quotes are not part of the text. They are fences that mark where the text starts and ends. Lua also accepts double quotes, so "proof line" means the same thing as 'proof line'. Pick one style and stay consistent. The [qu_first_line_of_lua] part at the front is just text you typed on purpose. It is a tag, so that when twenty resources are all printing at once, you can scan the console and find your own lines. That habit pays off the moment your server has more than one script running.

The print function

print('[qu_first_line_of_lua] proof line')

print is a function: a named action you can call. You call it by writing its name, then a pair of parentheses, and inside the parentheses you put what you want it to act on. Here you hand it one string. The value you hand a function is called an argument. So in plain words this line says, take this string and write it to the console. That is the entire job of print. It does not pop up on a player's screen and it does not appear in chat. It writes to the server console. If you run your server through txAdmin, that output shows up in the txAdmin Live Console (it is also the same text you would see in the raw FXServer console window).

The mental model to lock in: print is your eyes inside running code. Code that is working silently tells you nothing. A well-placed print is how you ask the program what it is actually doing, instead of guessing. Every debugging session you will ever run starts with the same move, dropping a print somewhere to see whether the code even reached that point.

The command that runs it

RegisterCommand('first_line_of_lua', function()
    print('[qu_first_line_of_lua] proof line')
end, true)

This is the line that decides when your print runs. RegisterCommand is a FiveM native: a function the platform gives you for free. It wires a typed command to a block of code. Read it as three arguments separated by commas:

• 'first_line_of_lua' is the command name, a string. This is the word you type in the console to fire it. It does not have to match the resource name. It just happens to here.
• function() ... end is the code to run when the command fires. Everything between function() and end is the body. Right now the body is one print, but it could be a hundred lines. This is called the handler or callback: code you hand to FiveM and say, hold onto this and run it later, when the command is typed.
• true is the restricted flag. With true, the command requires an ace permission, which is why it runs cleanly from the server console. The server console has full rights. Set it to false and any connected player could run the command from their own chat box. For a server-side proof line you do not want players triggering, true is the safe default. Security rule to carry forward: any command that changes game state or trusts player input (heal, give item, set money) must stay restricted (true) and gated behind an ace permission. A command left at false lets every connected player fire that code from chat, and unauthenticated player-triggered server actions are the single most common way FiveM servers get exploited.

The end keyword closes the function body. Lua does not use curly braces to mark where a block stops the way JavaScript or C# do. It uses the word end. A missing end is the single most common Lua error a beginner hits, so train your eye to pair every function with its end now.

Here is the flow in order. The server starts the resource and reads server.lua top to bottom. It hits RegisterCommand and registers the command, but it does not run the print yet. The print is sitting inside the handler, waiting. Later, when you type first_line_of_lua in the console, FiveM finds the matching command, runs the handler, and the print fires. Registering and running are two separate moments. That gap is the whole idea behind event-driven code, and almost everything you build in FiveM works this way: you register handlers up front, and they run later when something happens.

When you reach for this pattern

A command plus a print is the smallest useful tool in FiveM, and you will use it constantly even after you are far past beginner. Three real cases:

• A manual trigger while building. You are writing a feature and you want to fire one part of it on demand without waiting for the real game condition. A command is the fastest way to poke your code by hand.
• A debug probe. You suspect a value is wrong. Register a throwaway command that prints the value, type it whenever you want a reading, then delete it when you are done.
• An admin action. Heal, give an item, teleport. These are commands at heart, gated with the restricted flag so only staff can run them. You just built the skeleton every one of those shares.

If something went wrong

Stuck? Reset to a known-good state: re-paste the exact fxmanifest.lua and server.lua from Build it (overwriting whatever you have), then in the txAdmin Live Console run refresh; restart qu_first_line_of_lua and try the command again. refresh makes the server re-read your manifest; restart reloads the resource.

What you can do now

• Read a Lua string and explain why the quotes are fences, not text.
• Use print to write a tagged line to the server console as a feedback probe.
• Explain that RegisterCommand registers a handler now and runs it later when the command is typed.
• Say what each of the three RegisterCommand arguments does, including why the restricted flag is true.
• Pair every function with its end and spot the error when one is missing.

Run it live

No server needed for this part. Edit the Lua below and press RUN to execute it in your browser on real Lua 5.4. Change the message, add a second print, and watch the output. The sandbox has no FiveM around it, so RegisterCommand and other natives are not available here. Plain Lua like print and strings run exactly as they would on your server.

Press RUN to execute.

Try it yourself