From LSL to Lua

For LSL Scripters

You already know how Second Life scripting works—events, permissions, object communication, inventory management. All of that knowledge transfers directly to Lua. This page focuses on the syntax and pattern differences you need to know.

Tip

LSL still works! Your existing scripts continue to run, and LSL is fully supported. Lua is an option, not a requirement.

Why Consider Lua?

• Faster execution and ~50% less memory than LSL/Mono
• Modern features: coroutines, gradual typing, multiple return values
• Easier development: familiar syntax, better tooling, standard libraries
• Same ll functions* you already know

Syntax Quick Reference

Comments & Structure

LSL

SLua

Variables & Types

LSL

SLua

Caution

Type annotations recommended! While optional, they catch errors before runtime and make code self-documenting.

Typecasting

In many cases, Luau does typecasting automatically. Here’s how to do it explicitly:

LSL

SLua

LSL and Lua typecasts return different results on invalid input: LSL returns “zero”; Lua returns nil. The Lua examples include an or expressions that converts nil to what LSL typecast would have returned

Operators

Operation	LSL	Lua	Notes
Not equal	!=	~=	Different operator
Logical AND	&&	and	Word, not symbol
Logical OR	||	or	Word, not symbol
Logical NOT	!	not	Word, not symbol
String concat	+	..	Different operator
Increment	x++	x = x + 1 or x += 1	No ++ operator
Decrement	x--	x = x - 1 or x -= 1	No -- operator
Power	llPow(2, 3)	2 ^ 3	Native operator
Integer division	7 / 4 → 1	7 // 4 → 1	Use // not /
String length	llStringLength(s)	#s	Native operator
Bitwise AND	llGetAgentInfo(id) & AGENT_TYPING	bit32.btest(ll.GetAgentInfo(id), AGENT_TYPING)	No & operator (1)
Bitwise OR	PASSIVE | SCRIPTED	bit32.bor(PASSIVE, SCRIPTED)	No | operator
Bitwise NOT	~0	bit32.bnot(0)	No ~ operator (2)
Bitwise eXclusive OR	6 ^ 3	bit32.bxor(6, 3)	^ means Power instead (2)
Bitwise Shift Left	1 << 2	bit32.lshift(1, 2)	No << operator (2)
Bitwise Shift Right	0x80000000 >> 2	bit32.arshift(0x80000000, 2)	No >> operator (2)

Notes:

1. bit32.btest returns a boolean; bit32.band returns an integer. Both match the behavior of LSL &. Integers (bit32.band) don’t work inside if statements, unlike LSL. Use whichever is most appropriate.
2. Hexadecimal numbers 0x8000000 and above are positive in Lua, but negative in LSL, due to different number formats (signed 32-bit int vs 64-bit float). Use bit32.s32 to wrap large numbers down to the 32-bit signed integer range for LSL compatability.

Control Flow

LSL

SLua

Functions

LSL

SLua

Lists vs Tables

Tables are Lua’s most powerful data structure. Unlike LSL’s separate list type, tables serve two purposes: they work as both arrays (like LSL lists) and dictionaries/maps (which LSL doesn’t have).

Tables as Arrays (LSL list replacement)

LSL

SLua

Danger

1-based indexing! This is the #1 source of migration bugs. Arrays/tables start at index 1, not 0!

Tables as Dictionaries/Maps

LSL doesn’t have a dictionary/map type—you had to use two parallel lists for key-value pairs. Lua tables can store key-value pairs natively:

-- Dictionary/map
local playerData: {[string]: number} = {
    ["Alice"] = 100,
    ["Bob"] = 85,
    ["Charlie"] = 92
}

-- Access values by key
local aliceScore: number = playerData["Alice"]  -- 100

-- Add/update entries
playerData["Diana"] = 88
playerData["Alice"] = 105  -- Update

-- Check if key exists
if playerData["Unknown"] ~= nil then
    ll.Say(0, "Found!")
end

-- Iterate over key-value pairs
for name: string, score: number in playerData do
    ll.Say(0, `{name}: {score}`)
end

Shorthand syntax for string keys:

-- Instead of brackets and quotes, use dot notation
local player = {
    name = "Alice",
    health = 100,
    position = vector(10, 20, 30)
}

ll.Say(0, player.name)  -- "Alice"
player.health = 50  -- Update

Mixed Tables

Tables can even mix numeric indices and string keys:

local data = {
    10, 20, 30,  -- Indices 1, 2, 3
    name = "Alice",  -- String key
    active = true    -- String key
}

ll.Say(0, `First: {data[1]}`)  -- 10
ll.Say(0, `Name: {data.name}`)  -- "Alice"

Tip

Tables are versatile data structures. Use them with numeric indices for arrays, or with string keys for dictionaries/maps. They replace LSL lists and provide dictionary/map functionality that LSL never had.

String Operations

LSL

SLua

ll* Functions

LSL

SLua

Key difference: Use ll.FunctionName (dot notation), not llFunctionName.

Event Handling: The Big Change

This is the most significant difference between LSL and Lua. Instead of state-based event handlers, Lua uses event callbacks with LLEvents:on().

LSL

SLua

Lua Event Patterns

Basic event handler:

LLEvents:on("touch_start", function(events: {DetectedEvent})
    ll.Say(0, `Touched by {events[1]:getName()}`)
end)

Multiple events (run simultaneously):

LLEvents:on("touch_start", function(events: {DetectedEvent})
    ll.Say(0, "Touched!")
end)

LLEvents:on("collision_start", function(events: {DetectedEvent})
    ll.Say(0, "Collision!")
end)

Listen events:

ll.Listen(0, "", NULL_KEY, "")

LLEvents:on("listen", function(channel: number, name: string, id: string, message: string)
    ll.Say(0, `{name} said: {message}`)
end)

Accessing detected data:

LLEvents:on("touch_start", function(events: {DetectedEvent})
    for i, event in events do
        local name: string = event:getName()
        local key: uuid = event:getKey()
        ll.Say(0, `{name} touched me!`)
    end
end)

Global Variables

LSL

SLua

Common Patterns

Door Script

LSL

SLua

Timer Events

LSL

SLua

Type Annotations Guide

While types are optional, use them in your code! They catch errors and improve readability. Learn more about Luau’s type system.

-- Basic types
local count: number = 0
local name: string = "Alice"
local active: boolean = true

-- SL types
local pos: vector = vector(10, 20, 30)
local rot: rotation = rotation(0, 0, 0, 1)
local id: string = "uuid-here"

-- Tables/arrays
local scores: {number} = {95, 87, 92}
local names: {string} = {"Alice", "Bob"}

-- Custom types
type Player = {
    name: string,
    health: number,
    position: vector
}

local player: Player = {
    name = "Alice",
    health = 100,
    position = vector(0, 0, 0)
}

-- Function types (always use!)
function heal(player: Player, amount: number): Player
    player.health = player.health + amount
    return player
end

Standard Libraries

Lua includes Lua standard libraries you can use alongside ll* functions. See the full Luau library reference for more details.

-- String library
string.upper("hello")  -- "HELLO"
string.sub("hello", 1, 2)  -- "he" (1-based!)
string.format("Health: %d", health)

-- Table library
table.insert(items, value)
table.remove(items, index)
table.sort(items)

-- Math library
math.floor(3.7)  -- 3
math.ceil(3.2)  -- 4
math.random(1, 10)  -- Random 1-10
math.abs(-5)  -- 5

Next Steps

• Lua Basics - Deep dive into the language
• Lua Events - Master event handling patterns
• Lua Reference - All ll* functions
• Lua FAQ - Common questions