Explore Black History

This article needs more citations. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "Luau" programming language – news · newspapers · books · scholar · JSTOR (January 2026) (Learn how and when to remove this message)

Luau
Paradigm	Multi-paradigm: scripting, imperative, procedural, functional
Family	Lua
Designed by	Arseny Kapoulkine
Developer	Roblox Corporation, Open source contributors
First appeared	August 27, 2019; 7 years ago (2019-08-27)
Typing discipline	Gradual, dynamic, structural
Memory management	Garbage collector
Implementation language	C++
License	MIT
Filename extensions	.luau
Website	luau.org
Influenced by
Lua 5.1, TypeScript, Python, LuaJIT

Luau (/ˈluː.aʊ/, LOO-ow) is an open-source scripting language derived from Lua 5.1. Developed by Roblox Corporation, it serves as the primary scripting language for the Roblox platform. Luau adds gradual typing, performance improvements, and sandboxing features to the base Lua language while maintaining backward compatibility with Lua 5.1.

The language was released to Roblox developers in August 2019 and became free and open-source software under an MIT License in November 2021.^[1] Since its open-source release, Luau has been adopted by several video game developers outside of Roblox, including Remedy Entertainment for Alan Wake 2,^[2] Digital Extremes for Warframe,^[3] and Giants Software for Farming Simulator 2025.^[4]

Roblox originally used a modified version of Lua 5.1 as its scripting language. As the platform grew, developers began creating larger and more complex projects. The engineering team identified two main problems with standard Lua at this scale: the lack of a type system made error detection difficult, and the standard Lua interpreter had performance limits.^[5]

The team considered adopting LuaJIT, a just-in-time compiler implementation of Lua known for high performance. However, LuaJIT had limited support for some platforms, more so video game consoles, and presented maintenance challenges. Roblox decided to create their own language based on Lua 5.1 instead.^[6]

Luau was deployed on the Roblox platform on August 27, 2019. The language was initially called the "Faster Lua VM" (virtual machine) before receiving its current name.^[6] On November 3, 2021, Roblox released Luau as open-source software under an MIT License, making the runtime, compiler, type checker, and linter publicly available on GitHub.^[1]

For data types, Luau implements gradual typing, allowing developers to add type annotations to code or leave it to dynamic typing. The type system includes type inference, which automatically determines variable types based on use without needing explicit annotations.^[5]

-- Examples of common Luau type annotations
: number -- integers and floats
: string -- text
: boolean -- true or false
: any -- variable can be set to any type

local baseNumber: number = 1
-- baseNumber has the type "number"

local baseNumber = 1 :: number
-- 1 has been cast the type "number", overriding the inferred type

The language supports two typing modes. Strict mode needs more precise type annotations and aims to catch type errors before runtime. Non-strict mode is more permissive and designed to minimize false positives when gradually adding types to extant code. These modes can be set per module using directives.^[7]

Luau uses structural typing rather than nominal typing. The type checker verifies that tables contain the needed fields with correct types instead of checking class names or inheritance relationships. Luau was the first language to implement semantic subtyping for a large user base, using type normalization to check subtype relationships.^[7]

The Luau runtime is implemented in C++ as a new virtual machine rather than a modification of the standard Lua VM.^[8] The compiler performs several optimizations before code execution, including constant folding, dead code elimination, and peephole optimization. The interpreter uses inline caching to improve table field access performance.

Benchmarks show Luau's interpreter performing comparably to LuaJIT's interpreter mode. When LuaJIT uses just-in-time compilation, it maintains a performance advantage of approximately 1.6x in some tests.^[9]

In October 2023, Luau added native code generation capability.^[10] This feature compiles Luau bytecode directly to machine code for x64 and ARM64 architectures, including processors with Advanced Vector Extensions 1 (AVX1) support and Apple silicon. Performance improvements from native code generation typically range from 1.5x to 2.5x for computationally intensive code.^[10]

The compiler can process about 950,000 lines of code per second on a Ryzen 5900X processor with all optimizations enabled.^[8]

Luau maintains syntactic compatibility with Lua 5.1 while adding features from other languages. The language supports augmented assignment operators (+=, -=, *=, etc.).^[11] String interpolation was added in February 2023, allowing variables to be embedded directly in string literals using backtick syntax.^[12][13] Luau also includes conditional expressions similar to ternary operators in other languages.^[14]

local baseNumber: number = 1

-- Augmented assignment
baseNumber += 1 

-- Conditional expressions 
local isBaseNumberTwo: number = if baseNumber == 2 then true else false

-- String interpolation
print(`The baseNumber is {baseNumber}`)
--> The baseNumber is 2

Additional features include the continue keyword to skip the remaining code in a loop's current irritation and move to the next one^[15], and the const keyword for local variable bindings that cannot be modified once initiated.^[16]

const fruits: {string} = table.freeze({"Apple", "Pear", "Banana"})
const pearFruit: string = "Pear"
local foundPearFruit: boolean = false

for i: number, fruit: string in fruits do
    if pearFruit ~= fruit then
        continue
    end
    
    print("Found pear fruit!")
    foundPearFruit = true
    
    break
end

pearFruit = "Apple" -- fail

Luau includes security features for running untrusted code. The standard library does not provide access to the file system or operating system. The runtime enforces resource limits on memory use and can interrupt long-running code to prevent infinite loops from blocking execution.^[8]

The garbage collector uses an incremental design with a PID controller for heap pacing, based on techniques from the Go garbage collector.^[8] This reduces pause times compared to stop-the-world collection. The system includes optimizations for closures, upvalues, and weak tables.

Luau is the primary scripting language for the Roblox platform, handling game logic, physics, and user interface systems across millions of user-created experiences.

Luau also serves as a scripting language for platforms such as Polytoria 2.0 and Vortex, which were inspired to some extent by the aesthetic of old Roblox.

Remedy Entertainment replaced their proprietary scripting language with Luau in the Northlight engine for Alan Wake 2. The migration removed approximately 80,000 lines of legacy code. Remedy developed a Visual Studio Code language server extension for Luau integration.^[2]

Digital Extremes migrated Warframe from their existing Lua implementation to Luau. The change was motivated by improvements in garbage collection and memory efficiency.^[3]

Giants Software adopted Luau for Farming Simulator 2025, moving from LuaJIT. The company provides modding tools through the Giants Developer Network that support Luau scripting.^[4]

In December 2025, Linden Lab released SLua, a Luau-based scripting system for Second Life. SLua serves as an alternative to the Linden Scripting Language.^[17]

The Luau compiler operates in multiple passes, first parsing source code into an abstract syntax tree before generating bytecode.^[18] The compiler offers three optimization levels. Level 0 applies minimal optimizations. Level 1 (default) performs constant folding, upvalue optimization, and peephole optimization while preserving debugging information. Level 2 adds function inlining and loop unrolling.

The bytecode uses a register-based virtual machine with approximately 200 available registers. Instructions are 4 bytes in length, with constants stored in a separate constant pool.^[18]

The Luau team has published several academic papers on the type system. The initial paper, "Position Paper: Goals of the Luau Type System," was presented at HATRA 2021.^[5] Subsequent papers include "Goals of the Luau Type System, Two Years On" (2023) and "Towards an Unsound But Complete Type System" (2024).^[19]

• Lua
• TypeScript
• Roblox Studio
• Gradual typing
• Type inference

• Official website
• Luau on GitHub
• Luau Research Papers