Free through lesson 3

Lua for Beginners

Implementations and types, tables and metatables, closures and coroutines, _ENV sandboxes, LuaRocks and testing, all the way to embedding with the C API. Over 20 lessons, you'll go from reading and writing Lua to embedding it in your own C program and running plugins. Every output shown is real, measured by running it on Lua 5.5.1 and LuaJIT 2.1.

Start from lesson 1 Unlock every course

Curriculum

The 20 lessons are split into 5 chapters. We recommend going in order from chapter 1, but feel free to pick out just the parts that interest you. * Lua can't run in the browser, so try things with the Lua 5.5 you install in lesson 1. Wherever 5.4 gives a different result, we show the 5.4 output too. How to write Neovim configs is covered in Neovim, fish & tmux for Beginners.

Chapter 1 — The Shape of Lua (lessons 1–4)

Install Lua, run it in the REPL and from files, and get the skeleton of the language down: types, variables, functions, and strings. We finish by searching and replacing strings with Lua patterns, which are not regular expressions.

1

Implementations and Types (Install Lua and Meet the 8 Types)

Install Lua and try lua -v, the REPL, and running files. Check the 8 types with type(), and learn the rule that only nil and false are falsy.

Free
2

Variables and Scope (local, and Lua 5.5's global Declarations)

Plain assignment makes a global. Confine variables to a block with local, and use Lua 5.5's global declarations to catch missing ones at compile time. Plus the differences from 5.4.

Free
3

Functions and Multiple Values (Returning and Receiving Several Values)

Functions are values. Extra or missing arguments become discards or nil. Return several values, and learn where multiple values get truncated and how varargs ... work.

Free
4

Strings and Patterns (Search and Replace Without Regex)

Strings are bytes, indexed from 1. Search and replace with find, match, gmatch, gsub and Lua patterns; learn escaping with % and the trap of gsub returning two values.

🔒 Basic

Chapter 2 — Tables (lessons 5–8)

Learn tables, Lua's only data structure, and metatables, which change how tables behave. We finish by building classes out of tables, splitting files into modules, and connecting them with require.

5

Tables Are the Only Data Structure (Arrays, Dictionaries, #, and Iteration)

Arrays, dictionaries, and objects are all tables in Lua. 1-based indexes, the "border" that # returns, ipairs vs. pairs ordering, and using table.*.

🔒 Basic
6

Metatables (__index and Operator Overloading)

Attach a second table to decide where missing keys are looked up and what + and == mean. __index, __newindex, __eq, __lt, __call, __tostring, __len, plus rawget and rawset.

🔒 Basic
7

OOP with Tables (: and self, Class Patterns, Inheritance)

Lua has no class syntax. Passing self with :, the class pattern that points __index at itself, inheritance via __index chains, and a small class function using __call.

🔒 Basic
8

Modules and require (package.path and Caching)

A module is one file that returns a table. How require searches package.path and caches in package.loaded, why it fails from another directory, and how circular requires break and get fixed.

🔒 Basic

Chapter 3 — The Core of the Language (lessons 9–12)

Learn the four mechanisms at the root of how Lua works: closures, coroutines, error handling, and numbers. We finish by measuring floating point, whose display changed between 5.4 and 5.5.

9

Closures and Upvalues (Functions That Carry Variables)

Functions can leave their scope carrying outer local variables as upvalues. Counters, capturing loop variables, upvalues shared by several functions, and callbacks passed to a host.

🔒 Basic
10

Coroutines (Pause Now, Resume Later)

Coroutines pause a function midway and resume it while passing values. create, resume, yield, status, and wrap, then generators, producer/consumer, and waiting in game scripts.

🔒 Basic
11

Error Handling and <close> (pcall and Cleanup)

Throw with error, catch with pcall and xpcall. Using tables as error values, the classic assert idiom, <const> and <close>, and reliable cleanup with __close.

🔒 Basic
12

Integers and Floats (The Two Faces of number)

The number type's two subtypes, integer and float. Telling them apart with math.type, rounding with // and %, integer overflow wraparound, string conversion, and display changes in 5.5.

🔒 Basic

Chapter 4 — In Practice (lessons 13–16)

Work with files and time, sandbox other people's code, and learn to read how memory gets collected. We finish by turning your own module into a rock with LuaRocks and running tests with busted.

13

The Standard Library and I/O (Files, Time, Building Strings)

Read and write files with io.open and read formats, handle time with os.time, os.date, and os.clock, and build output with string.format and table.concat.

🔒 Basic
14

_ENV and Sandboxes (Running Other People's Code Safely)

_ENV, the truth behind global variables, and confining code by passing an environment to load. Building an allowlist, the string metatable loophole, and the limits of debug.sethook.

🔒 Basic
15

GC and Weak References (__mode, __gc, and the Two Modes)

Watch collection with collectgarbage. Build weak tables with __mode and write a cache that clears itself. When __gc is called, and incremental vs. generational modes.

🔒 Basic
16

LuaRocks and Testing (rockspec and busted)

Install rocks inside your project with --tree. Turn your own module into a rock with a rockspec, write tests with busted, and fix things starting from a failure.

🔒 Basic

Chapter 5 — Embedding (lessons 17–20)

Embed Lua in a C program, pass values back and forth on the stack, and expose C functions to Lua. After measuring the differences with LuaJIT, we finish by building a C host that safely loads Lua plugins.

17

The C API and the Stack (C and Lua Pass Values by Stacking Them)

The first step to embedding Lua in a C program: lua_State, luaL_newstate, luaL_dostring, and reading the virtual stack with positive and negative indexes.

🔒 Basic
18

Exposing C Functions (From lua_CFunction to C Modules)

Make C functions callable from Lua. Check arguments with luaL_check*, return the result count, and build a requireable module with luaL_Reg and luaL_newlib. Plus a first look at userdata.

🔒 Basic
19

LuaJIT and 5.1 (Running the Same Code on Both)

The LuaJIT inside Neovim and LÖVE speaks Lua 5.1. Measure differences in integers, syntax, and _ENV side by side with 5.5, and call C functions directly with the FFI.

🔒 Basic
20

Building a Plugin System (A C Host and a Lua Sandbox)

The course capstone. A C host loads plugins/*.lua one by one in an _ENV sandbox, exposes host functions, and isolates broken plugins with pcall and hooks.

🔒 Basic

Once you've finished all 20 lessons, firm up the C you used in chapter 5 from the ground up with C Intro Course, or write configs in Lua with Neovim, fish & tmux for Beginners. A membership unlocks every course.