luau-csharp-comparison.md

title	Luau and C# Comparison
description	Explains the similarities and differences between the C# and Luau programming languages.

Roblox uses the Luau programming language. The following code samples and tables indicate some of the differences between syntaxes for C# and Luau.

Line Endings

You don't need semicolons in Luau, but they don't break the syntax.

Reserved Keywords

The following table has Luau's reserved keywords mapped to their C# equivalent. Note it doesn't show all C# keywords.

Lua	C#
`and`
`break`	`break`
`do`	`do`
`if`	`if`
`else`	`else`
`elseif`	`else if`
`then`
`end`
`true`	`true`
`false`	`false`
`for`	`for` / `foreach`
`function`
`in`	`in`
`local`
`nil`	`null`
`not`
`or`
`repeat`
`return`	`return`
`until`
`while`	`while`

Comments

-- Single line comment

--[[ Resulting output:
	Block comment
--]]

// Single line comment

/*
	Block comment
*/

Strings

-- Multi-line string
[[This is a string that,
when printed, appears
on multiple lines]]

-- Concatenation
s1 = "This is a string "
s2 = "made with two parts."
endString = s1 .. s2

// Multi-line string
"This is a string that,\nwhen printed, appears\n on multiple lines."

string multiLineString = @"This is a string that,
when printed, appears
on multiple lines";

// Concatenation
string s1 = "This is a string ";
string s2 = "made with two parts.";
string endString = s1 + s2;

Tables

To learn more about tables in Luau, see Tables.

Dictionary Tables

You can use tables in Luau as dictionaries just like in C#.

local dictionary = {
	val1 = "this",
	val2 = "is"
}

print(dictionary.val1)  -- Outputs 'this'
print(dictionary["val1"])  -- Outputs 'this'

dictionary.val1 = nil  -- Removes 'val1' from table
dictionary["val3"] = "a dictionary"  -- Overwrites 'val3' or sets new key-value pair

Dictionary dictionary = new Dictionary()
{
	{ "val1", "this" },
	{ "val2", "is" }
};

Console.WriteLine(dictionary["val1"]);  // Outputs 'this'
dictionary.Remove("val1");  // Removes 'val1' from dictionary

dictionary["val3"] = "a dictionary";  // Overwrites 'val3' or sets new key-value pair
dictionary.Add("val3", "a dictionary");  // Creates a new key-value pair

Numerically-Indexed Tables

You can use tables in Luau as arrays just like in C#. Indices start at 1 in Luau and 0 in C#.

local npcAttributes = {"strong", "intelligent"}

print(npcAttributes[1])  -- Outputs 'strong'
print(#npcAttributes)  -- Outputs the size of the list

-- Append to the list
table.insert(npcAttributes, "humble")
-- Another way...
npcAttributes[#npcAttributes+1] = "humble"

-- Insert at the beginning of the list
table.insert(npcAttributes, 1, "brave")

-- Remove item at a given index
table.remove(npcAttributes, 3)

List npcAttributes = new List{"strong", "intelligent"};

Console.WriteLine(npcAttributes[0]);  // Outputs 'strong'
Console.WriteLine(npcAttributes.Count);  // Outputs the size of the list

// Append to the list
npcAttributes.Add("humble");
// Another way...
npcAttributes.Insert(npcAttributes.Count, "humble");

// Insert at the beginning of the list
npcAttributes.Insert(0, "brave");

// Remove item at a given index
npcAttributes.Remove(2);

Operators

Conditional Operators

Operator	Lua	C#
Equal To	`==`	`==`
Greater Than	`>`	`>`
Less Than	`<`	`<`
Greater Than or Equal To	`>=`	`>=`
Less Than or Equal To	`<=`	`<=`
Not Equal To	`~=`	`!=`
And	`and`	`&&`
Or	`or`	`||`

Arithmetic Operators

	Lua	C#
Addition	`+`	`+`
Subtraction	`-`	`-`
Multiplication	`*`	`*`
Division	`/`	`/`
Modulus	`%`	`%`
Exponentiation	`^`	`**`

Variables

In Luau, variables don't specify their type when you declare them. Luau variables don't have access modifiers, although you may prefix "private" variables with an underscore for readability.

local stringVariable = "value"

-- "Public" declaration
local variableName

-- "Private" declaration - parsed the same way
local _variableName

string stringVariable = "value";

// Public declaration
public string variableName

// Private declaration
string variableName;

Scope

In Luau, you can write variables and logic in a tighter scope than their function or class by nesting the logic within do and end keywords, similar to curly brackets {} in C#. For more details on scope in Luau, please see the Scope.

local example = "Example text"

do
	local example = example .. " changed!"
	print(example)  -- Outputs 'Example text changed!'
end

print(example)  -- Outputs 'Example text'

string example = "Example text";

{
	example += " changed!";
	Console.WriteLine(example);  // Outputs 'Example text changed!'
}


Console.WriteLine(example);  // Outputs 'Example text'

Conditional Statements

-- One condition
if boolExpression then
	doSomething()
end

-- Multiple conditions
if not boolExpression then
	doSomething()
elseif otherBoolExpression then
	doSomething()
else
	doSomething()
end

// One condition
if (boolExpression) {
	doSomething();
}


// Multiple conditions
if (!boolExpression) {
	doSomething();
}
else if (otherBoolExpression) {
	doSomething();
}
else {
	doSomething();
}

Conditional Operator

Luau doesn't offer a direct equivalent to the C# conditional operator, a ? b : c. However, the Luau idiom a and b or c offers a close approximation, provided b isn't false or nil.

local max = x > y and x or y

int max = (x > y) ? x : y;

Loops

To learn more about loops in Luau, see Control Structures.

While and Repeat Loops

while boolExpression do
	doSomething()
end

repeat
	doSomething()
until not boolExpression

while (boolExpression) {
	doSomething();
}

do {
	doSomething();
} while (boolExpression)

For Loops

-- Forward loop
for i = 1, 10 do
	doSomething()
end

-- Reverse loop
for i = 10, 1, -1 do
	doSomething()
end

// Forward loop
for (int i = 1; i <= 10; i++) {
	doSomething();
}

// Reverse loop
for (int i = 10; i >= 1; i--) {
	doSomething();
}

local abcList = {"a", "b", "c"}

for i, v in ipairs(abcList) do
	print(v)
end

local abcDictionary = { a=1, b=2, c=3 }

for k, v in pairs(abcDictionary) do
	print(k, v)
end

List<string> abcList = new List<string>{"a", "b", "c"};

foreach (string v in abcList) {
	Console.WriteLine(v);
}

Dictionary<string, int> abcDictionary = new Dictionary<string, int>
{ {"a", 1}, {"b", 2}, {"c", 3} };


foreach (KeyValuePair<string, int> entry in abcDictionary) {
	Console.WriteLine(entry.Key + " " + entry.Value);
}

Functions

To learn more about functions in Luau, see Functions.

Generic Functions

-- Generic function
local function increment(number)
	return number + 1
end

// Generic function
int increment(int number) {
	return number + 1;
}

Variable Argument Number

-- Variable argument number
local function variableArguments(...)
	print(...)
end

// Variable argument number
void variableArguments(params string[] inventoryItems) {
	for (item in inventoryItems) {
		Console.WriteLine(item);
	}
}

Named Arguments

-- Named arguments
local function namedArguments(args)
	return args.name .. "'s birthday: " .. args.dob
end

namedArguments{name="Bob", dob="4/1/2000"}

// Named arguments
string namedArguments(string name, string dob) {
	return name + "'s birthday: " + dob;
}

namedArguments(name: "Bob", dob: "4/1/2000");

Try/Catch Structures

local function fireWeapon()
	if not weaponEquipped then
		error("No weapon equipped!")
	end
	-- Proceed...
end

local success, errorMessage = pcall(fireWeapon)
if not success then
	print(errorMessage)
end

void fireWeapon() {
	if (!weaponEquipped) {
		// Use a user-defined exception
		throw new InvalidWeaponException("No weapon equipped!");
	}
	// Proceed...
}

try {
	fireWeapon();
} catch (InvalidWeaponException ex) {
	// An error was raised
}