yuin/gopher-lua
Gopher Lua
Gopher-lua is a complete implementation of the Lua language and its standard libraries written natively in Go. It serves as an embedded scripting engine and virtual machine that allows Go applications to execute Lua scripts and exchange data between the host and the script environment.
The project provides a bytecode compiler to transform source code into a binary format for faster execution. It enables deep integration between the two languages by allowing the registration of native Go functions to be called from scripts, and the invocation of script functions directly from Go.
The engine covers a wide range of capabilities including cooperative multitasking through coroutines, memory limit management for sandboxed execution, and the ability to extend the environment with custom types via metatables. It also supports asynchronous communication by integrating script execution with Go channels and providing context-driven execution termination for timeout or lifecycle management.
Features
- Embedded Script Execution - Provides a complete Lua virtual machine and compiler to execute scripts within a Go application.
- Embedded Scripting Engines - Provides a complete engine for integrating the Lua scripting language into Go applications for dynamic logic.
- Function Calling Interfaces - Provides an interface for Lua scripts to trigger and execute native Go functions.
- Script-to-Native Type Mappings - Translates Lua data types such as strings and numbers into their native Go equivalents.
- VM Runtime Environments - Manages the execution environment lifecycle by configuring memory limits and initializing core system libraries.
- Host-Language Channel Integration - Enables asynchronous communication and selection operations between Lua scripts and Go routines using shared channels.
- Associative Arrays - Implements Lua tables for manipulating data using both indexed arrays and keyed dictionaries.
- Bytecode Compilation - Includes a compiler that transforms Lua source code into binary bytecode for faster virtual machine execution.
- Bytecode Virtual Machines - Implements a custom virtual machine that executes Lua bytecode for high-performance script evaluation.
- Host Function Exposure - Allows registering native Go functions as callable global variables within the Lua environment.
- Module and Package Management - Supports packaging functions and variables into modules that can be dynamically loaded using the require statement.
- Native-to-Script Invocations - Allows the host Go application to call functions defined inside a Lua script with specific parameters.
- Lua - Provides a complete native implementation of the Lua language and its standard libraries in Go.
- Virtual Machines - Implements a virtual machine and compiler for executing Lua scripts and exchanging data with Go.
- Source Code Compilers - Includes a compiler that transforms Lua source code into bytecode for faster virtual machine execution.
- Modular Plugin Systems - Enables building modular architectures where external Lua scripts extend the core functionality of a Go program.
- Virtual Machine - Uses a virtual stack to push, replace, or remove values for data exchange between Go and Lua.
- VM Stack Value Passing - Implements a shared stack for pushing and popping values to exchange data between Go and the Lua VM.
- Game Logic Scripting - Enables the execution of custom interactive behaviors and logic via an embedded Lua engine.
- Command-Line Interpreters - Includes a standalone interpreter that allows executing Lua scripts directly from the command line.
- Runtime Memory Limits - Restricts the maximum amount of memory the virtual machine can use to prevent system resource exhaustion.
- Configuration Scripting - Allows replacing static configuration files with Lua scripts for complex runtime calculations and conditional logic.
- Script-Channel Integration - Links Lua script execution with Go channels to enable asynchronous data exchange between different execution states.
- Multi-threaded Execution - Implements cooperative multitasking via coroutines to pause and resume execution threads.
- Channel-Based Concurrency - Implements channel-based concurrency to facilitate safe data exchange and synchronization between concurrent processes.
- Coroutines - Supports lightweight cooperative multitasking through coroutines that can be paused and resumed.
- Built-ins - Provides control over which standard libraries are loaded into the state to restrict system access.
- Metatable-Based Type Extensions - Enables the definition of custom data types and behaviors by attaching metatables to base objects.
- Script Module Resolution - Imports Lua scripts from the filesystem using configurable search paths to extend script functionality.
- Sandboxed Code Execution Environments - Supports running untrusted scripts in a controlled environment with restricted memory and limited system access.
- Standard Library Implementations - Provides a complete set of standard Lua libraries for common tasks like math and string manipulation.
- User-Defined Types - Enables the definition of custom data types and behaviors using user-defined data and metatables.
- Message Passing Channels - Implements synchronized communication primitives for exchanging data between concurrent script states.
- Bytecode Caching - Caches compiled Lua scripts in binary bytecode format to reduce initialization time and memory overhead.
- Context-Aware Cancellation - Provides mechanisms to terminate running Lua scripts using Go context signals for timeout and lifecycle management.
- VM Interrupt Terminations - Allows stopping a running VM state using contexts to manage timeouts or manual cancellation.
- Compilers and Interpreters - Lua virtual machine and compiler.
- Embedded Scripting - Lua 5.1 virtual machine and compiler.
- Language Implementations - Virtual machine and compiler implemented in Go.
- Language Runtimes - Lua 5.1 virtual machine and compiler for Go.
- Scripting Languages - Lua 5.1 VM and compiler written in Go.
