Master statement formatting, single-line (--), and multi-line (--[[ ]]) comments.

Explore nil, boolean, number, string, table, function, thread, and userdata using type().

Master integers, floats, division (/), floor division (//), modulo (%), and exponentiation (^).

Work with single quotes, double quotes, long brackets [[ ]], concatenation, and # length.

Understand Lua truth values (only false and nil are falsy! 0 and "" are true), and logic operators.

Structure decisions with if condition then ... elseif ... else ... end blocks.

Compare values using ==, ~= (not equal), <, >, <=, and >=.

Leverage and, or, not, and build inline ternary conditionals.

Understand structured goto jumps and label definitions in Lua 5.2+.

Master lexical scoping with local, avoiding accidental globals, and creating explicit do ... end blocks.

Assign multiple variables simultaneously (a, b = 10, 20) and perform atomic swaps.

Repeat statements while a condition remains truthy with while ... do ... end.

Execute loop body at least once and loop until a condition becomes true.

Write counting loops with for var = start, stop, step do ... end.

Iterate over 1-based sequential arrays using for index, value in ipairs(t) do.

Iterate over all key-value pairs of a table (numeric, string, or mixed) using pairs(t).

Exit loops prematurely using the break statement.

Define reusable functions with function name(params) ... end and handle arguments.

Return multiple values (return a, b, c) and unpack them directly into variables.

Accept arbitrary argument lists using the ellipsis (...), table.pack, and select().

Treat functions as first-class values: assign to variables, pass to HOFs, and return from functions.

Encapsulate private state using lexical closures and external local variables (upvalues).

Write infinite state machines and recursions with zero stack growth using proper tail calls.

Construct tables using {} and explore why tables serve as arrays, hashes, and objects in Lua.

Work with sequences, 1-based indexing, the length operator (#), and inserting items.

Store key-value pairs and access fields using dot notation (t.key) or bracket notation (t["key"]).

Use table.insert, table.remove, table.concat, and table.unpack for array manipulation.

Construct nested tables for 2D grids, game matrices, and complex tree structures.

Sort array tables in-place using custom comparator functions.

Extend and customize table behaviors with setmetatable and getmetatable.

Overload +, -, *, /, %, and ^ for custom tables and vector math.

Define equality (==) and ordering comparisons (<, <=, >, >=) on custom tables.

Master __index for prototype inheritance and __newindex for intercepting assignments.

Format tables with tostring() via __tostring and make tables callable like functions with __call.

Lock and protect metatables from tampering using the __metatable field.

Build object-oriented classes in Lua using table prototypes and __index.

Understand the difference between obj:method() and obj.method(self).

Implement standard constructors in Lua to instantiate and initialize objects.

Derive subclasses, inherit base methods, and override behavior.

Achieve true private object members using closures and proxy tables.

Implement multiple inheritance using a custom __index search function.

Manipulate strings with string.sub, string.byte, string.rep, string.lower, and string.upper.

Format text with printf-style specifiers (%s, %d, %f, %02d, %x).

Master Lua pattern matching classes (%d, %a, %s, %w) and magic characters (^$()%.[]*+-?).

Locate substrings with string.find and iterate all matches with string.gmatch.

Search and replace using string.gsub with strings, lookup tables, and replacement functions.

Structure modular code in Lua by returning module tables and importing with require().

Implement non-preemptive concurrency using coroutine.create, resume, yield, and status.

Handle exceptions safely using error(), assert(), pcall(), and xpcall().

Work with file streams, reading line-by-line, and writing output using the io library.

Build an interactive game loop with entity hierarchy, metatable vector physics, and state updates.

Test your understanding across all 9 modules: tables, metatables, closures, and coroutines.

Build a domain-specific language (DSL) interpreter that parses commands and triggers events.

Claim your official ZenCompiler Lua Systems & Game Scripting Specialist Certificate.