luau-lang/luau
Luau
Luau is a high-performance programming language evolved from Lua 5.1. It consists of a bytecode virtual machine, an embeddable scripting engine, and a static code analyzer designed to provide a secure, sandboxed execution environment for host applications.
The project is distinguished by its gradual typing system, which combines automatic type inference with optional manual annotations to detect bugs without requiring full static typing. It also features native vector mathematics for high-performance operations and a specialized debugging system that uses bytecode patching to minimize execution overhead.
The runtime includes a wide array of execution optimizations, including incremental garbage collection, inline caching for tables, and peephole bytecode optimization. The type system supports configurable strictness levels, control-flow type refinement, and structural table shape validation.
The project provides a C API for embedding the engine into applications and a command-line interface for script execution and development.
Features
- Bytecode Virtual Machines - Provides a specialized bytecode virtual machine with a tuned interpreter for high-performance script execution.
- Language Dialects - Provides a high-performance evolution of the Lua 5.1 language with enhanced speed and safety features.
- Embeddable Scripting Engines - Ships an embeddable scripting engine with a C API for integrating sandboxed execution into host applications.
- Bytecode Interpreters - Implements a tuned bytecode interpreter designed for efficient assembly generation and fast instruction dispatch.
- Embedded Scripting Engines - Provides a lightweight scripting engine that can be embedded into host applications via a C API.
- Gradual Typing Systems - Implements a gradual typing system that combines automatic type inference with optional manual annotations.
- High-Performance Runtimes - Provides a high-performance execution engine combining a fast bytecode compiler and incremental garbage collector.
- Incremental Garbage Collection - Minimizes stop-the-world pauses via incremental marking for coroutines and a specialized remark step.
- Sandboxed Code Execution Environments - Provides a secure, sandboxed execution environment to protect host systems from untrusted or unstable code.
- Virtual Machine Optimizations - Accelerates code execution through a specialized virtual machine that optimizes loops and method calls.
- General Bug Detection - Detects potential errors, dead code, and stylistic inconsistencies through automated linting passes.
- Static Code Analysis - Ships a static code analyzer that checks source files for type errors and linting warnings.
- Memory Allocators - Employs a domain-specific pool allocator tuned for scripting workloads to outperform general-purpose memory allocators.
- Configurable Strictness Levels - Provides configurable type checking modes ranging from no checks to strict enforcement for individual files.
- Bytecode Iteration Optimization - Avoids function calls on every loop cycle by emitting optimized bytecode for common iteration idioms.
- Inline Caches - Accelerates table and global lookups by storing the results of previous hash slot resolutions.
- Static Code Analyzers - Ships a static code analyzer for performing linting and type validation to detect bugs and stylistic inconsistencies.
- Bytecode Patching Debuggers - Features a specialized debugging system using bytecode patching to provide low-overhead breakpoints and stepping.
- Script Debugging Tools - Provides tools to inspect and control the state of running scripts to identify and fix runtime issues.
- Game Logic Scripting - Supports game logic development with specialized native vector math and efficient table management.
- Fixed-Size Memory Pool Managers - Uses a paged pool allocator to organize objects into fixed-size pages for better cache locality and faster reclamation.
- Table Capacity Preallocation - Reduces allocation overhead by creating tables with preallocated capacity or using object-like templates.
- Analysis-Phase Type Transformations - Modifies existing types or generates new ones during the analysis phase based on type-level inputs.
- Runtime Bytecode Instrumentation - Implements a debugging system that modifies live bytecode to enable breakpoints and stepping without execution overhead.
- Method Call Specialization - Minimizes interop costs by specializing method call sequences and using a namecall mechanism for reflected data.
- Adaptive Pacing Controllers - Schedules memory reclamation outside critical paths using a controller that estimates allocation rates.
- Inline Caching - Reduces the cost of accessing table members and global variables by predicting hash slots using inline caching.
- Type Narrowing - Narrows the type of a variable using truthiness tests and type guards to ensure safety within specific blocks.
- Explicit Variable Typing - Allows overriding inferred types with specific declarations to ensure precise validation and catch incompatible assignments.
- Paged Memory Reclamation - Implements a paged pool allocator that organizes objects into fixed-size pages to improve cache locality and reclamation speed.
- Lua - Ensures compatibility with Lua 5.1 by incorporating core features and standard libraries for consistent script execution.
- Scripting Runtimes - Provides a high-performance runtime optimized for low memory overhead and fast bytecode execution.
- Peephole Optimizers - Performs peephole optimizations and constant folding during compilation to simplify instruction sequences.
- Vector Mathematics - Provides native 3-component float types and SIMD-accelerated mathematical operations for high-performance vector math.
- Vector Operations - Provides native 3-component 32-bit float vector types for high-performance mathematical operations.
- Object Shape Validation - Determines table compatibility based on their structural shapes rather than explicit class definitions.
- Scripting and Bindings - Fast, safe, and gradually typed scripting language derived from Lua.
