NewYour coding agent can read the release notes before it upgrades.Set up the MCP server →
crates.io
crates.io, #4306 most downloaded on crates.io
Low level (FFI) bindings to Lua 5.5/5.4/5.3/5.2/5.1 (including LuaJIT) and Luau
Latest stable
0.13.0
Last release 1 months ago
03 Oct 2026
Ships fairly regularly
a new release about every 5 weeks
Most releases are documented
notes for 20 of 31 stable releases
Nothing withdrawn
no release was ever pulled
4 years old
32 releases · first in 2022
Drag across the ruler to compare, or tap a release to open it.
Nothing published for this version
Declaratively implement UserData with #[derive(UserData)] and register methods/fields with the new #[mlua::userdata_impl] attribute macro.
UserData with #[derive(UserData)] and register methods/fields with the new #[mlua::userdata_impl] attribute macro.UserDataOwned<T> wrapper takes ownership of userdata and implements FromLuaUserDataMethods::add_method_once/add_async_method_once__todebugstring metamethod for pretty-printing userdata when debuggingMaybeSync trait for userdata under the send featureTypes are now grouped into focused modules: chunk, debug, error, function, table, string, state, thread, userdata and luau.
Hook into coroutine create/resume/yield events across all Lua versions (when using mlua API).
Latest Luau with extended require-by-string support and JIT options.
Lua::gc_inc / Lua::gc_gen are replaced by a Lua::gc_set_mode, with GcIncParams/GcGenParams for fine-grained tuning.
ThreadStatus::Normal and Thread::is_normal (mimic coroutine.status)Lua::set_jit_options with support of Luau JIT inliner (Luau)Value::as_vector/Value::is_vector (Luau)Table::removeserde: tables with the array metatable are always encoded as arrays (incl. detect_mixed_tables option)Hash for BorrowedStr/BorrowedBytesLua::current_thread resolves implicit async threads to their root owner (#706)Full Changelog: https://github.com/mlua-rs/mlua/compare/v0.11.6...v0.12.0
Your coding agent can read these notes before it upgrades. Set up the MCP server →
Debug::curr_line is deprecated in favour of Debug::current_line that returns Option
external mlua-sys feature flagLua::inspect_stack takes a callback with &Debug argument, instead of returning Debug directlyDebug::function method to get function running at a given levelDebug::curr_line is deprecated in favour of Debug::current_line that returns Option<usize>Lua::set_globals method to replace global environmentTable::set_metatable now returns Result<()> (this operation can fail in sandboxed Luau mode)impl ToString replaced with Into<StdString> in UserData registrationValue::as_str and Value::as_string_lossy methods are deprecated (as they are non-idiomatic)Full Changelog: https://github.com/mlua-rs/mlua/compare/v0.11.0-beta.3...v0.11.0
Nothing published for this version
For full changelog see changes in [v0.10.0-beta.1], [v0.10.0-beta.2] and [v0.10.0-rc.1] versions.
For full changelog see changes in v0.10.0-beta.1, v0.10.0-beta.2 and v0.10.0-rc.1 versions.
Most notable changes since v0.9:
'lua lifetimeSend + Sync with send feature flagLua::exec_raw helper to execute low-level Lua C API codeLuaNativeFn/LuaNativeFnMut/LuaNativeAsyncFn traits for using in Function::wrapChanges since v0.10.0-rc.1
error-send feature flag (disabled by default) to require Send + Sync for ErrorThe v0.10 version of mlua has a goal to improve the user experience while keeping the same performance and safety guarantees. This document highlights the most notable features. For a full list of changes, see the CHANGELOG.
'static Lua typesIn previous mlua versions, it was required to have a 'lua lifetime attached to every Lua value. v0.9 introduced (experimental) owned types that are 'static without a lifetime attached, but they kept strong references to the Lua instance.
In v0.10 all Lua types are 'static and have only weak reference to the Lua instance. It means they are more flexible and can be used in more places without worrying about memory leaks.
send featureIn this version Lua is Send + Sync when the send feature flag is enabled (previously was only Send). It means Lua instance and their values can be safely shared between threads and used in multi threaded async contexts.
let lua = Lua::new();
lua.globals().set("i", 0)?;
let func = lua.load("i = i + ...").into_function()?;
std::thread::scope(|s| {
s.spawn(|| {
for i in 0..5 {
func.call::<()>(i).unwrap();
}
});
s.spawn(|| {
for i in 0..5 {
func.call::<()>(i).unwrap();
}
});
});
assert_eq!(lua.globals().get::<i32>("i")?, 20);
Under the hood, to synchronize access to the Lua state, mlua uses ReentrantMutex which can be recursively locked by a single thread. Only one thread can execute Lua code at a time, but it's possible to share Lua values between threads.
This has some performance penalties (about 10-20%) compared to the lock free mode. This flag is disabled by default and is not supported in module mode.
The new traits LuaNativeFn/LuaNativeFnMut/LuaNativeAsyncFn have been introduced to provide a way to register Rust functions with variable number of arguments in Lua, without needing to pass all arguments as a tuple.
They are used by Function::wrap/Function::wrap_mut/Function::wrap_async methods:
let add = Function::wrap(|a: i64, b: i64| Ok(a + b));
lua.globals().set("add", add).unwrap();
// Prints 50
lua.load(r#"print(add(5, 45))"#).exec().unwrap();
To wrap functions that return direct value (non-Result) you can use Function::wrap_raw method.
For Lua builtin types (like string, function, number, etc.) that have a shared metatable for all instances, it's now possible to set a custom metatable for them.
let mt = lua.create_table()?;
mt.set("__tostring", lua.create_function(|_, b: bool| Ok(if b { "2" } else { "0" }))?)?;
lua.set_type_metatable::<bool>(Some(mt));
lua.load("assert(tostring(true) == '2')").exec().unwrap();
ObjectLike traitThe ObjectLike trait is a combination of the AnyUserDataExt and TableExt traits used in previous versions. It provides a unified interface for working with Lua tables and userdata.
Either<L, R> enumThe Either<L, R> enum is a simple enum that can hold either L or R value. It's useful when you need to return or receive one of two types in a function.
This type implements IntoLua and FromLua traits and can generate a meaningful error message when conversion fails.
let func = Function::wrap(|x: Either<i32, String>| Ok(format!("received: {x}")));
lua.globals().set("func", func).unwrap();
// Prints: received: 123
lua.load(r#"print(func(123))"#).exec().unwrap();
// Prints: bad argument #1: error converting Lua table to Either<i32, String>
lua.load(r#"print(pcall(func, {}))"#).exec().unwrap();
Lua::exec_raw helper to execute low-level Lua C API codeFor advanced users, it's now possible to execute low-level Lua C API code using the Lua::exec_raw method.
let t = lua.create_sequence_from([1, 2, 3, 4, 5])?;
let sum: i64 = unsafe {
lua.exec_raw(&t, |state| {
// top of the stack: table `t`
let mut sum = 0;
// push nil as the first key
mlua::ffi::lua_pushnil(state);
while mlua::ffi::lua_next(state, -2) != 0 {
sum += mlua::ffi::lua_tointeger(state, -1);
// Remove the value, keep the key for the next iteration
mlua::ffi::lua_pop(state, 1);
}
mlua::ffi::lua_pop(state, 1);
mlua::ffi::lua_pushinteger(state, sum);
// top of the stack: sum
})
}?;
assert_eq!(sum, 15);
The exec_raw method is longjmp-safe. It's not recommended to move Drop types into the closure to avoid possible memory leaks.
anyhow feature flagThe new anyhow feature flag adds IntoLua and Into<mlua::Error> implementation for the anyhow::Error type.
let f = lua.create_function(|_, ()| {
Err(anyhow!("error message"))?;
Ok(())
})?;
The following Scope methods were changed:
Scope::create_any_userdataScope::create_nonstatic_userdata is renamed to Scope::create_userdataInstead, scope has comprehensive support for borrowed userdata: create_any_userdata_ref, create_any_userdata_ref_mut, create_userdata_ref, create_userdata_ref_mut.
UserDataRef and UserDataRefMut are no longer acceptable for scoped userdata access as they require owned underlying data.
In mlua v0.9 this could cause a read-after-free bug in some edge cases.
To temporarily borrow underlying data, the AnyUserData::borrow_scoped and AnyUserData::borrow_mut_scoped methods were introduced:
let data = "hello".to_string();
lua.scope(|scope| {
let ud = scope.create_any_userdata_ref(&data)?;
// We can only borrow scoped userdata using this method
ud.borrow_scoped::<String, ()>(|s| {
assert_eq!(s, "hello");
})?;
Ok(())
})?;
Those methods work for scoped and regular userdata objects (but still require T: 'static).
Since mlua::String holds a weak reference to Lua without any guarantees about the lifetime of the underlying data, getting a &str or &[u8] from it is no longer safe.
Lua instance can be destroyed while reference to the data is still alive:
let lua = Lua::new();
let s: mlua::String = lua.create_string("hello, world")?; // only weak reference to Lua!
let s_ref: &str = s.to_str()?; // this is not safe!
drop(lua);
println!("{s_ref}"); // use after free!
To solve this issue, return types of mlua::String::to_str and mlua::String::as_bytes methods changed to BorrowedStr and BorrowedBytes respectively.
These new types hold a strong reference to the Lua instance and can be safely converted to &str or &[u8]:
let lua = Lua::new();
let s: mlua::String = lua.create_string("hello, world")?;
let s_ref: mlua::BorrowedStr = s.to_str()?; // The strong reference to Lua is held here
drop(lua);
println!("{s_ref}"); // ok
The good news is that BorrowedStr implements Deref<Target = str>/AsRef<str> as well as Display, Debug, Eq, PartialEq and other traits for easy usage.
The same applies to BorrowedBytes.
Unfortunately, mlua::String::to_string_lossy cannot return Cow<'a, str> anymore, because it requires a strong reference to Lua. It now returns Rust String instead.
Improved non-static (scoped) userdata support
Changes since v0.9.0-rc.3
Scope::create_any_userdata() methodLua::set_vector_metatable() method (unstable feature flag)OwnedThread type (unstable feature flag)sort_keys to DeserializeOptions (Lua::from_value() method)Table::raw_len() output type to usizeValue (eg: Value::as_number()/Value::as_string/etc)The v0.9 version of mlua is a major release that includes a number of API changes and improvements. This release is a stepping stone towards the v1.0. This document highlights the most important changes. For a full list of changes, see the CHANGELOG.
This is a long awaited feature that allows to register in Lua foreign types that cannot implement UserData trait because of the Rust orphan rules.
Now you can register any type that implements Any trait as a userdata type.
Consider the following example:
lua.register_userdata_type::<std::string::String>(|reg| {
reg.add_method("len", |_, this, ()| Ok(this.len()));
reg.add_method_mut("push", |_, this, s: String| {
this.push_str(&s);
Ok(())
});
reg.add_meta_method(MetaMethod::ToString, |lua, this, ()| lua.create_string(this));
})?;
let s = lua.create_any_userdata("hello".to_string())?;
lua.load(chunk! {
print("s:len() is " .. $s:len())
$s:push(" world")
// Prints: hello, world
print($s)
})
.exec()?;
In this example we registered std::string::String as a userdata type with a set of methods and then created an instance of this type in Lua.
It's not required to register a type before using the Lua::create_any_userdata() method, instead an empty metatable will be created for you.
You can also register the same type multiple times with different methods. Any previously created instances will share the old metatable, while new instances will have the new one.
The new set of API is called any_userdata because it allows to register types that implements Any trait.
When you need to create non-static userdata instances in Lua, the usual way is use Lua::scope() helper to make them scoped. When out of scope, any scoped objects will be automatically
dropped. The only downside of this approach is that every new instance will have a new metatable. This is not very fast if you need to create a lot of instances.
With the new Any UserData API, you can place non-static references &T where T: 'static into a scope and they will share a single static metatable.
lua.register_userdata_type::<std::string::String>(|reg| {
reg.add_method_mut("replace", |_, this, (pat, to): (String, String)| {
*this = this.replace(&pat, &to);
Ok(())
});
reg.add_meta_method(MetaMethod::ToString, |lua, this, ()| lua.create_string(this));
})?;
let mut s = "hello, world".to_string();
lua.scope(|scope| {
// This userdata instance holds only a mutable reference to our string
let ud = scope.create_any_userdata_ref_mut(&mut s)?;
lua.load(chunk! {
$ud:replace("world", "user")
})
.exec()
})?;
// Prints: hello, user!
println!("{s}!");
unstable)One of the common questions was how to embed a Lua type into Rust struct to use it later. It was non-trivial to do because of the 'lua lifetime attached to every Lua value.
In v0.9 mlua introduces "owned" types OwnedTable/OwnedFunction/OwnedString/OwnedAnyUserData/ OwnedThreadthat are 'static (no lifetime attached).
let lua = Lua::new();
struct MyStruct {
table: OwnedTable,
func: OwnedFunction,
}
let my_struct = MyStruct {
table: lua.globals().into_owned(),
func: lua
.create_function(|_, t: Table| Ok(format!("{t:#?}")))?
.into_owned(),
};
// It's safe to drop Lua!
drop(lua);
let result = my_struct.func.call::<_, String>(my_struct.table)?;
println!("{result}");
Prior to v0.9, it was possible to do by creating a reference to the Lua value in registry using Lua::create_registry_value()
and retrieving value later using Lua::registry_value() method.
All owned handles hold a strong reference to the current Lua instance.
Be warned, if you place them into a Lua type (eg. UserData or a Rust callback), it is very easy
to accidentally cause reference cycles that would prevent destroying Lua instance.
Please note this functionality is available under the unstable feature flag and not available when the send feature is enabled.
In v0.9 release the internal ffi module has been moved into the new mlua-sys crate and became available for public use.
This crate provides unified Lua FFI API (targeting Lua 5.4) using a (limited) compatibility layer for older versions.
mlua re-exports the ffi module aliasing the mlua-sys crate and provides (unsafe) functionality to work with raw Lua state:
unsafe {
unsafe extern "C-unwind" fn lua_add(state: *mut mlua::lua_State) -> i32 {
let a = mlua::ffi::luaL_checkinteger(state, 1);
let b = mlua::ffi::luaL_checkinteger(state, 2);
mlua::ffi::lua_pushinteger(state, a + b);
1
}
let add = lua.create_c_function(lua_add)?;
assert_eq!(add.call::<_, i32>((2, 3))?, 5);
}
mlua brings support for the new Luau JIT backend under the luau-jit feature flag.
It will automatically trigger JIT compilation for new Lua chunks. To disable it, just call lua.enable_jit(false) before loading Lua code
(but any previously compiled chunks will remain JIT-compiled).
When calling a Rust function from Lua and passing wrong arguments, previous mlua versions reported an error message without any context or reference to the particular argument.
In v0.9 it reports an error message with the argument index and expected type:
let func = lua.create_function(|_, _a: i32| Ok(()))?;
lua.load(chunk! {
local ok, err = pcall($func, "not a number")
// Prints: bad argument #1: error converting Lua string to i32 (expected number or string coercible to number)
print(err)
})
.exec()?;
Similar changes have been made for userdata functions and methods:
lua.register_userdata_type::<&'static str>(|reg| {
reg.add_method("len", |_, this, ()| Ok(this.len()));
})?;
let s = lua.create_any_userdata("hello")?;
lua.load(chunk! {
local ok, err = pcall($s.len, 123)
// Prints: bad argument `self` to `&str.len`: error converting Lua integer to userdata
print(err)
})
.exec()?;
Similar to the anyhow Error type, now it's possible to attach context to Lua errors:
let read = lua.create_function(|lua, path: String| {
let bytes = std::fs::read(&path)
.into_lua_err()
.context(format!("Failed to open `{path}`"))?;
Ok(lua.create_string(bytes))
})?;
lua.load(chunk! {
local ok, err = pcall($read, "/nonexistent")
/// Prints:
/// Failed to open /nonexistent
/// No such file or directory (os error 2)
/// stack traceback:
/// ...
print(err)
})
.exec()?;
Function::wrap/AnyUserData::wrapSometimes it's useful to have IntoLua trait implementation for a Rust function or type T: Any without needing to call Lua::create_function()/Lua::create_any_userdata() methods.
Since v0.9 you can call the new methods Function::wrap()/AnyUserData::wrap() that allows to do this. They return an abstract type that impl IntoLua:
lua.globals().set("print_rust", Function::wrap(|_, s: String| Ok(println!("{}", s))))?;
lua.globals().set("rust_ud", AnyUserData::wrap("hello"))?;
In addition there are also Function::wrap_mut()/Function::wrap_async() methods that allow to wrap mutable and async functions respectively.
For a T: 'UserData + 'static the IntoLua trait is still always implemented.
UserDataRef and UserDataRefMut type wrappersThe new wrappers UserDataRef and UserDataRefMut are receivers for userdata type T and borrow underlying instance for the lifetime of the wrapper.
lua.globals()
.set("ud", AnyUserData::wrap("hello".to_string()))?;
let mut ud_mut: UserDataRefMut<String> = lua.globals().get("ud")?;
ud_mut.push_str(", Rust");
drop(ud_mut);
let ud_ref: UserDataRef<String> = lua.globals().get("ud")?;
// Prints: hello, Rust
println!("{}", *ud_ref);
In the previous mlua versions the same functionality can be achieved by receiving AnyUserData and calling AnyUserData::borrow()/AnyUserData::borrow_mut() methods.
The new wrappers are identical to Rust Ref/RefMut types.
AnyUserDataExt traitSimilar to the TableExt trait, the AnyUserDataExt provides a set of extra methods for the AnyUserData type.
AnyUserDataExt::get()/set() to get/set a value by key from the userdata, assuming it has __index metamethod.
AnyUserDataExt::call() to call the userdata as a function assuming it has __call metamethod.
AnyUserData::call_method(name, ...) to call the userdata method, assuming it has __index metamethod and the associated function.
mlua::Value implements a new format :#? that allows to (recursively) pretty print Lua values:
println!("{:#?}", lua.globals());
Prints:
{
["_G"] = table: 0x7fa2d0706260,
["_VERSION"] = "Lua 5.4",
["assert"] = function: 0x10451d11d,
["collectgarbage"] = function: 0x10451d198,
["coroutine"] = {
["close"] = function: 0x10451e28f,
...
},
["dofile"] = function: 0x10451d37c,
...
}
In addition a new method Value::to_string() has been added to convert Value to a string (using __tostring metamethod if available).
Any Lua functions have an associated environment table that is used to resolve global variables. By default it sets to a Lua globals table.
In the new release it's possible to get or update a function environment using Function::environment() or Function::set_environment() methods respectively.
let f = lua.load("return a").into_function()?;
assert_eq!(f.environment(), Some(lua.globals()));
lua.globals().set("a", 1)?;
assert_eq!(f.call::<_, i32>(())?, 1);
f.set_environment(lua.create_table_from([("a", "hello")])?)?;
assert_eq!(f.call::<_, mlua::String>(())?, "hello");
The new mlua version has a number of performance improvements. Please check the benchmarks results to see how mlua compares to rlua and rhai.
module modeThe lua_module macro now support the following attributes:
name=... - sets name of the module (defaults to the name of the function).Eg.:
#[mlua::lua_module(name = "alt_module")]
fn my_module(lua: &Lua) -> LuaResult<LuaTable> {
lua.create_table()
}
Under the hood a new function luaopen_alt_module will be created for the Lua module loader.
skip_memory_check - skip memory allocation checks for some operations.In module mode, mlua runs in an unknown environment and cannot tell whether there are any memory limits or not. As a result, some operations that require memory allocation run in protected mode. Setting this attribute will improve performance of such operations with risk of having uncaught exceptions and memory leaks.
In previous mlua versions, building a Lua module for Windows requires having Lua development libraries installed on the system.
In contrast, on Linux and macOS, modules can be built without any external dependencies using the -undefined=dynamic_lookup linker flag.
With Rust 1.71+ it's now possible to lift this restriction for Windows as well. You can build modules normally and they will be linked with
lua5x.dll depending on the enabled Lua version.
You still need to have the dll although, linked to application where the module will be loaded.
ToLua/ToLuaMulti traits have been renamed to IntoLua/IntoLuaMulti respectively (with the methods called into_lua/into_lua_multi).The main reason for this change is following the Rust self convention.
FromLua implementation for T: UserData + Clone.During the usage of mlua, it was found that this implementation is not very useful and prevents custom FromLua implementations for T: UserData.
It should be a developer decision to opt-in FromLua for their T if needed rather than having enabled it unconditionally.
To opt-in FromLua for T: Clone you can use a simple #[derive(FromLua)] macro (requires feature = "macros"):
#[derive(Clone, Copy, mlua::FromLua)]
struct MyUserData(i32);
T is not required to implement UserData because of the new relaxed restrictions on userdata types.
Close to-be-closed variables for Lua 5.4 when using call_async functions
Performance optimizations in handling UserData
Function::bind when passing empty binds and no arguments (#189)Added Lua::create_proxy for accessing to UserData static fields and functions without instance
Lua::create_proxy for accessing to UserData static fields and functions without instanceTable::to_pointer() and String::to_pointer() functionsAdded async support to __index and __newindex metamethods
Changes since 0.7.4
__index and __newindex metamethodsFunction::info() to get information about functions (#149).parking_lot dependency under feature flag (for UserData)Hash implementation for Lua StringValue::to_pointer() functionBreaking changes:
AsChunk trait (added implementation for Path and PathBuf).New "application data" api to store arbitrary objects inside Lua
luajit52 to build/support LuaJIT with partial compatibility with Lua 5.2AnyUserData::take() to take UserData objects from Luaset_nth_user_value/get_nth_user_value to AnyUserData for all Lua versionsset_named_user_value/get_named_user_value to AnyUserData for all Lua versionsLua::inspect_stack() to get information about the interpreter runtime stackset_warning_function/remove_warning_function/warning functions to Lua for 5.4TableExt::call() to call tables with __call metamethod as functionsLua::unload() to unload modulesToLua implementation for arrays changed to const genericsserde::Serialize for Lua Tablesfmt::Display implementation for Error::CallbackErrorNothing published for this version
Nothing published for this version
Fixed calculating LUA_REGISTRYINDEX when cross-compiling for lua51/jit
LUA_REGISTRYINDEX when cross-compiling for lua51/jit (#82)Fixed bug when polling async futures
Location::caller() information to Lua::load() if chunk's name is None (Rust 1.46+)Fixed table traversal used in recursion detection in deserializer
Disabled catching Rust panics in userdata finalizers on drop. It also has positive performance impact.
Debug::event() to the hook's Debug structurehook::HookTriggersExtraData in module mode. This helps avoiding memory leak on closing state when Lua unloads modules and frees memory.DeserializeOptions struct to control deserializer behavior (from_value_with function).New functionality: Lua::load_from_function() and Lua::create_c_function()
Lua::load_from_function() and Lua::create_c_function()Update chunk! documentation (stable Rust limitations)
chunk! documentation (stable Rust limitations)once_cell dependency lowered to 1.0Full access to UserData metatables with support of setting arbitrary fields.
Changes since 0.5.4
UserDataFields APIUserData metatables with support of setting arbitrary fields.UserData for Rc<RefCell<T>>/Arc<Mutex<T>>/Arc<RwLock<T>> where T: UserData.SerializeOptions to to change default Lua serializer behaviour (eg. nil/null/array serialization)LuaOptions to customize Lua/Rust behaviour (currently panic handling)ToLua/FromLua implementation for Box<str> and Box<[T]>.Thread::reset() for luajit/lua54 to recycle threads (coroutines) with attaching a new function.chunk! macro support to load chunks of Lua code using the Rust tokenizer and optionally capturing Rust variables.Error's __tostring method formats full stacktraces). This is useful in a module mode.String::to_string_lossyBreaking changes:
Send + Sync to be compatible with the anyhow crate.Result from LuaSerdeExt::null() and LuaSerdeExt::array_metatable() (never fails)Result from Function::dump() (never fails)AnyUserData::has_metamethod() (in favour of full access to metatables)Some performance optimisations (callbacks)
ToLua implementation for Cow<str> and Cow<CStr>Scope destruction of partially polled futuresSupport cross compilation that should work well for vendored builds (including LuaJIT with some restrictions)
Serde support under serialize feature flag.
serialize feature flag.mlua_derive.ToLua and FromLua for HashSet and BTreeSetRemoved deprecated Table::call() function.
MetaMethod::Close.lua53 feature is disabled by default. Now preferred Lua version have to be chosen explicitly.require or package.loadlib) are disabled. Equivalent to the previous Lua::new() function is Lua::unsafe_new().send feature to require Send.module feature, that disables linking to Lua Core Libraries. Required for modules.'callback outlive 'lua in Lua::create_function() to fix the unsoundness.Lua::into_static() to make 'static Lua state. This is useful to spawn async Lua threads that requires 'static.Lua::set_memory_limit() (similar to rlua) to enable memory restrictions in Lua VM (requires Lua >= 5.2).Scope, temporary removed in v0.3, is back with async support.Table::call() function.AnyUserData::has_metamethod() function.Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
Nothing published for this version
One column per quarter.