SLua
A First Look at SLua
Published On: March 15, 2025
Estimated Reading Time: 12 minutes
This past week SLua was released to the beta grid (Aditi) on Second Life, itself a branch of Luau created by Roblox as a way to run scripts in their game engine. SLua is a fork of Luau—the scripting language used by Roblox—and brings significant enhancements in power and flexibility to Second Life scripting.
What I intend to do in this article is explore some of the expanded feature set in SLua and how that can help us in scripting for Second Life in the future. This is by no means an exhaustive list of the new features in SLua but I hope it gives you an idea of what is possible with the language.
I'm not going to cover the basics, you can see Linden Lab's documentation and introduction for that at the wiki here:
#New Features
#Dynamic Methods
SLua brings with it the functionality of Lua. Something Lua doesn't have natively but we can implement is namespaces. This is a way to group functions and variables together under a common name. This is useful for keeping things organized and preventing naming conflicts. This is something that is not possible in LSL and is a welcome addition to SLua.
We can achieve this by using tables in Lua. Tables are a data structure that can hold multiple values. We can use tables to create namespaces by creating a table and then adding functions and variables to it. We can then access these functions and variables by using the table name followed by a dot and then the function or variable name.
1local myNamespace = {}
2
3myNamespace.example = function()
4 ll.OwnerSay("Hello, World!")
5end
6
7myNamespace.example()
This will output "Hello, World!" to chat. This is a simple example but it shows how we can use tables to create namespaces in Lua.
Example of dynamically creating functions:
1local emptyFunction = function() end
2
3emptyFunction = function()
4 ll.OwnerSay("Hello, World!")
5end
6
7emptyFunction()
This isn't incredibly powerful in this example but it shows how we can reassign functions to variables. This is useful for creating functions on the fly and passing them around as variables.
Expanding upon this idea we also have anonymous functions in Lua. These are functions that do not have a name and are instead assigned to a variable. This is incredibly useful as we can do a few things now. We can organise our bootstrap code into a namespace and have them labeled as such rather than using prefixes to our method names as we did in LSL.
1local tables = {
2 [01] = function()
3 ll.OwnerSay("Hello, World!")
4 end,
5 [02] = function()
6 ll.OwnerSay("Goodbye, World!")
7 end
8}
9
10tables[01]()
11tables[02]()
#Callback Methods
Callback methods are functions that are passed as arguments to other functions. This is a powerful feature that can be used in many different ways to build flexible and modular code. We can use callback methods to create custom behaviour for functions, allowing us to change the behaviour of functions without changing their code.
1function binary_op(a, b, callback)
2 return callback(a, b)
3end
4
5ll.OwnerSay(binary_op(1, 2, function(a, b)
6 return a + b
7end))
In this example, we have a function called binary_op that takes two numbers and a callback function as arguments. The callback function is called with the two numbers as arguments and the result is returned. We can pass different callback functions to binary_op to change the behaviour of the function. Of course we aren't going to use this for simple addition but it is a good example of how we can use callback methods to create custom behaviour for functions.
Callbacks allow scripts to execute customizable behavior dynamically by passing functions as arguments. In Second Life, this means scripts can be modularized, with behaviors adjusted at runtime, leading to more reusable, adaptable, and maintainable scripting components.
Something we could implement using this is the array_walk method from PHP. This is a method that takes an array and a callback function as arguments. The callback function is called with each element of the array as an argument. This is a powerful feature that can be used in many different ways to build flexible and modular code.
1function table_walk(array, callback)
2 for i, v in ipairs(array) do
3 callback(v, i)
4 end
5end
6
7local myArray = {1, 2, 3, 4, 5}
8
9table_walk(myArray, function(v, i)
10 ll.OwnerSay("Index: " .. i .. ", Value: " .. v)
11end)
We can do this for any number of functions such as preg_replace_callback and call_user_func both of which I've created below.
1function preg_replace_callback(pattern, subject, callback)
2 return string.gsub(subject, pattern, callback)
3end
4
5local output = preg_replace_callback(text, "%d+", function(match)
6 local num = tonumber(match)
7 return tostring(num + 1)
8end)
9
10ll.OwnerSay(output)
1function call_user_func(func, ...)
2 return func(...)
3end
4
5local output = call_user_func(function(a, b)
6 return a + b
7end, 1, 2)
8
9ll.OwnerSay(output)
Much like many other features, this will improve our ability as creators to create more interesting and complex scripts. By embracing callbacks we're able to build richer interactive experiences, create adaptable and reusable components, and foster a scripting environment where creativity and technical skill can flourish.
#Coroutines
Coroutines introduce a robust way to pause and resume scripts without relying solely on timers. This makes managing timed or sequential events—like user input, animations, or asynchronous interactions—far simpler, resulting in smoother, more responsive experiences in-world without cluttering scripts with complex timer logic.
1local example = function()
2 ll.OwnerSay("Hello, World!")
3 coroutine.yield()
4 ll.OwnerSay("Goodbye, World!")
5end
6
7local exampleCoroutine = coroutine.create(example)
8
9coroutine.resume(exampleCoroutine)
Continuing with the "Hello, World!" examples we can see that we can pause our functions at a particular point, resuming them only when we want or need to.
#Metatables
Metatables redefine the behavior of tables, enabling advanced operations such as custom arithmetic or controlled property access. For Second Life scripters, this means easier handling of complex data types such as vectors, rotations, or custom objects, improving both readability and efficiency of code.
Metatables are one of Lua's more advanced features, allowing us to redefine how tables behave under various operations, like addition or indexing.
The __index metamethod is used to index a table. When we try to access a key in a table that doesn't exist, Lua will look for the key in the table's metatable. If the key exists in the metatable, Lua will return the value associated with that key.
The __add metamethod is used to add two tables together. When we use the + operator on two tables, Lua will look for the __add metamethod in the metatable of the first table. If the metamethod exists, Lua will call it with the second table as an argument.
1local defaults = {a = 1, b = 2}
2
3local myTable = setmetatable({}, {
4 __index = defaults
5})
6
7ll.OwnerSay(myTable.a) -- Output: 1
8ll.OwnerSay(myTable.b) -- Output: 2
9
10myTable.a = 10
11ll.OwnerSay(myTable.a) -- Output: 10
1local Vector = {}
2Vector.__index = Vector
3
4function Vector.new(x, y)
5 local self = setmetatable({}, Vector)
6 self.x = x
7 self.y = y
8 return self
9end
10
11function Vector.__add(v1, v2)
12 return Vector.new(v1.x + v2.x, v1.y + v2.y)
13end
14
15local v1 = Vector.new(ll.GetPos().x, ll.GetPos().y)
16local v2 = Vector.new(5, 7)
17
18local v3 = v1 + v2
19ll.OwnerSay("v3.x = " .. v3.x .. ", v3.y = " .. v3.y)
#Tables
I've used tables a lot in the examples above but I haven't really explained what they are. Tables are a data structure that can hold multiple values. They are similar to lists in LSL but they are much more flexible, very much like arrays in other programming languages. We can use tables to store data, create objects, and create custom data structures and namespace as I've already demonstrated.
Tables provide versatile data structures, acting as lists, dictionaries, or even objects. This flexibility allows us as scripters to easily manage collections of data, settings, or configurations, enabling more complex, organized, and efficient data management than was previously possible with LSL's limited lists.
Tables can be indexed by numbers, strings, and even other tables. This flexibility makes them useful as arrays, dictionaries, or even complex data structures. We can use numbers to access elements in a table like we would with a list. We can use strings to access elements in a table like we would with a dictionary.
1local table = {
2 a = 1,
3 b = 2,
4 c = 3
5}
6
7local keyValuePair = {
8 ["a"] = 1,
9 ["b"] = 2,
10 ["c"] = 3
11}
12
13local index = {1, 2, 3}
14
15ll.OwnerSay(table.a) -- Output: 1
16ll.OwnerSay(keyValuePair["a"]) -- Output: 1
17ll.OwnerSay(index[1]) -- Output: 1
Tables can also be used to create objects. We can create a table and then add functions and variables to it. We can then create multiple instances of this table, each with their own data. This is a powerful feature that can be used to create custom data structures and objects. I already demonstrated this with the Vector example above.
#Error Handling
In LSL we don't have a way to handle errors. If an error occurs in our script, the script will stop running and the error message will be output to the debug channel. This can be frustrating as we have no way to recover from errors or handle them gracefully. In SLua we have the ability to handle errors using the pcall function. This function takes a function as an argument and runs it. If an error occurs in the function, pcall will return false and the error message. If no error occurs, pcall will return true and the return values of the function.
1local success, result = pcall(function()
2 error("An error occurred!")
3end)
4
5if success then
6 ll.OwnerSay("No error occurred!")
7else
8 ll.OwnerSay("An error occurred: " .. result)
9end
Built-in error handling allows scripts to gracefully manage runtime errors, preventing scripts from halting unexpectedly. For Second Life scripters, this ensures scripts are more robust, stable, and capable of recovery from unexpected issues, improving overall reliability and user experience in-world.
#Project Conversion
I've converted a couple of my projects to SLua so far and the process is relatively painless but the differences between languages are significant. Rewriting some code to take advantage of SLua is a great idea, the speed improvements alone are worth it. The new features are also a great addition to the language and I'm excited to see what the community can do with them.
Below I've included one of my converted scripts for MSF-, an esoteric language. Firstly I've included the LSL version and then the SLua version. The SLua version is much more efficient and uses tables to accumulate output for efficiency. This is a simple example but it shows how we can use tables to create namespaces in Lua. Note that the LSL version does use FURWare to output data to a screen but this does not have a significant impact on the script itself.
1integer memory = 0;
2string output = "";
3string PROGRAM_VERSION = "0.3";
4list ASCII = [
5 "", "", "", "", "", "", "", "", "", "\t", "\n", "", "", "\r", "", "",
6 "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
7 " ", "!", "\"", "#", "$", "%", "&", "'", "(", ")", "*", "+", ",", "-", ".", "/",
8 "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ":", ";", "<", "=", ">", "?",
9 "@", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O",
10 "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "[", "\\", "]", "^", "_",
11 "`", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o",
12 "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "{", "|", "}", "~", "",
13 "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
14 "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "",
15 "", "¡", "¢", "£", "¤", "¥", "¦", "§", "¨", "©", "ª", "«", "¬", "", "®", "¯",
16 "°", "±", "²", "³", "´", "µ", "¶", "·", "¸", "¹", "º", "»", "¼", "½", "¾", "¿",
17 "À", "Á", "Â", "Ã", "Ä", "", "Æ", "Ç", "È", "É", "Ê", "Ë", "Ì", "Í", "Î", "Ï",
18 "Ð", "Ñ", "Ò", "Ó", "Ô", "Õ", "Ö", "×", "Ø", "Ù", "Ú", "Û", "Ü", "Ý", "Þ", "ß",
19 "à", "á", "â", "ã", "ä", "å", "æ", "ç", "è", "é", "ê", "ë", "ì", "í", "î", "ï",
20 "ð", "ñ", "ò", "ó", "ô", "õ", "ö", "÷", "ø", "ù", "ú", "û", "ü", "ý", "þ", "ÿ"
21];
22
23string integerToChar(integer i) {
24 return llList2String(ASCII, i);
25}
26
27setText(string text) {
28 llSetText("MiniStringFuck Interpreter v" + PROGRAM_VERSION + "\n" + text, <1,1,1>, 1.0);
29}
30
31parse(string program) {
32 memory = 0;
33 list outputList = [];
34 integer progLen = llStringLength(program);
35 integer i = 0;
36
37 for (i = 0; i < progLen; i++) {
38 if (i % 50 == 0) {
39 setText("Processing " + (string)i + "/" + (string)progLen);
40 }
41
42 string currentChar = llGetSubString(program, i, i);
43
44 if (currentChar == "+") {
45 memory++;
46 if (memory > 255) {
47 memory = 0;
48 }
49 } else if (currentChar == ".") {
50 outputList += [ integerToChar(memory) ];
51 if (i % 50 == 0) {
52 output = llDumpList2String(outputList, "");
53 llMessageLinked(LINK_SET, 0, output, "fw_data : default");
54 }
55 }
56 }
57
58 output = llDumpList2String(outputList, "");
59 llMessageLinked(LINK_SET, 0, output, "fw_data : default");
60 setText("Done");
61}
62
63idle() {
64 setText("Ready");
65}
66
67default {
68 state_entry() {
69 llMessageLinked(LINK_SET, 0, "MSF- Booting...", "fw_data : logger");
70 llSleep(0.5);
71 idle();
72 llMessageLinked(LINK_SET, 0, "", "fw_data : logger");
73 }
74
75 touch_start(integer total_number) {
76 llMessageLinked(LINK_SET, 0, "", "fw_data : default");
77 string program = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.";
78 parse(program);
79 idle();
80 memory = 0;
81 output = "";
82 }
83
84 link_message(integer sender, integer num, string str, key id) {
85 if (id == "fw_ready") {
86 llOwnerSay("FW text is up and running!");
87 llMessageLinked(sender, 0, "c=white", "fw_conf");
88 llMessageLinked(sender, 0, "Default text", "fw_data : logger");
89 }
90 }
91}
Converting this to SLua let me introduce optimisations. This script utilises tables to accumulate output for efficiency, combined with the design of Lua this is a much more efficient script. The script is also much more readable and easier to understand as it is simpler and more concise.
1local memory = 0
2local output = ""
3local program = "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++.+++++++..+++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++.+++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++."
4
5function intToAscii(i)
6 return string.char(i)
7end
8
9function setText(text)
10 ll.SetText(text, vector(0, 0, 0), 1)
11end
12
13function parse(program)
14 memory = 0
15 local outputChars = {}
16 local progLen = #program
17 for i = 1, progLen do
18 if i % 1000 == 0 then
19 setText("Processing " .. i .. "/" .. progLen)
20 end
21
22 local c = program:sub(i, i)
23
24 if c == '+' then
25 memory = memory + 1
26 if memory > 255 then
27 memory = 0
28 end
29 elseif c == '.' then
30 table.insert(outputChars, intToAscii(memory))
31
32 if #outputChars % 100 == 0 then
33 setText(table.concat(outputChars))
34 end
35 end
36 end
37 output = table.concat(outputChars)
38 setText(output)
39end
40
41function touch_start(total_number)
42 parse(program)
43end
This is obviously not a useful script but it is a good demonstration of how we can use tables to accumulate output for efficiency.
#Conclusion
SLua is a powerful language that brings with it many new features that can help us in scripting for Second Life. The expanded feature set in SLua is a welcome addition to the language and I'm excited to see what the community can do with it. I'm looking forward to it being released to the main grid and seeing what people can do with it.