v0.8.0-beta.2

Update docs
Enable Thread::reset for Luau
2026-06-08 16:05:43 +00:00 · 2022-03-25 00:44:02 +00:00 · 2022-03-25 00:43:54 +00:00 · 2022-03-23 21:13:48 +00:00 · 2022-03-23 01:25:34 +00:00 · 2022-03-23 01:24:54 +00:00
86 changed files with 9459 additions and 4619 deletions
@@ -0,0 +1 @@
+github: khvzak
@@ -14,7 +14,7 @@ jobs:

      - name: Generate code coverage
        run: |
-          cargo tarpaulin --verbose --features lua53,vendored,async,send,serialize,macros --out xml --exclude-files benches --exclude-files build --exclude-files mlua_derive --exclude-files src/ffi --exclude-files tests
+          cargo tarpaulin --verbose --features lua54,vendored,async,send,serialize,macros --out xml --exclude-files benches --exclude-files build --exclude-files mlua_derive --exclude-files src/ffi --exclude-files tests

      - name: Upload to codecov.io
        uses: codecov/codecov-action@v1
@@ -7,11 +7,11 @@ jobs:
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
-        os: [ubuntu-18.04, macos-latest, windows-latest]
+        os: [ubuntu-20.04, macos-latest, windows-latest]
        rust: [stable]
-        lua: [lua54, lua53, lua52, lua51, luajit]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau]
        include:
-        - os: ubuntu-18.04
+        - os: ubuntu-20.04
          target: x86_64-unknown-linux-gnu
        - os: macos-latest
          target: x86_64-apple-darwin
@@ -31,7 +31,7 @@ jobs:
        cargo build --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
      shell: bash
    - name: Build ${{ matrix.lua }} pkg-config
-      if: ${{ matrix.os == 'ubuntu-18.04' && matrix.lua != 'lua54' }}
+      if: ${{ matrix.os == 'ubuntu-20.04' && matrix.lua != 'lua54' }}
      run: |
        sudo apt-get update
        sudo apt-get install -y --no-install-recommends liblua5.3-dev liblua5.2-dev liblua5.1-0-dev libluajit-5.1-dev
@@ -56,7 +56,7 @@ jobs:

  build_aarch64_cross_ubuntu:
    name: Cross-compile to aarch64-unknown-linux-gnu
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
    needs: build
    strategy:
      matrix:
@@ -79,7 +79,7 @@ jobs:

  build_armv7_cross_ubuntu:
    name: Cross-compile to armv7-unknown-linux-gnueabihf
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
    needs: build
    strategy:
      matrix:
@@ -106,11 +106,11 @@ jobs:
    needs: build
    strategy:
      matrix:
-        os: [ubuntu-18.04, macos-latest, windows-latest]
+        os: [ubuntu-20.04, macos-latest, windows-latest]
        rust: [stable, nightly]
-        lua: [lua54, lua53, lua52, lua51, luajit]
+        lua: [lua54, lua53, lua52, lua51, luajit, luajit52, luau]
        include:
-        - os: ubuntu-18.04
+        - os: ubuntu-20.04
          target: x86_64-unknown-linux-gnu
        - os: macos-latest
          target: x86_64-apple-darwin
@@ -129,8 +129,8 @@ jobs:
        cargo test --features "${{ matrix.lua }},vendored"
        cargo test --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
      shell: bash
-    - name: Run compile tests (macos lua53)
-      if: ${{ matrix.os == 'macos-latest' && matrix.lua == 'lua53' }}
+    - name: Run compile tests (macos lua54)
+      if: ${{ matrix.os == 'macos-latest' && matrix.lua == 'lua54' }}
      run: |
        TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored" -- --ignored
        TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored,async,send,serialize,macros" -- --ignored
@@ -142,11 +142,11 @@ jobs:
    needs: build
    strategy:
      matrix:
-        os: [ubuntu-18.04]
+        os: [ubuntu-20.04]
        rust: [nightly]
-        lua: [lua54, lua53, lua52, lua51, luajit]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau]
        include:
-        - os: ubuntu-18.04
+        - os: ubuntu-20.04
          target: x86_64-unknown-linux-gnu
    steps:
    - uses: actions/checkout@v2
@@ -168,11 +168,11 @@ jobs:
    needs: build
    strategy:
      matrix:
-        os: [ubuntu-18.04, macos-latest]
+        os: [ubuntu-20.04, macos-latest]
        rust: [stable]
        lua: [lua54, lua53, lua52, lua51, luajit]
        include:
-        - os: ubuntu-18.04
+        - os: ubuntu-20.04
          target: x86_64-unknown-linux-gnu
        - os: macos-latest
          target: x86_64-apple-darwin
@@ -213,7 +213,7 @@ jobs:

  rustfmt:
    name: Rustfmt
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
    steps:
    - uses: actions/checkout@v2
    - uses: actions-rs/toolchain@v1
@@ -225,10 +225,10 @@ jobs:

  clippy:
    name: Clippy check
-    runs-on: ubuntu-18.04
+    runs-on: ubuntu-20.04
    strategy:
      matrix:
-        lua: [lua54, lua53, lua52, lua51, luajit]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau]
    steps:
      - uses: actions/checkout@v2
      - uses: actions-rs/toolchain@v1
@@ -1,3 +1,80 @@
+## v0.8.0-beta.2
+
+- Luau vector datatype support
+- Luau readonly table attribute
+- Other Luau improvements
+
+## v0.8.0-beta.1
+
+- Roblox Luau support
+- Refactored ffi module. C glue is no longer required
+- Added async support to `__index` and `__newindex` metamethods
+
+## v0.7.4
+
+- Improved `Lua::create_registry_value` to reuse previously expired registry keys.
+  No need to call `Lua::expire_registry_values` when creating/dropping registry values.
+- Added `Lua::replace_registry_value` to change value of an existing Registry Key
+- Async calls optimization
+
+## v0.7.3
+
+- Fixed cross-compilation issue (introduced in 84a174c)
+
+## v0.7.2
+
+- Allow `pkg-config` to omit include paths if they equals to standard (#114).
+- Various bugfixes (eg. #121)
+
+## v0.7.1
+
+- Fixed traceback generation for errors (#112)
+- `Lua::into_static/from_static` methods have been removed from the docs and are discouraged for use
+
+## v0.7.0
+
+- New "application data" api to store arbitrary objects inside Lua
+- New feature flag `luajit52` to build/support LuaJIT with partial compatibility with Lua 5.2
+- Added async meta methods for all Lua (except 5.1)
+- Added `AnyUserData::take()` to take UserData objects from Lua
+- Added `set_nth_user_value`/`get_nth_user_value` to `AnyUserData` for all Lua versions
+- Added `set_named_user_value`/`get_named_user_value` to `AnyUserData` for all Lua versions
+- Added `Lua::inspect_stack()` to get information about the interpreter runtime stack
+- Added `set_warning_function`/`remove_warning_function`/`warning` functions to `Lua` for 5.4
+- Added `TableExt::call()` to call tables with `__call` metamethod as functions
+- Added `Lua::unload()` to unload modules
+- `ToLua` implementation for arrays changed to const generics
+- Added thread (coroutine) cache for async execution (disabled by default and works for Lua 5.4/JIT)
+- LuaOptions and (De)SerializeOptions marked as const
+- Fixed recursive tables serialization when using `serde::Serialize` for Lua Tables
+- Improved errors reporting. Now source included to `fmt::Display` implementation for `Error::CallbackError`
+- Major performance improvements
+
+## v0.6.6
+
+- Fixed calculating `LUA_REGISTRYINDEX` when cross-compiling for lua51/jit (#82)
+- Updated documentation & examples
+
+## v0.6.5
+
+- Fixed bug when polling async futures (#77)
+- Refactor Waker handling in async code (+10% performance gain when calling async functions)
+- Added `Location::caller()` information to `Lua::load()` if chunk's name is None (Rust 1.46+)
+- Added serialization of i128/u128 types (serde)
+
+## v0.6.4
+
+- Performance optimizations
+- Fixed table traversal used in recursion detection in deserializer
+
+## v0.6.3
+
+- Disabled catching Rust panics in userdata finalizers on drop. It also has positive performance impact.
+- Added `Debug::event()` to the hook's Debug structure
+- Simplified interface of `hook::HookTriggers`
+- Added finalizer to `ExtraData` in module mode. This helps avoiding memory leak on closing state when Lua unloads modules and frees memory.
+- Added `DeserializeOptions` struct to control deserializer behavior (`from_value_with` function).
+
 ## v0.6.2

 - New functionality: `Lua::load_from_function()` and `Lua::create_c_function()`
@@ -1,6 +1,6 @@
 [package]
 name = "mlua"
-version = "0.6.2" # remember to update html_root_url and mlua_derive
+version = "0.8.0-beta.2" # remember to update html_root_url and mlua_derive
 authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@chucklefish.org>"]
 edition = "2018"
 repository = "https://github.com/khvzak/mlua"
@@ -12,12 +12,12 @@ license = "MIT"
 links = "lua"
 build = "build/main.rs"
 description = """
-High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT)
-with async/await features and support of writing native lua modules in Rust.
+High level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau
+with async/await features and support of writing native Lua modules in Rust.
 """

 [package.metadata.docs.rs]
-features = ["lua53", "async", "send", "serialize", "macros"]
+features = ["lua54", "vendored", "async", "send", "serialize", "macros"]
 rustdoc-args = ["--cfg", "docsrs"]

 [workspace]
@@ -33,6 +33,8 @@ lua53 = []
 lua52 = []
 lua51 = []
 luajit = []
+luajit52 = ["luajit"]
+luau = ["luau0-src"]
 vendored = ["lua-src", "luajit-src"]
 module = ["mlua_derive"]
 async = ["futures-core", "futures-task", "futures-util"]
@@ -45,6 +47,7 @@ mlua_derive = { version = "=0.6.0", optional = true, path = "mlua_derive" }
 bstr = { version = "0.2", features = ["std"], default_features = false }
 once_cell = { version = "1.0" }
 num-traits = { version = "0.2.14" }
+rustc-hash = "1.0"
 futures-core = { version = "0.3.5", optional = true }
 futures-task = { version = "0.3.5", optional = true }
 futures-util = { version = "0.3.5", optional = true }
@@ -55,10 +58,11 @@ erased-serde = { version = "0.3", optional = true }
 cc = { version = "1.0" }
 pkg-config = { version = "0.3.17" }
 lua-src = { version = ">= 540.0.0, < 550.0.0", optional = true }
-luajit-src = { version = ">= 210.1.2, < 220.0.0", optional = true }
+luajit-src = { version = ">= 210.3.1, < 220.0.0", optional = true }
+luau0-src = { version = "0.2.1", optional = true }

 [dev-dependencies]
-rustyline = "8.0"
+rustyline = "9.0"
 criterion = { version = "0.3.4", features = ["html_reports", "async_tokio"] }
 trybuild = "1.0"
 futures = "0.3.5"
@@ -68,6 +72,7 @@ tokio = { version = "1.0", features = ["full"] }
 futures-timer = "3.0"
 serde_json = "1.0"
 maplit = "1.0"
+tempfile = "3"

 [[bench]]
 name = "benchmark"
@@ -84,7 +89,7 @@ required-features = ["async", "serialize", "macros"]

 [[example]]
 name = "async_http_server"
-required-features = ["async", "send"]
+required-features = ["async", "macros"]

 [[example]]
 name = "async_tcp_server"
@@ -1,5 +1,5 @@
 # mlua
-[![Build Status]][github-actions] [![Latest Version]][crates.io] [![API Documentation]][docs.rs] [![Coverage Status]][codecov.io]
+[![Build Status]][github-actions] [![Latest Version]][crates.io] [![API Documentation]][docs.rs] [![Coverage Status]][codecov.io] ![MSRV]

 [Build Status]: https://github.com/khvzak/mlua/workflows/CI/badge.svg
 [github-actions]: https://github.com/khvzak/mlua/actions
@@ -9,17 +9,19 @@
 [docs.rs]: https://docs.rs/mlua
 [Coverage Status]: https://codecov.io/gh/khvzak/mlua/branch/master/graph/badge.svg?token=99339FS1CG
 [codecov.io]: https://codecov.io/gh/khvzak/mlua
+[MSRV]: https://img.shields.io/badge/rust-1.53+-brightgreen.svg?&logo=rust

 [Guided Tour](examples/guided_tour.rs)

 `mlua` is bindings to [Lua](https://www.lua.org) programming language for Rust with a goal to provide
 _safe_ (as far as it's possible), high level, easy to use, practical and flexible API.

-Started as [rlua](https://github.com/amethyst/rlua/tree/0.15.3) fork, `mlua` supports Lua 5.4, 5.3, 5.2 and 5.1 including LuaJIT (2.0.5 and 2.1 beta) and allows to write native Lua modules in Rust as well as use Lua in a standalone mode.
+Started as `rlua` fork, `mlua` supports Lua 5.4, 5.3, 5.2, 5.1 (including LuaJIT) and [Roblox Luau] and allows to write native Lua modules in Rust as well as use Lua in a standalone mode.

 `mlua` tested on Windows/macOS/Linux including module mode in [GitHub Actions] on `x86_64` platform and cross-compilation to `aarch64` (other targets are also supported).

 [GitHub Actions]: https://github.com/khvzak/mlua/actions
+[Roblox Luau]: https://luau-lang.org

 ## Usage

@@ -33,6 +35,8 @@ Below is a list of the available feature flags. By default `mlua` does not enabl
 * `lua52`: activate Lua [5.2] support
 * `lua51`: activate Lua [5.1] support
 * `luajit`: activate [LuaJIT] support
+* `luajit52`: activate [LuaJIT] support with partial compatibility with Lua 5.2
+* `luau`: activate [Luau] support (auto vendored mode)
 * `vendored`: build static Lua(JIT) library from sources during `mlua` compilation using [lua-src] or [luajit-src] crates
 * `module`: enable module mode (building loadable `cdylib` library for Lua)
 * `async`: enable async/await support (any executor can be used, eg. [tokio] or [async-std])
@@ -45,6 +49,7 @@ Below is a list of the available feature flags. By default `mlua` does not enabl
 [5.2]: https://www.lua.org/manual/5.2/manual.html
 [5.1]: https://www.lua.org/manual/5.1/manual.html
 [LuaJIT]: https://luajit.org/
+[Luau]: https://github.com/Roblox/luau
 [lua-src]: https://github.com/khvzak/lua-src-rs
 [luajit-src]: https://github.com/khvzak/luajit-src-rs
 [tokio]: https://github.com/tokio-rs/tokio
@@ -54,7 +59,9 @@ Below is a list of the available feature flags. By default `mlua` does not enabl

 ### Async/await support

-`mlua` supports async/await for all Lua versions. This works using Lua [coroutines](https://www.lua.org/manual/5.3/manual.html#2.6) and require running [Thread](https://docs.rs/mlua/latest/mlua/struct.Thread.html) along with enabling `feature = "async"` in `Cargo.toml`.
+`mlua` supports async/await for all Lua versions including Luau.
+
+This works using Lua [coroutines](https://www.lua.org/manual/5.3/manual.html#2.6) and require running [Thread](https://docs.rs/mlua/latest/mlua/struct.Thread.html) along with enabling `feature = "async"` in `Cargo.toml`.

 **Examples**:
 - [HTTP Client](examples/async_http_client.rs)
@@ -74,7 +81,7 @@ With `serialize` feature flag enabled, `mlua` allows you to serialize/deserializ

 ### Compiling

-You have to enable one of the features `lua54`, `lua53`, `lua52`, `lua51` or `luajit`, according to the chosen Lua version.
+You have to enable one of the features: `lua54`, `lua53`, `lua52`, `lua51`, `luajit(52)` or `luau`, according to the chosen Lua version.

 By default `mlua` uses `pkg-config` tool to find lua includes and libraries for the chosen Lua version.
 In most cases it works as desired, although sometimes could be more preferable to use a custom lua library.
@@ -97,7 +104,7 @@ Add to `Cargo.toml` :

 ``` toml
 [dependencies]
-mlua = { version = "0.6", features = ["lua53", "vendored"] }
+mlua = { version = "0.8.0-beta.2", features = ["lua54", "vendored"] }
 ```

 `main.rs`
@@ -121,7 +128,7 @@ fn main() -> LuaResult<()> {
 ```

 ### Module mode
-In a module mode `mlua` allows to create a compiled Lua module that can be loaded from Lua code using [`require`](https://www.lua.org/manual/5.3/manual.html#pdf-require). In this case `mlua` uses an external Lua runtime which could lead to potential unsafety due to unpredictability of the Lua environment and usage of libraries such as [`debug`](https://www.lua.org/manual/5.3/manual.html#6.10).
+In a module mode `mlua` allows to create a compiled Lua module that can be loaded from Lua code using [`require`](https://www.lua.org/manual/5.4/manual.html#pdf-require). In this case `mlua` uses an external Lua runtime which could lead to potential unsafety due to unpredictability of the Lua environment and usage of libraries such as [`debug`](https://www.lua.org/manual/5.4/manual.html#6.10).

 [Example](examples/module)

@@ -132,7 +139,7 @@ Add to `Cargo.toml` :
 crate-type = ["cdylib"]

 [dependencies]
-mlua = { version = "0.6", features = ["lua53", "vendored", "module"] }
+mlua = { version = "0.8.0-beta.2", features = ["lua54", "vendored", "module"] }
 ```

 `lib.rs` :
@@ -158,7 +165,7 @@ And then (**macOS** example):
 ``` sh
 $ cargo rustc -- -C link-arg=-undefined -C link-arg=dynamic_lookup
 $ ln -s ./target/debug/libmy_module.dylib ./my_module.so
-$ lua5.3 -e 'require("my_module").hello("world")'
+$ lua5.4 -e 'require("my_module").hello("world")'
 hello, world!
 ```

@@ -120,7 +120,8 @@ fn call_sum_callback(c: &mut Criterion) {
 }

 fn call_async_sum_callback(c: &mut Criterion) {
-    let lua = Lua::new();
+    let options = LuaOptions::new().thread_cache_size(1024);
+    let lua = Lua::new_with(LuaStdLib::ALL_SAFE, options).unwrap();
    let callback = lua
        .create_async_function(|_, (a, b, c): (i64, i64, i64)| async move {
            task::yield_now().await;
@@ -208,6 +209,33 @@ fn create_userdata(c: &mut Criterion) {
    });
 }

+fn call_userdata_index(c: &mut Criterion) {
+    struct UserData(i64);
+    impl LuaUserData for UserData {
+        fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
+            methods.add_meta_method(LuaMetaMethod::Index, move |_, _, index: String| Ok(index));
+        }
+    }
+
+    let lua = Lua::new();
+    lua.globals().set("userdata", UserData(10)).unwrap();
+
+    c.bench_function("call [userdata index] 10", |b| {
+        b.iter_batched_ref(
+            || {
+                collect_gc_twice(&lua);
+                lua.load("function() for i = 1,10 do local v = userdata.test end end")
+                    .eval::<LuaFunction>()
+                    .unwrap()
+            },
+            |function| {
+                function.call::<_, ()>(()).unwrap();
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
 fn call_userdata_method(c: &mut Criterion) {
    struct UserData(i64);
    impl LuaUserData for UserData {
@@ -244,7 +272,8 @@ fn call_async_userdata_method(c: &mut Criterion) {
        }
    }

-    let lua = Lua::new();
+    let options = LuaOptions::new().thread_cache_size(1024);
+    let lua = Lua::new_with(LuaStdLib::ALL_SAFE, options).unwrap();
    lua.globals().set("userdata", UserData(10)).unwrap();

    c.bench_function("call async [userdata method] 10", |b| {
@@ -281,6 +310,7 @@ criterion_group! {
        call_concat_callback,
        create_registry_values,
        create_userdata,
+        call_userdata_index,
        call_userdata_method,
        call_async_userdata_method,
 }
@@ -1,5 +1,5 @@
 use std::path::PathBuf;

-pub fn probe_lua() -> PathBuf {
+pub fn probe_lua() -> Option<PathBuf> {
    unreachable!()
 }
@@ -10,7 +10,7 @@ fn get_env_var(name: &str) -> String {
    }
 }

-pub fn probe_lua() -> PathBuf {
+pub fn probe_lua() -> Option<PathBuf> {
    let include_dir = get_env_var("LUA_INC");
    let lib_dir = get_env_var("LUA_LIB");
    let lua_lib = get_env_var("LUA_LIB_NAME");
@@ -38,73 +38,42 @@ pub fn probe_lua() -> PathBuf {
            println!("cargo:rustc-link-search=native={}", lib_dir);
            println!("cargo:rustc-link-lib={}{}", link_lib, lua_lib);
        }
-        return PathBuf::from(include_dir);
+        return Some(PathBuf::from(include_dir));
    }

    // Find using `pkg-config`

    #[cfg(feature = "lua54")]
-    {
-        let mut lua = pkg_config::Config::new()
-            .range_version((Bound::Included("5.4"), Bound::Excluded("5.5")))
-            .cargo_metadata(need_lua_lib)
-            .probe("lua");
-
-        if lua.is_err() {
-            lua = pkg_config::Config::new()
-                .cargo_metadata(need_lua_lib)
-                .probe("lua5.4");
-        }
-
-        lua.unwrap().include_paths[0].clone()
-    }
-
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.4", "5.5", "lua5.4", "5.4");
    #[cfg(feature = "lua53")]
-    {
-        let mut lua = pkg_config::Config::new()
-            .range_version((Bound::Included("5.3"), Bound::Excluded("5.4")))
-            .cargo_metadata(need_lua_lib)
-            .probe("lua");
-
-        if lua.is_err() {
-            lua = pkg_config::Config::new()
-                .cargo_metadata(need_lua_lib)
-                .probe("lua5.3");
-        }
-
-        lua.unwrap().include_paths[0].clone()
-    }
-
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.3", "5.4", "lua5.3", "5.3");
    #[cfg(feature = "lua52")]
-    {
-        let mut lua = pkg_config::Config::new()
-            .range_version((Bound::Included("5.2"), Bound::Excluded("5.3")))
-            .cargo_metadata(need_lua_lib)
-            .probe("lua");
-
-        if lua.is_err() {
-            lua = pkg_config::Config::new()
-                .cargo_metadata(need_lua_lib)
-                .probe("lua5.2");
-        }
-
-        lua.unwrap().include_paths[0].clone()
-    }
-
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.2", "5.3", "lua5.2", "5.2");
    #[cfg(feature = "lua51")]
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.1", "5.2", "lua5.1", "5.1");
+
+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "lua51"
+    ))]
    {
        let mut lua = pkg_config::Config::new()
-            .range_version((Bound::Included("5.1"), Bound::Excluded("5.2")))
+            .range_version((Bound::Included(incl_bound), Bound::Excluded(excl_bound)))
            .cargo_metadata(need_lua_lib)
            .probe("lua");

        if lua.is_err() {
            lua = pkg_config::Config::new()
                .cargo_metadata(need_lua_lib)
-                .probe("lua5.1");
+                .probe(alt_probe);
        }

-        lua.unwrap().include_paths[0].clone()
+        lua.unwrap_or_else(|_| panic!("cannot find Lua {} using `pkg-config`", ver))
+            .include_paths
+            .get(0)
+            .cloned()
    }

    #[cfg(feature = "luajit")]
@@ -114,6 +83,9 @@ pub fn probe_lua() -> PathBuf {
            .cargo_metadata(need_lua_lib)
            .probe("luajit");

-        lua.unwrap().include_paths[0].clone()
+        lua.expect("cannot find LuaJIT using `pkg-config`")
+            .include_paths
+            .get(0)
+            .cloned()
    }
 }
@@ -1,6 +1,6 @@
 use std::path::PathBuf;

-pub fn probe_lua() -> PathBuf {
+pub fn probe_lua() -> Option<PathBuf> {
    #[cfg(feature = "lua54")]
    let artifacts = lua_src::Build::new().build(lua_src::Lua54);
    #[cfg(feature = "lua53")]
@@ -10,10 +10,18 @@ pub fn probe_lua() -> PathBuf {
    #[cfg(feature = "lua51")]
    let artifacts = lua_src::Build::new().build(lua_src::Lua51);
    #[cfg(feature = "luajit")]
-    let artifacts = luajit_src::Build::new().build();
+    let artifacts = {
+        let mut builder = luajit_src::Build::new();
+        if cfg!(feature = "luajit52") {
+            builder.lua52compat(true);
+        }
+        builder.build()
+    };
+    #[cfg(feature = "luau")]
+    let artifacts = luau0_src::Build::new().build();

    #[cfg(not(feature = "module"))]
    artifacts.print_cargo_metadata();

-    artifacts.include_dir().to_owned()
+    Some(artifacts.include_dir().to_owned())
 }
@@ -1,20 +1,15 @@
-#![allow(unreachable_code)]
-
-use std::env;
-use std::fs::File;
-use std::io::{Error, ErrorKind, Result, Write};
-use std::path::{Path, PathBuf};
-use std::process::Command;
-
 #[cfg_attr(
-    all(
-        feature = "vendored",
-        any(
-            feature = "lua54",
-            feature = "lua53",
-            feature = "lua52",
-            feature = "lua51",
-            feature = "luajit"
+    any(
+        feature = "luau",
+        all(
+            feature = "vendored",
+            any(
+                feature = "lua54",
+                feature = "lua53",
+                feature = "lua52",
+                feature = "lua51",
+                feature = "luajit"
+            )
        )
    ),
    path = "find_vendored.rs"
@@ -38,168 +33,25 @@ use std::process::Command;
        feature = "lua53",
        feature = "lua52",
        feature = "lua51",
-        feature = "luajit"
+        feature = "luajit",
+        feature = "luau"
    )),
    path = "find_dummy.rs"
 )]
 mod find;

-trait CommandExt {
-    fn execute(&mut self) -> Result<()>;
-}
-
-impl CommandExt for Command {
-    /// Execute the command and return an error if it exited with a failure status.
-    fn execute(&mut self) -> Result<()> {
-        self.status()
-            .and_then(|status| {
-                if status.success() {
-                    Ok(())
-                } else {
-                    Err(Error::new(ErrorKind::Other, "non-zero exit code"))
-                }
-            })
-            .map_err(|_| {
-                Error::new(
-                    ErrorKind::Other,
-                    format!("The command {:?} did not run successfully.", self),
-                )
-            })
-    }
-}
-
-fn build_glue<P: AsRef<Path> + std::fmt::Debug>(include_path: &P) {
-    let build_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
-
-    let mut config = cc::Build::new();
-    config.include(include_path);
-
-    // Compile and run glue.c
-    let glue = build_dir.join("glue");
-
-    config
-        .get_compiler()
-        .to_command()
-        .arg("src/ffi/glue/glue.c")
-        .arg("-o")
-        .arg(&glue)
-        .execute()
-        .unwrap();
-
-    Command::new(glue)
-        .arg(build_dir.join("glue.rs"))
-        .execute()
-        .unwrap();
-}
-
-// When cross-compiling, we cannot use `build_glue` as we cannot run the generated
-// executable.  Instead, let's take a stab at synthesizing the likely values.
-// If you're cross-compiling and using a non-vendored library then there is a chance
-// that the values selected here may be incorrect, but we have no way to determine
-// that here.
-fn generate_glue() -> Result<()> {
-    let build_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
-    let mut glue = File::create(build_dir.join("glue.rs"))?;
-    writeln!(
-        glue,
-        "/* This file was generated by build/main.rs; do not modify by hand */"
-    )?;
-    writeln!(glue, "use std::os::raw::*;")?;
-
-    writeln!(glue, "/* luaconf.h */")?;
-    let pointer_bit_width: usize = env::var("CARGO_CFG_TARGET_POINTER_WIDTH")
-        .unwrap()
-        .parse()
-        .unwrap();
-    writeln!(
-        glue,
-        "pub const LUA_EXTRASPACE: c_int = {} / 8;",
-        pointer_bit_width
-    )?;
-
-    // This is generally hardcoded to this size
-    writeln!(glue, "pub const LUA_IDSIZE: c_int = 60;")?;
-
-    // Unless the target is restricted, the defaults are 64 bit
-    writeln!(glue, "pub type LUA_NUMBER = c_double;")?;
-    writeln!(glue, "pub type LUA_INTEGER = i64;")?;
-    writeln!(glue, "pub type LUA_UNSIGNED = u64;")?;
-
-    writeln!(glue, "/* lua.h */")?;
-    let version = if cfg!(any(feature = "luajit", feature = "lua51")) {
-        (5, 1, 0)
-    } else if cfg!(feature = "lua52") {
-        (5, 2, 0)
-    } else if cfg!(feature = "lua53") {
-        (5, 3, 0)
-    } else if cfg!(feature = "lua54") {
-        (5, 4, 0)
-    } else {
-        unreachable!();
-    };
-    writeln!(
-        glue,
-        "pub const LUA_VERSION_NUM: c_int = {};",
-        (version.0 * 100) + version.1
-    )?;
-
-    let max_stack = if pointer_bit_width >= 32 {
-        1_000_000
-    } else {
-        15_000
-    };
-    writeln!(
-        glue,
-        "pub const LUA_REGISTRYINDEX: c_int = -{} - 1000;",
-        max_stack
-    )?;
-
-    // These two are only defined in lua 5.1
-    writeln!(glue, "pub const LUA_ENVIRONINDEX: c_int = -10001;")?;
-    writeln!(glue, "pub const LUA_GLOBALSINDEX: c_int = -10002;")?;
-
-    writeln!(glue, "/* lauxlib.h */")?;
-    // This is only defined in lua 5.3 and up, but we can always generate its value here,
-    // even if we don't use it.
-    // This matches the default definition in lauxlib.h
-    writeln!(glue, "pub const LUAL_NUMSIZES: c_int = std::mem::size_of::<LUA_INTEGER>() as c_int * 16 + std::mem::size_of::<LUA_NUMBER>() as c_int;")?;
-
-    writeln!(glue, "/* lualib.h */")?;
-    write!(
-        glue,
-        r#"
-#[cfg(feature = "luajit")]
-pub const LUA_BITLIBNAME: &str = "bit";
-#[cfg(not(feature = "luajit"))]
-pub const LUA_BITLIBNAME: &str = "bit32";
-
-pub const LUA_COLIBNAME: &str = "coroutine";
-pub const LUA_DBLIBNAME: &str = "debug";
-pub const LUA_IOLIBNAME: &str = "io";
-pub const LUA_LOADLIBNAME: &str = "package";
-pub const LUA_MATHLIBNAME: &str = "math";
-pub const LUA_OSLIBNAME: &str = "os";
-pub const LUA_STRLIBNAME: &str = "string";
-pub const LUA_TABLIBNAME: &str = "table";
-pub const LUA_UTF8LIBNAME: &str = "utf8";
-
-pub const LUA_JITLIBNAME: &str = "jit";
-pub const LUA_FFILIBNAME: &str = "ffi";
-"#
-    )?;
-
-    Ok(())
-}
-
 fn main() {
    #[cfg(not(any(
        feature = "lua54",
        feature = "lua53",
        feature = "lua52",
        feature = "lua51",
-        feature = "luajit"
+        feature = "luajit",
+        feature = "luau"
    )))]
-    compile_error!("You must enable one of the features: lua54, lua53, lua52, lua51, luajit");
+    compile_error!(
+        "You must enable one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau"
+    );

    #[cfg(all(
        feature = "lua54",
@@ -207,22 +59,44 @@ fn main() {
            feature = "lua53",
            feature = "lua52",
            feature = "lua51",
-            feature = "luajit"
+            feature = "luajit",
+            feature = "luau"
        )
    ))]
-    compile_error!("You can enable only one of the features: lua54, lua53, lua52, lua51, luajit");
+    compile_error!(
+        "You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau"
+    );

    #[cfg(all(
        feature = "lua53",
-        any(feature = "lua52", feature = "lua51", feature = "luajit")
+        any(
+            feature = "lua52",
+            feature = "lua51",
+            feature = "luajit",
+            feature = "luau"
+        )
    ))]
-    compile_error!("You can enable only one of the features: lua54, lua53, lua52, lua51, luajit");
+    compile_error!(
+        "You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau"
+    );

-    #[cfg(all(feature = "lua52", any(feature = "lua51", feature = "luajit")))]
-    compile_error!("You can enable only one of the features: lua54, lua53, lua52, lua51, luajit");
+    #[cfg(all(
+        feature = "lua52",
+        any(feature = "lua51", feature = "luajit", feature = "luau")
+    ))]
+    compile_error!(
+        "You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau"
+    );

-    #[cfg(all(feature = "lua51", feature = "luajit"))]
-    compile_error!("You can enable only one of the features: lua54, lua53, lua52, lua51, luajit");
+    #[cfg(all(feature = "lua51", any(feature = "luajit", feature = "luau")))]
+    compile_error!(
+        "You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau"
+    );
+
+    #[cfg(all(feature = "luajit", feature = "luau"))]
+    compile_error!(
+        "You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau"
+    );

    // We don't support "vendored module" mode on windows
    #[cfg(all(feature = "vendored", feature = "module", target_os = "windows"))]
@@ -231,13 +105,7 @@ fn main() {
            + "Please, use `pkg-config` or custom mode to link to a Lua dll."
    );

-    let include_dir = find::probe_lua();
-    if env::var("TARGET").unwrap() != env::var("HOST").unwrap() {
-        generate_glue().unwrap();
-    } else {
-        build_glue(&include_dir);
-        println!("cargo:rerun-if-changed=src/ffi/glue/glue.c");
-    }
+    find::probe_lua();

    println!("cargo:rerun-if-changed=build");
 }
@@ -1,26 +1,17 @@
 use std::collections::HashMap;
-use std::sync::Arc;

 use hyper::body::{Body as HyperBody, HttpBody as _};
 use hyper::Client as HyperClient;
-use tokio::sync::Mutex;

-use mlua::{chunk, ExternalResult, Lua, Result, UserData, UserDataMethods};
+use mlua::{chunk, AnyUserData, ExternalResult, Lua, Result, UserData, UserDataMethods};

-#[derive(Clone)]
-struct BodyReader(Arc<Mutex<HyperBody>>);
-
-impl BodyReader {
-    fn new(body: HyperBody) -> Self {
-        BodyReader(Arc::new(Mutex::new(body)))
-    }
-}
+struct BodyReader(HyperBody);

 impl UserData for BodyReader {
    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_async_method("read", |lua, reader, ()| async move {
-            let mut reader = reader.0.lock().await;
-            if let Some(bytes) = reader.data().await {
+        methods.add_async_function("read", |lua, reader: AnyUserData| async move {
+            let mut reader = reader.borrow_mut::<Self>()?;
+            if let Some(bytes) = reader.0.data().await {
                let bytes = bytes.to_lua_err()?;
                return Some(lua.create_string(&bytes)).transpose();
            }
@@ -50,7 +41,7 @@ async fn main() -> Result<()> {
        }

        lua_resp.set("headers", headers)?;
-        lua_resp.set("body", BodyReader::new(resp.into_body()))?;
+        lua_resp.set("body", BodyReader(resp.into_body()))?;

        Ok(lua_resp)
    })?;
@@ -58,7 +49,7 @@ async fn main() -> Result<()> {
    let f = lua
        .load(chunk! {
            local res = $fetch_url(...)
-            print(res.status)
+            print("status: "..res.status)
            for key, vals in pairs(res.headers) do
                for _, val in ipairs(vals) do
                    print(key..": "..val)
@@ -1,10 +1,16 @@
+use std::future::Future;
 use std::net::SocketAddr;
+use std::pin::Pin;
+use std::rc::Rc;
+use std::task::{Context, Poll};

 use hyper::server::conn::AddrStream;
-use hyper::service::{make_service_fn, service_fn};
+use hyper::service::Service;
 use hyper::{Body, Request, Response, Server};

-use mlua::{Error, Function, Lua, Result, Table, UserData, UserDataMethods};
+use mlua::{
+    chunk, Error as LuaError, Function, Lua, String as LuaString, Table, UserData, UserDataMethods,
+};

 struct LuaRequest(SocketAddr, Request<Body>);

@@ -15,75 +21,106 @@ impl UserData for LuaRequest {
    }
 }

-async fn run_server(handler: Function<'static>) -> Result<()> {
-    let make_svc = make_service_fn(|socket: &AddrStream| {
-        let remote_addr = socket.remote_addr();
-        let handler = handler.clone();
-        async move {
-            Ok::<_, Error>(service_fn(move |req: Request<Body>| {
-                let handler = handler.clone();
-                async move {
-                    let lua_req = LuaRequest(remote_addr, req);
-                    let lua_resp: Table = handler.call_async(lua_req).await?;
-                    let body = lua_resp
-                        .get::<_, Option<String>>("body")?
-                        .unwrap_or_default();
+pub struct Svc(Rc<Lua>, SocketAddr);

-                    let mut resp = Response::builder()
-                        .status(lua_resp.get::<_, Option<u16>>("status")?.unwrap_or(200));
+impl Service<Request<Body>> for Svc {
+    type Response = Response<Body>;
+    type Error = LuaError;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;

+    fn poll_ready(&mut self, _cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }
+
+    fn call(&mut self, req: Request<Body>) -> Self::Future {
+        // If handler returns an error then generate 5xx response
+        let lua = self.0.clone();
+        let lua_req = LuaRequest(self.1, req);
+        Box::pin(async move {
+            let handler: Function = lua.named_registry_value("http_handler")?;
+            match handler.call_async::<_, Table>(lua_req).await {
+                Ok(lua_resp) => {
+                    let status = lua_resp.get::<_, Option<u16>>("status")?.unwrap_or(200);
+                    let mut resp = Response::builder().status(status);
+
+                    // Set headers
                    if let Some(headers) = lua_resp.get::<_, Option<Table>>("headers")? {
-                        for pair in headers.pairs::<String, String>() {
+                        for pair in headers.pairs::<String, LuaString>() {
                            let (h, v) = pair?;
-                            resp = resp.header(&h, v);
+                            resp = resp.header(&h, v.as_bytes());
                        }
                    }

-                    Ok::<_, Error>(resp.body(Body::from(body)).unwrap())
+                    let body = lua_resp
+                        .get::<_, Option<LuaString>>("body")?
+                        .map(|b| Body::from(b.as_bytes().to_vec()))
+                        .unwrap_or_else(Body::empty);
+
+                    Ok(resp.body(body).unwrap())
                }
-            }))
-        }
-    });
+                Err(err) => {
+                    eprintln!("{}", err);
+                    Ok(Response::builder()
+                        .status(500)
+                        .body(Body::from("Internal Server Error"))
+                        .unwrap())
+                }
+            }
+        })
+    }
+}
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() {
+    let lua = Rc::new(Lua::new());
+
+    // Create Lua handler function
+    let handler: Function = lua
+        .load(chunk! {
+            function(req)
+                return {
+                    status = 200,
+                    headers = {
+                        ["X-Req-Method"] = req:method(),
+                        ["X-Remote-Addr"] = req:remote_addr(),
+                    },
+                    body = "Hello from Lua!\n"
+                }
+            end
+        })
+        .eval()
+        .expect("cannot create Lua handler");
+
+    // Store it in the Registry
+    lua.set_named_registry_value("http_handler", handler)
+        .expect("cannot store Lua handler");

    let addr = ([127, 0, 0, 1], 3000).into();
-    let server = Server::bind(&addr).executor(LocalExec).serve(make_svc);
+    let server = Server::bind(&addr).executor(LocalExec).serve(MakeSvc(lua));

    println!("Listening on http://{}", addr);

-    tokio::task::LocalSet::new()
-        .run_until(server)
-        .await
-        .map_err(Error::external)
+    // Create `LocalSet` to spawn !Send futures
+    let local = tokio::task::LocalSet::new();
+    local.run_until(server).await.expect("cannot run server")
 }

-#[tokio::main]
-async fn main() -> Result<()> {
-    let lua = Lua::new().into_static();
+struct MakeSvc(Rc<Lua>);

-    let handler: Function = lua
-        .load(
-            r#"
-        function(req)
-            return {
-                status = 200,
-                headers = {
-                    ["X-Req-Method"] = req:method(),
-                    ["X-Remote-Addr"] = req:remote_addr(),
-                },
-                body = "Hello, World!\n"
-            }
-        end
-    "#,
-        )
-        .eval()?;
+impl Service<&AddrStream> for MakeSvc {
+    type Response = Svc;
+    type Error = hyper::Error;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;

-    run_server(handler).await?;
+    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
+        Poll::Ready(Ok(()))
+    }

-    // Consume the static reference and drop it.
-    // This is safe as long as we don't hold any other references to Lua
-    // or alive resources.
-    unsafe { Lua::from_static(lua) };
-    Ok(())
+    fn call(&mut self, stream: &AddrStream) -> Self::Future {
+        let lua = self.0.clone();
+        let remote_addr = stream.remote_addr();
+        Box::pin(async move { Ok(Svc(lua, remote_addr)) })
+    }
 }

 #[derive(Clone, Copy, Debug)]
@@ -1,122 +1,121 @@
-use std::sync::Arc;
+use std::io;
+use std::net::SocketAddr;
+use std::rc::Rc;

 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{TcpListener, TcpStream};
-use tokio::sync::Mutex;
 use tokio::task;

-use mlua::{chunk, Function, Lua, Result, String as LuaString, UserData, UserDataMethods};
+use mlua::{
+    chunk, AnyUserData, Function, Lua, RegistryKey, String as LuaString, UserData, UserDataMethods,
+};

-struct LuaTcp;
-
-#[derive(Clone)]
-struct LuaTcpListener(Arc<Mutex<TcpListener>>);
-
-#[derive(Clone)]
-struct LuaTcpStream(Arc<Mutex<TcpStream>>);
-
-impl UserData for LuaTcp {
-    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_async_function("bind", |_, addr: String| async move {
-            let listener = TcpListener::bind(addr).await?;
-            Ok(LuaTcpListener(Arc::new(Mutex::new(listener))))
-        });
-    }
-}
-
-impl UserData for LuaTcpListener {
-    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_async_method("accept", |_, listener, ()| async move {
-            let (stream, _) = listener.0.lock().await.accept().await?;
-            Ok(LuaTcpStream(Arc::new(Mutex::new(stream))))
-        });
-    }
-}
+struct LuaTcpStream(TcpStream);

 impl UserData for LuaTcpStream {
    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_async_method("peer_addr", |_, stream, ()| async move {
-            Ok(stream.0.lock().await.peer_addr()?.to_string())
+        methods.add_method("peer_addr", |_, this, ()| {
+            Ok(this.0.peer_addr()?.to_string())
        });

-        methods.add_async_method("read", |lua, stream, size: usize| async move {
-            let mut buf = vec![0; size];
-            let n = stream.0.lock().await.read(&mut buf).await?;
-            buf.truncate(n);
-            lua.create_string(&buf)
-        });
+        methods.add_async_function(
+            "read",
+            |lua, (this, size): (AnyUserData, usize)| async move {
+                let mut this = this.borrow_mut::<Self>()?;
+                let mut buf = vec![0; size];
+                let n = this.0.read(&mut buf).await?;
+                buf.truncate(n);
+                lua.create_string(&buf)
+            },
+        );

-        methods.add_async_method("write", |_, stream, data: LuaString| async move {
-            let n = stream.0.lock().await.write(&data.as_bytes()).await?;
-            Ok(n)
-        });
+        methods.add_async_function(
+            "write",
+            |_, (this, data): (AnyUserData, LuaString)| async move {
+                let mut this = this.borrow_mut::<Self>()?;
+                let n = this.0.write(&data.as_bytes()).await?;
+                Ok(n)
+            },
+        );

-        methods.add_async_method("close", |_, stream, ()| async move {
-            stream.0.lock().await.shutdown().await?;
+        methods.add_async_function("close", |_, this: AnyUserData| async move {
+            let mut this = this.borrow_mut::<Self>()?;
+            this.0.shutdown().await?;
            Ok(())
        });
    }
 }

-async fn run_server(lua: &'static Lua) -> Result<()> {
-    let spawn = lua.create_function(move |_, func: Function| {
-        task::spawn_local(async move { func.call_async::<_, ()>(()).await });
-        Ok(())
-    })?;
+async fn run_server(lua: Lua, handler: RegistryKey) -> io::Result<()> {
+    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
+    let listener = TcpListener::bind(addr).await.expect("cannot bind addr");

-    let tcp = LuaTcp;
+    println!("Listening on {}", addr);

-    let server = lua
+    let lua = Rc::new(lua);
+    let handler = Rc::new(handler);
+    loop {
+        let (stream, _) = match listener.accept().await {
+            Ok(res) => res,
+            Err(err) if is_transient_error(&err) => continue,
+            Err(err) => return Err(err),
+        };
+
+        let lua = lua.clone();
+        let handler = handler.clone();
+        task::spawn_local(async move {
+            let handler: Function = lua
+                .registry_value(&handler)
+                .expect("cannot get Lua handler");
+
+            let stream = LuaTcpStream(stream);
+            if let Err(err) = handler.call_async::<_, ()>(stream).await {
+                eprintln!("{}", err);
+            }
+        });
+    }
+}
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() {
+    let lua = Lua::new();
+
+    // Create Lua handler function
+    let handler_fn = lua
        .load(chunk! {
-            local addr = ...
-            local listener = $tcp.bind(addr)
-            print("listening on "..addr)
-
-            local accept_new = true
-            while true do
-                local stream = listener:accept()
+            function(stream)
                local peer_addr = stream:peer_addr()
                print("connected from "..peer_addr)

-                if not accept_new then
-                    return
-                end
-
-                $spawn(function()
-                    while true do
-                        local data = stream:read(100)
-                        data = data:match("^%s*(.-)%s*$") -- trim
-                        print("["..peer_addr.."] "..data)
-                        if data == "bye" then
-                            stream:write("bye bye\n")
-                            stream:close()
-                            return
-                        end
-                        if data == "exit" then
-                            stream:close()
-                            accept_new = false
-                            return
-                        end
-                        stream:write("echo: "..data.."\n")
+                while true do
+                    local data = stream:read(100)
+                    data = data:match("^%s*(.-)%s*$") // trim
+                    print("["..peer_addr.."] "..data)
+                    if data == "bye" then
+                        stream:write("bye bye\n")
+                        stream:close()
+                        return
                    end
-                end)
+                    stream:write("echo: "..data.."\n")
+                end
            end
        })
-        .into_function()?;
+        .eval::<Function>()
+        .expect("cannot create Lua handler");
+
+    // Store it in the Registry
+    let handler = lua
+        .create_registry_value(handler_fn)
+        .expect("cannot store Lua handler");

    task::LocalSet::new()
-        .run_until(server.call_async::<_, ()>("0.0.0.0:1234"))
+        .run_until(run_server(lua, handler))
        .await
+        .expect("cannot run server")
 }

-#[tokio::main]
-async fn main() {
-    let lua = Lua::new().into_static();
-
-    run_server(lua).await.unwrap();
-
-    // Consume the static reference and drop it.
-    // This is safe as long as we don't hold any other references to Lua
-    // or alive resources.
-    unsafe { Lua::from_static(lua) };
+fn is_transient_error(e: &io::Error) -> bool {
+    e.kind() == io::ErrorKind::ConnectionRefused
+        || e.kind() == io::ErrorKind::ConnectionAborted
+        || e.kind() == io::ErrorKind::ConnectionReset
 }
@@ -3,3 +3,9 @@ rustflags = [
  "-C", "link-arg=-undefined",
  "-C", "link-arg=dynamic_lookup",
 ]
+
+[target.aarch64-apple-darwin]
+rustflags = [
+  "-C", "link-arg=-undefined",
+  "-C", "link-arg=dynamic_lookup",
+]
@@ -175,8 +175,7 @@ impl Tokens {
    pub(crate) fn retokenize(tt: TokenStream) -> Tokens {
        Tokens(
            tt.into_iter()
-                .map(Tokens::from)
-                .flatten()
+                .flat_map(Tokens::from)
                .peekable()
                .batching(|iter| {
                    // Find variable tokens
@@ -217,7 +216,7 @@ impl From<TokenTree> for Tokens {

                vec![Token::new_delim(b, tt.clone(), true)]
                    .into_iter()
-                    .chain(g.stream().into_iter().map(Tokens::from).flatten())
+                    .chain(g.stream().into_iter().flat_map(Tokens::from))
                    .chain(vec![Token::new_delim(e, tt, false)])
                    .collect()
            }
@@ -0,0 +1,398 @@
+use std::borrow::Cow;
+use std::ffi::CString;
+
+use crate::error::{Error, Result};
+use crate::ffi;
+use crate::function::Function;
+use crate::lua::Lua;
+use crate::value::{FromLuaMulti, ToLua, ToLuaMulti, Value};
+
+#[cfg(feature = "async")]
+use {futures_core::future::LocalBoxFuture, futures_util::future};
+
+/// Trait for types [loadable by Lua] and convertible to a [`Chunk`]
+///
+/// [loadable by Lua]: https://www.lua.org/manual/5.4/manual.html#3.3.2
+/// [`Chunk`]: crate::Chunk
+pub trait AsChunk<'lua> {
+    /// Returns chunk data (can be text or binary)
+    fn source(&self) -> &[u8];
+
+    /// Returns optional chunk name
+    fn name(&self) -> Option<CString> {
+        None
+    }
+
+    /// Returns optional chunk [environment]
+    ///
+    /// [environment]: https://www.lua.org/manual/5.4/manual.html#2.2
+    fn env(&self, _lua: &'lua Lua) -> Result<Option<Value<'lua>>> {
+        Ok(None)
+    }
+
+    /// Returns optional chunk mode (text or binary)
+    fn mode(&self) -> Option<ChunkMode> {
+        None
+    }
+}
+
+impl<'lua, T: AsRef<[u8]> + ?Sized> AsChunk<'lua> for T {
+    fn source(&self) -> &[u8] {
+        self.as_ref()
+    }
+}
+
+/// Returned from [`Lua::load`] and is used to finalize loading and executing Lua main chunks.
+///
+/// [`Lua::load`]: crate::Lua::load
+#[must_use = "`Chunk`s do nothing unless one of `exec`, `eval`, `call`, or `into_function` are called on them"]
+pub struct Chunk<'lua, 'a> {
+    pub(crate) lua: &'lua Lua,
+    pub(crate) source: Cow<'a, [u8]>,
+    pub(crate) name: Option<CString>,
+    pub(crate) env: Result<Option<Value<'lua>>>,
+    pub(crate) mode: Option<ChunkMode>,
+    #[cfg(feature = "luau")]
+    pub(crate) compiler: Option<Compiler>,
+}
+
+/// Represents chunk mode (text or binary).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ChunkMode {
+    Text,
+    Binary,
+}
+
+/// Luau compiler
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+#[derive(Clone, Copy, Debug)]
+pub struct Compiler {
+    optimization_level: u8,
+    debug_level: u8,
+    coverage_level: u8,
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl Default for Compiler {
+    fn default() -> Self {
+        // Defaults are taken from luacode.h
+        Compiler {
+            optimization_level: 1,
+            debug_level: 1,
+            coverage_level: 0,
+        }
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl Compiler {
+    /// Creates Luau compiler instance with default options
+    pub fn new() -> Self {
+        Compiler::default()
+    }
+
+    /// Sets Luau compiler optimization level.
+    ///
+    /// Possible values:
+    /// 0 - no optimization
+    /// 1 - baseline optimization level that doesn't prevent debuggability (default)
+    /// 2 - includes optimizations that harm debuggability such as inlining
+    pub fn set_optimization_level(mut self, level: u8) -> Self {
+        self.optimization_level = level;
+        self
+    }
+
+    /// Sets Luau compiler debug level.
+    ///
+    /// Possible values:
+    /// 0 - no debugging support
+    /// 1 - line info & function names only; sufficient for backtraces (default)
+    /// 2 - full debug info with local & upvalue names; necessary for debugger
+    pub fn set_debug_level(mut self, level: u8) -> Self {
+        self.debug_level = level;
+        self
+    }
+
+    /// Sets Luau compiler code coverage level.
+    ///
+    /// Possible values:
+    /// 0 - no code coverage support (default)
+    /// 1 - statement coverage
+    /// 2 - statement and expression coverage (verbose)
+    pub fn set_coverage_level(mut self, level: u8) -> Self {
+        self.coverage_level = level;
+        self
+    }
+
+    /// Compiles the `source` into bytecode.
+    pub fn compile(&self, source: impl AsRef<[u8]>) -> Vec<u8> {
+        use std::os::raw::c_int;
+        use std::ptr;
+
+        unsafe {
+            let options = ffi::lua_CompileOptions {
+                optimizationLevel: self.optimization_level as c_int,
+                debugLevel: self.debug_level as c_int,
+                coverageLevel: self.coverage_level as c_int,
+                vectorLib: ptr::null(),
+                vectorCtor: ptr::null(),
+                mutableGlobals: ptr::null_mut(),
+            };
+            ffi::luau_compile(source.as_ref(), options)
+        }
+    }
+}
+
+impl<'lua, 'a> Chunk<'lua, 'a> {
+    /// Sets the name of this chunk, which results in more informative error traces.
+    pub fn set_name<S: AsRef<[u8]> + ?Sized>(mut self, name: &S) -> Result<Chunk<'lua, 'a>> {
+        let name =
+            CString::new(name.as_ref().to_vec()).map_err(|e| Error::ToLuaConversionError {
+                from: "&str",
+                to: "string",
+                message: Some(e.to_string()),
+            })?;
+        self.name = Some(name);
+        Ok(self)
+    }
+
+    /// Sets the first upvalue (`_ENV`) of the loaded chunk to the given value.
+    ///
+    /// Lua main chunks always have exactly one upvalue, and this upvalue is used as the `_ENV`
+    /// variable inside the chunk. By default this value is set to the global environment.
+    ///
+    /// Calling this method changes the `_ENV` upvalue to the value provided, and variables inside
+    /// the chunk will refer to the given environment rather than the global one.
+    ///
+    /// All global variables (including the standard library!) are looked up in `_ENV`, so it may be
+    /// necessary to populate the environment in order for scripts using custom environments to be
+    /// useful.
+    pub fn set_environment<V: ToLua<'lua>>(mut self, env: V) -> Result<Chunk<'lua, 'a>> {
+        // Prefer to propagate errors here and wrap to `Ok`
+        self.env = Ok(Some(env.to_lua(self.lua)?));
+        Ok(self)
+    }
+
+    /// Sets whether the chunk is text or binary (autodetected by default).
+    ///
+    /// Be aware, Lua does not check the consistency of the code inside binary chunks.
+    /// Running maliciously crafted bytecode can crash the interpreter.
+    pub fn set_mode(mut self, mode: ChunkMode) -> Chunk<'lua, 'a> {
+        self.mode = Some(mode);
+        self
+    }
+
+    /// Sets Luau compiler optimization level.
+    ///
+    /// See [`Compiler::set_optimization_level`] for details.
+    ///
+    /// Requires `feature = "luau`
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn set_optimization_level(mut self, level: u8) -> Self {
+        self.compiler
+            .get_or_insert_with(Default::default)
+            .set_optimization_level(level);
+        self
+    }
+
+    /// Sets Luau compiler debug level.
+    ///
+    /// See [`Compiler::set_debug_level`] for details.
+    ///
+    /// Requires `feature = "luau`
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn set_debug_level(mut self, level: u8) -> Self {
+        self.compiler
+            .get_or_insert_with(Default::default)
+            .set_debug_level(level);
+        self
+    }
+
+    /// Sets Luau compiler code coverage level.
+    ///
+    /// See [`Compiler::set_coverage_level`] for details.
+    ///
+    /// Requires `feature = "luau`
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn set_coverage_level(mut self, level: u8) -> Self {
+        self.compiler
+            .get_or_insert_with(Default::default)
+            .set_coverage_level(level);
+        self
+    }
+
+    /// Compiles the chunk and changes mode to binary.
+    ///
+    /// It does nothing if the chunk is already binary.
+    #[cfg(feature = "luau")]
+    #[doc(hidden)]
+    pub fn compile(mut self) -> Self {
+        if self.detect_mode() == ChunkMode::Text {
+            let data = self
+                .compiler
+                .unwrap_or_default()
+                .compile(self.source.as_ref());
+            self.mode = Some(ChunkMode::Binary);
+            self.source = Cow::Owned(data);
+        }
+        self
+    }
+
+    /// Execute this chunk of code.
+    ///
+    /// This is equivalent to calling the chunk function with no arguments and no return values.
+    pub fn exec(self) -> Result<()> {
+        self.call(())?;
+        Ok(())
+    }
+
+    /// Asynchronously execute this chunk of code.
+    ///
+    /// See [`exec`] for more details.
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// [`exec`]: #method.exec
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    pub fn exec_async<'fut>(self) -> LocalBoxFuture<'fut, Result<()>>
+    where
+        'lua: 'fut,
+    {
+        self.call_async(())
+    }
+
+    /// Evaluate the chunk as either an expression or block.
+    ///
+    /// If the chunk can be parsed as an expression, this loads and executes the chunk and returns
+    /// the value that it evaluates to. Otherwise, the chunk is interpreted as a block as normal,
+    /// and this is equivalent to calling `exec`.
+    pub fn eval<R: FromLuaMulti<'lua>>(self) -> Result<R> {
+        // Bytecode is always interpreted as a statement.
+        // For source code, first try interpreting the lua as an expression by adding
+        // "return", then as a statement. This is the same thing the
+        // actual lua repl does.
+        if self.detect_mode() == ChunkMode::Binary {
+            self.call(())
+        } else if let Ok(function) = self.to_expression() {
+            function.call(())
+        } else {
+            self.call(())
+        }
+    }
+
+    /// Asynchronously evaluate the chunk as either an expression or block.
+    ///
+    /// See [`eval`] for more details.
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// [`eval`]: #method.eval
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    pub fn eval_async<'fut, R>(self) -> LocalBoxFuture<'fut, Result<R>>
+    where
+        'lua: 'fut,
+        R: FromLuaMulti<'lua> + 'fut,
+    {
+        if self.detect_mode() == ChunkMode::Binary {
+            self.call_async(())
+        } else if let Ok(function) = self.to_expression() {
+            function.call_async(())
+        } else {
+            self.call_async(())
+        }
+    }
+
+    /// Load the chunk function and call it with the given arguments.
+    ///
+    /// This is equivalent to `into_function` and calling the resulting function.
+    pub fn call<A: ToLuaMulti<'lua>, R: FromLuaMulti<'lua>>(self, args: A) -> Result<R> {
+        self.into_function()?.call(args)
+    }
+
+    /// Load the chunk function and asynchronously call it with the given arguments.
+    ///
+    /// See [`call`] for more details.
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// [`call`]: #method.call
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    pub fn call_async<'fut, A, R>(self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    where
+        'lua: 'fut,
+        A: ToLuaMulti<'lua>,
+        R: FromLuaMulti<'lua> + 'fut,
+    {
+        match self.into_function() {
+            Ok(func) => func.call_async(args),
+            Err(e) => Box::pin(future::err(e)),
+        }
+    }
+
+    /// Load this chunk into a regular `Function`.
+    ///
+    /// This simply compiles the chunk without actually executing it.
+    pub fn into_function(self) -> Result<Function<'lua>> {
+        #[cfg(not(feature = "luau"))]
+        let self_ = self;
+        #[cfg(feature = "luau")]
+        let self_ = match self.compiler {
+            // We don't need to compile source if no compiler options set
+            Some(_) => self.compile(),
+            _ => self,
+        };
+
+        self_.lua.load_chunk(
+            self_.source.as_ref(),
+            self_.name.as_ref(),
+            self_.env()?,
+            self_.mode,
+        )
+    }
+
+    fn env(&self) -> Result<Option<Value<'lua>>> {
+        self.env.clone()
+    }
+
+    fn expression_source(&self) -> Vec<u8> {
+        let mut buf = Vec::with_capacity(b"return ".len() + self.source.len());
+        buf.extend(b"return ");
+        buf.extend(self.source.as_ref());
+        buf
+    }
+
+    fn to_expression(&self) -> Result<Function<'lua>> {
+        // We assume that mode is Text
+        let source = self.expression_source();
+        // We don't need to compile source if no compiler options set
+        #[cfg(feature = "luau")]
+        let source = self.compiler.map(|c| c.compile(&source)).unwrap_or(source);
+
+        self.lua
+            .load_chunk(&source, self.name.as_ref(), self.env()?, None)
+    }
+
+    fn detect_mode(&self) -> ChunkMode {
+        match self.mode {
+            Some(mode) => mode,
+            None => {
+                #[cfg(not(feature = "luau"))]
+                if self.source.starts_with(ffi::LUA_SIGNATURE) {
+                    return ChunkMode::Binary;
+                }
+                #[cfg(feature = "luau")]
+                if self.source[0] < b'\n' {
+                    return ChunkMode::Binary;
+                }
+                ChunkMode::Text
+            }
+        }
+    }
+}
@@ -2,6 +2,7 @@

 use std::borrow::Cow;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::convert::TryInto;
 use std::ffi::{CStr, CString};
 use std::hash::{BuildHasher, Hash};
 use std::string::String as StdString;
@@ -20,24 +21,28 @@ use crate::userdata::{AnyUserData, UserData};
 use crate::value::{FromLua, Nil, ToLua, Value};

 impl<'lua> ToLua<'lua> for Value<'lua> {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(self)
    }
 }

 impl<'lua> FromLua<'lua> for Value<'lua> {
+    #[inline]
    fn from_lua(lua_value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
        Ok(lua_value)
    }
 }

 impl<'lua> ToLua<'lua> for String<'lua> {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::String(self))
    }
 }

 impl<'lua> FromLua<'lua> for String<'lua> {
+    #[inline]
    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<String<'lua>> {
        let ty = value.type_name();
        lua.coerce_string(value)?
@@ -50,12 +55,14 @@ impl<'lua> FromLua<'lua> for String<'lua> {
 }

 impl<'lua> ToLua<'lua> for Table<'lua> {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::Table(self))
    }
 }

 impl<'lua> FromLua<'lua> for Table<'lua> {
+    #[inline]
    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Table<'lua>> {
        match value {
            Value::Table(table) => Ok(table),
@@ -69,12 +76,14 @@ impl<'lua> FromLua<'lua> for Table<'lua> {
 }

 impl<'lua> ToLua<'lua> for Function<'lua> {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::Function(self))
    }
 }

 impl<'lua> FromLua<'lua> for Function<'lua> {
+    #[inline]
    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Function<'lua>> {
        match value {
            Value::Function(table) => Ok(table),
@@ -88,12 +97,14 @@ impl<'lua> FromLua<'lua> for Function<'lua> {
 }

 impl<'lua> ToLua<'lua> for Thread<'lua> {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::Thread(self))
    }
 }

 impl<'lua> FromLua<'lua> for Thread<'lua> {
+    #[inline]
    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Thread<'lua>> {
        match value {
            Value::Thread(t) => Ok(t),
@@ -107,12 +118,14 @@ impl<'lua> FromLua<'lua> for Thread<'lua> {
 }

 impl<'lua> ToLua<'lua> for AnyUserData<'lua> {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::UserData(self))
    }
 }

 impl<'lua> FromLua<'lua> for AnyUserData<'lua> {
+    #[inline]
    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<AnyUserData<'lua>> {
        match value {
            Value::UserData(ud) => Ok(ud),
@@ -126,12 +139,14 @@ impl<'lua> FromLua<'lua> for AnyUserData<'lua> {
 }

 impl<'lua, T: 'static + MaybeSend + UserData> ToLua<'lua> for T {
+    #[inline]
    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::UserData(lua.create_userdata(self)?))
    }
 }

 impl<'lua, T: 'static + UserData + Clone> FromLua<'lua> for T {
+    #[inline]
    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<T> {
        match value {
            Value::UserData(ud) => Ok(ud.borrow::<T>()?.clone()),
@@ -145,12 +160,14 @@ impl<'lua, T: 'static + UserData + Clone> FromLua<'lua> for T {
 }

 impl<'lua> ToLua<'lua> for Error {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::Error(self))
    }
 }

 impl<'lua> FromLua<'lua> for Error {
+    #[inline]
    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Error> {
        match value {
            Value::Error(err) => Ok(err),
@@ -164,12 +181,14 @@ impl<'lua> FromLua<'lua> for Error {
 }

 impl<'lua> ToLua<'lua> for bool {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::Boolean(self))
    }
 }

 impl<'lua> FromLua<'lua> for bool {
+    #[inline]
    fn from_lua(v: Value<'lua>, _: &'lua Lua) -> Result<Self> {
        match v {
            Value::Nil => Ok(false),
@@ -180,12 +199,14 @@ impl<'lua> FromLua<'lua> for bool {
 }

 impl<'lua> ToLua<'lua> for LightUserData {
+    #[inline]
    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::LightUserData(self))
    }
 }

 impl<'lua> FromLua<'lua> for LightUserData {
+    #[inline]
    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
        match value {
            Value::LightUserData(ud) => Ok(ud),
@@ -199,12 +220,14 @@ impl<'lua> FromLua<'lua> for LightUserData {
 }

 impl<'lua> ToLua<'lua> for StdString {
+    #[inline]
    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::String(lua.create_string(&self)?))
    }
 }

 impl<'lua> FromLua<'lua> for StdString {
+    #[inline]
    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
        let ty = value.type_name();
        Ok(lua
@@ -220,6 +243,7 @@ impl<'lua> FromLua<'lua> for StdString {
 }

 impl<'lua> ToLua<'lua> for &str {
+    #[inline]
    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
        Ok(Value::String(lua.create_string(self)?))
    }
@@ -325,24 +349,24 @@ macro_rules! lua_convert_int {
    ($x:ty) => {
        impl<'lua> ToLua<'lua> for $x {
            fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
-                if let Some(i) = cast(self) {
-                    Ok(Value::Integer(i))
-                } else {
-                    cast(self)
-                        .ok_or_else(|| Error::ToLuaConversionError {
-                            from: stringify!($x),
-                            to: "number",
-                            message: Some("out of range".to_owned()),
-                        })
-                        .map(Value::Number)
-                }
+                cast(self)
+                    .map(Value::Integer)
+                    .or_else(|| cast(self).map(Value::Number))
+                    // This is impossible error because conversion to Number never fails
+                    .ok_or_else(|| Error::ToLuaConversionError {
+                        from: stringify!($x),
+                        to: "number",
+                        message: Some("out of range".to_owned()),
+                    })
            }
        }

        impl<'lua> FromLua<'lua> for $x {
            fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
                let ty = value.type_name();
-                (if let Some(i) = lua.coerce_integer(value.clone())? {
+                (if let Value::Integer(i) = value {
+                    cast(i)
+                } else if let Some(i) = lua.coerce_integer(value.clone())? {
                    cast(i)
                } else {
                    cast(lua.coerce_number(value)?.ok_or_else(|| {
@@ -427,37 +451,48 @@ where
    }
 }

-macro_rules! lua_convert_array {
-    ($($N:literal)+) => {
-        $(
-            impl<'lua, T> ToLua<'lua> for [T; $N]
-            where
-                T: Clone + ToLua<'lua>,
-            {
-                fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-                    (&self).to_lua(lua)
-                }
-            }
-
-            impl<'lua, T> ToLua<'lua> for &[T; $N]
-            where
-                T: Clone + ToLua<'lua>,
-            {
-                fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-                    Ok(Value::Table(
-                        lua.create_sequence_from(self.iter().cloned())?,
-                    ))
-                }
-            }
-        )+
+impl<'lua, T, const N: usize> ToLua<'lua> for [T; N]
+where
+    T: ToLua<'lua>,
+{
+    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+        Ok(Value::Table(lua.create_sequence_from(self)?))
    }
 }

-lua_convert_array! {
-    0  1  2  3  4  5  6  7  8  9
-   10 11 12 13 14 15 16 17 18 19
-   20 21 22 23 24 25 26 27 28 29
-   30 31 32
+impl<'lua, T, const N: usize> FromLua<'lua> for [T; N]
+where
+    T: FromLua<'lua>,
+{
+    fn from_lua(value: Value<'lua>, _lua: &'lua Lua) -> Result<Self> {
+        match value {
+            #[cfg(feature = "luau")]
+            Value::Vector(x, y, z) if N == 3 => Ok(mlua_expect!(
+                vec![
+                    T::from_lua(Value::Number(x as _), _lua)?,
+                    T::from_lua(Value::Number(y as _), _lua)?,
+                    T::from_lua(Value::Number(z as _), _lua)?,
+                ]
+                .try_into()
+                .map_err(|_| ()),
+                "cannot convert vector to array"
+            )),
+            Value::Table(table) => {
+                let vec = table.sequence_values().collect::<Result<Vec<_>>>()?;
+                vec.try_into()
+                    .map_err(|vec: Vec<T>| Error::FromLuaConversionError {
+                        from: "Table",
+                        to: "Array",
+                        message: Some(format!("expected table of length {}, got {}", N, vec.len())),
+                    })
+            }
+            _ => Err(Error::FromLuaConversionError {
+                from: value.type_name(),
+                to: "Array",
+                message: Some("expected table".to_string()),
+            }),
+        }
+    }
 }

 impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Box<[T]> {
@@ -467,16 +502,8 @@ impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Box<[T]> {
 }

 impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Box<[T]> {
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
-        if let Value::Table(table) = value {
-            table.sequence_values().collect()
-        } else {
-            Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: "Box<[T]>",
-                message: Some("expected table".to_string()),
-            })
-        }
+    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
+        Ok(Vec::<T>::from_lua(value, lua)?.into_boxed_slice())
    }
 }

@@ -487,15 +514,20 @@ impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Vec<T> {
 }

 impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Vec<T> {
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
-        if let Value::Table(table) = value {
-            table.sequence_values().collect()
-        } else {
-            Err(Error::FromLuaConversionError {
+    fn from_lua(value: Value<'lua>, _lua: &'lua Lua) -> Result<Self> {
+        match value {
+            #[cfg(feature = "luau")]
+            Value::Vector(x, y, z) => Ok(vec![
+                T::from_lua(Value::Number(x as _), _lua)?,
+                T::from_lua(Value::Number(y as _), _lua)?,
+                T::from_lua(Value::Number(z as _), _lua)?,
+            ]),
+            Value::Table(table) => table.sequence_values().collect(),
+            _ => Err(Error::FromLuaConversionError {
                from: value.type_name(),
                to: "Vec",
                message: Some("expected table".to_string()),
-            })
+            }),
        }
    }
 }
@@ -595,6 +627,7 @@ impl<'lua, T: Ord + FromLua<'lua>> FromLua<'lua> for BTreeSet<T> {
 }

 impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Option<T> {
+    #[inline]
    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
        match self {
            Some(val) => val.to_lua(lua),
@@ -604,6 +637,7 @@ impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Option<T> {
 }

 impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Option<T> {
+    #[inline]
    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
        match value {
            Nil => Ok(None),
@@ -37,7 +37,8 @@ pub enum Error {
    /// Lua garbage collector error, aka `LUA_ERRGCMM`.
    ///
    /// The Lua VM returns this error when there is an error running a `__gc` metamethod.
-    #[cfg(any(feature = "lua53", feature = "lua52"))]
+    #[cfg(any(feature = "lua53", feature = "lua52", doc))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "lua53", feature = "lua52"))))]
    GarbageCollectorError(StdString),
    /// Potentially unsafe action in safe mode.
    SafetyError(StdString),
@@ -96,8 +97,8 @@ pub enum Error {
    /// [`Thread::status`] can be used to check if the coroutine can be resumed without causing this
    /// error.
    ///
-    /// [`Thread::resume`]: struct.Thread.html#method.resume
-    /// [`Thread::status`]: struct.Thread.html#method.status
+    /// [`Thread::resume`]: crate::Thread::resume
+    /// [`Thread::status`]: crate::Thread::status
    CoroutineInactive,
    /// An [`AnyUserData`] is not the expected type in a borrow.
    ///
@@ -105,15 +106,15 @@ pub enum Error {
    /// metamethods for binary operators. Refer to the documentation of [`UserDataMethods`] for
    /// details.
    ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
-    /// [`UserDataMethods`]: trait.UserDataMethods.html
+    /// [`AnyUserData`]: crate::AnyUserData
+    /// [`UserDataMethods`]: crate::UserDataMethods
    UserDataTypeMismatch,
    /// An [`AnyUserData`] borrow failed because it has been destructed.
    ///
    /// This error can happen either due to to being destructed in a previous __gc, or due to being
    /// destructed from exiting a `Lua::scope` call.
    ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
    UserDataDestructed,
    /// An [`AnyUserData`] immutable borrow failed because it is already borrowed mutably.
    ///
@@ -121,8 +122,8 @@ pub enum Error {
    /// tries to call a method on the same [`UserData`] type. Consider restructuring your API to
    /// prevent these errors.
    ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
-    /// [`UserData`]: trait.UserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
+    /// [`UserData`]: crate::UserData
    UserDataBorrowError,
    /// An [`AnyUserData`] mutable borrow failed because it is already borrowed.
    ///
@@ -130,22 +131,24 @@ pub enum Error {
    /// tries to call a method on the same [`UserData`] type. Consider restructuring your API to
    /// prevent these errors.
    ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
-    /// [`UserData`]: trait.UserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
+    /// [`UserData`]: crate::UserData
    UserDataBorrowMutError,
    /// A [`MetaMethod`] operation is restricted (typically for `__gc` or `__metatable`).
    ///
-    /// [`MetaMethod`]: enum.MetaMethod.html
+    /// [`MetaMethod`]: crate::MetaMethod
    MetaMethodRestricted(StdString),
    /// A [`MetaMethod`] (eg. `__index` or `__newindex`) has invalid type.
    ///
-    /// [`MetaMethod`]: enum.MetaMethod.html
+    /// [`MetaMethod`]: crate::MetaMethod
    MetaMethodTypeError {
        method: StdString,
        type_name: &'static str,
        message: Option<StdString>,
    },
-    /// A `RegistryKey` produced from a different Lua state was used.
+    /// A [`RegistryKey`] produced from a different Lua state was used.
+    ///
+    /// [`RegistryKey`]: crate::RegistryKey
    MismatchedRegistryKey,
    /// A Rust callback returned `Err`, raising the contained `Error` as a Lua error.
    CallbackError {
@@ -245,8 +248,28 @@ impl fmt::Display for Error {
            Error::MismatchedRegistryKey => {
                write!(fmt, "RegistryKey used from different Lua state")
            }
-            Error::CallbackError { ref traceback, .. } => {
-                write!(fmt, "callback error\n{}", traceback)
+            Error::CallbackError { ref cause, ref traceback } => {
+                writeln!(fmt, "callback error")?;
+                // Trace errors down to the root
+                let (mut cause, mut full_traceback) = (cause, None);
+                while let Error::CallbackError { cause: ref cause2, traceback: ref traceback2 } = **cause {
+                    cause = cause2;
+                    full_traceback = Some(traceback2);
+                }
+                if let Some(full_traceback) = full_traceback {
+                    let traceback = traceback.trim_start_matches("stack traceback:");
+                    let traceback = traceback.trim_start().trim_end();
+                    // Try to find local traceback within the full traceback
+                    if let Some(pos) = full_traceback.find(traceback) {
+                        write!(fmt, "{}", &full_traceback[..pos])?;
+                        writeln!(fmt, ">{}", &full_traceback[pos..].trim_end())?;
+                    } else {
+                        writeln!(fmt, "{}", full_traceback.trim_end())?;
+                    }
+                } else {
+                    writeln!(fmt, "{}", traceback.trim_end())?;
+                }
+                write!(fmt, "caused by: {}", cause)
            }
            Error::PreviouslyResumedPanic => {
                write!(fmt, "previously resumed panic returned again")
@@ -267,7 +290,11 @@ impl fmt::Display for Error {
 impl StdError for Error {
    fn source(&self) -> Option<&(dyn StdError + 'static)> {
        match *self {
-            Error::CallbackError { ref cause, .. } => Some(cause.as_ref()),
+            // An error type with a source error should either return that error via source or
+            // include that source's error message in its own Display output, but never both.
+            // https://blog.rust-lang.org/inside-rust/2021/07/01/What-the-error-handling-project-group-is-working-towards.html
+            // Given that we include source to fmt::Display implementation for `CallbackError`, this call returns nothing.
+            Error::CallbackError { .. } => None,
            Error::ExternalError(ref err) => err.source(),
            _ => None,
        }
@@ -1,289 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-// Copyright (c) 2014 J.C. Moyer
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <lauxlib.h>
-#include <lua.h>
-#include <lualib.h>
-
-#ifndef LUA_EXTRASPACE
-#define LUA_EXTRASPACE (sizeof(void*))
-#endif
-
-// Macros taken from https://gcc.gnu.org/onlinedocs/cpp/Stringification.html
-#define xstr(s) str(s)
-#define str(s) #s
-
-typedef struct rs_item {
-  int type;
-  const char *name;
-  union {
-    int int_val;
-    const char *str_val;
-    LUA_INTEGER lua_int_val;
-  };
-} rs_item;
-
-
-#define TY_INT 0
-#define RS_INT(name, val)                                                      \
-  { TY_INT, name, .int_val = val }
-
-#if LUA_VERSION_NUM >= 503
-#define TY_LUAINT 1
-#define RS_LUAINT(name, val)                                                   \
-  { TY_LUAINT, name, .lua_int_val = val }
-#endif
-
-#define TY_STR 2
-#define RS_STR(name, val)                                                      \
-  { TY_STR, name, .str_val = val }
-
-#define TY_TYPE 3
-#define RS_TYPE(name, val)                                                     \
-  { TY_TYPE, name, .str_val = val }
-
-#define TY_COMMENT 4
-#define RS_COMMENT(val)                                                        \
-  { TY_COMMENT, NULL, .str_val = val }
-
-#define TY_RAW 5
-#define RS_RAW(val)                                                            \
-  { TY_RAW, NULL, .str_val = val }
-
-const char *rs_int_type(int width) {
-  switch (width) {
-  default:
-  case 2:
-    return "i16";
-  case 4:
-    return "i32";
-  case 8:
-    return "i64";
-  case 16:
-    return "i128";
-  }
-}
-
-const char *rs_uint_type(int width) {
-  switch (width) {
-  default:
-  case 2:
-    return "u16";
-  case 4:
-    return "u32";
-  case 8:
-    return "u64";
-  case 16:
-    return "u128";
-  }
-}
-
-int try_write(char **str, char c, size_t n, size_t *written, size_t szstr) {
-  if (szstr - *written < n) {
-    return 0;
-  }
-  for (; n; n--, *written++)
-    *(*str)++ = c;
-  return 1;
-}
-
-// converts \ in a string to \\ so that it can be used as a rust string literal
-// ensures that `out` will always have a null terminating character
-size_t escape(const char *in, char *out, size_t szout) {
-  size_t written = 0;
-  char cur;
-
-  while ((cur = *in++)) {
-    switch (cur) {
-    case '\\':
-      if (!try_write(&out, cur, 2, &written, szout))
-        goto finalize;
-      break;
-    default:
-      if (!try_write(&out, cur, 1, &written, szout))
-        goto finalize;
-      break;
-    }
-  }
-
-finalize:
-  if (written + 1 <= szout) {
-    *out++ = '\0';
-    written++;
-  }
-  return written;
-}
-
-int write_int_item(FILE *f, const char *name, int value) {
-  return fprintf(f, "pub const %s: c_int = %d;\n", name, value);
-}
-
-#if LUA_VERSION_NUM >= 503
-int write_lua_int_item(FILE *f, const char *name, LUA_INTEGER value) {
-  return fprintf(f, "pub const %s: LUA_INTEGER = " LUA_INTEGER_FMT ";\n", name,
-                 value);
-}
-#endif
-
-int write_str_item(FILE *f, const char *name, const char *value) {
-  size_t len = strlen(value);
-  size_t bufsz = len * 2 + 1;
-  char *buf = malloc(bufsz);
-  int ret;
-  escape(value, buf, bufsz);
-  ret = fprintf(f, "pub const %s: &str = \"%s\";\n", name, buf);
-  free(buf);
-  return ret;
-}
-
-int write_type(FILE *f, const char *name, const char *value) {
-  return fprintf(f, "pub type %s = %s;\n", name, value);
-}
-
-int write_comment(FILE *f, const char *value) {
-  return fprintf(f, "/* %s */\n", value);
-}
-
-int write_raw(FILE *f, const char *value) { return fputs(value, f) >= 0; }
-
-int write_item(FILE *f, const rs_item *c) {
-  switch (c->type) {
-  case TY_INT:
-    return write_int_item(f, c->name, c->int_val);
-#if LUA_VERSION_NUM >= 503
-  case TY_LUAINT:
-    return write_lua_int_item(f, c->name, c->lua_int_val);
-#endif
-  case TY_STR:
-    return write_str_item(f, c->name, c->str_val);
-  case TY_TYPE:
-    return write_type(f, c->name, c->str_val);
-  case TY_COMMENT:
-    return write_comment(f, c->str_val);
-  case TY_RAW:
-    return write_raw(f, c->str_val);
-  default:
-    return 0;
-  }
-}
-
-int write_items_(FILE *f, const rs_item items[], size_t num) {
-  size_t i;
-  for (i = 0; i < num; i++) {
-    if (!write_item(f, &items[i]))
-      return 0;
-  }
-  return 1;
-}
-
-#define write_items(f, cs) write_items_(f, cs, sizeof(cs) / sizeof(cs[0]))
-
-int main(int argc, const char **argv) {
-  if (argc <= 1) {
-    printf("usage: %s <filename>\n", argv[0]);
-    return EXIT_FAILURE;
-  }
-
-  const char *filename = argv[1];
-
-  FILE *f = fopen(filename, "w");
-
-  if (!f) {
-    printf("could not open file: errno = %d\n", errno);
-    return EXIT_FAILURE;
-  }
-
-  const rs_item glue_entries[] = {
-      RS_COMMENT("this file was generated by glue.c; do not modify it by hand"),
-      RS_RAW("use std::os::raw::*;\n"),
-
-      // == luaconf.h ==========================================================
-
-      RS_COMMENT("luaconf.h"),
-      RS_INT("LUA_EXTRASPACE", LUA_EXTRASPACE),
-      RS_INT("LUA_IDSIZE", LUA_IDSIZE),
-      RS_TYPE("LUA_NUMBER",
-              sizeof(LUA_NUMBER) > sizeof(float) ? "c_double" : "c_float"),
-      RS_TYPE("LUA_INTEGER", rs_int_type(sizeof(LUA_INTEGER))),
-#if LUA_VERSION_NUM >= 502
-      RS_TYPE("LUA_UNSIGNED", rs_uint_type(sizeof(LUA_UNSIGNED))),
-#else
-      RS_TYPE("LUA_UNSIGNED", rs_uint_type(sizeof(size_t))),
-#endif
-
-      // == lua.h ==============================================================
-
-      RS_COMMENT("lua.h"),
-      RS_INT("LUA_VERSION_NUM", LUA_VERSION_NUM),
-      RS_INT("LUA_REGISTRYINDEX", LUA_REGISTRYINDEX),
-#if LUA_VERSION_NUM == 501
-      RS_INT("LUA_ENVIRONINDEX", LUA_ENVIRONINDEX),
-      RS_INT("LUA_GLOBALSINDEX", LUA_GLOBALSINDEX),
-#endif
-
-      // == lauxlib.h ==========================================================
-
-      RS_COMMENT("lauxlib.h"),
-#if LUA_VERSION_NUM >= 503
-      RS_INT("LUAL_NUMSIZES", LUAL_NUMSIZES),
-#endif
-
-      // == lualib.h ===========================================================
-
-      RS_COMMENT("lualib.h"),
-      RS_STR("LUA_COLIBNAME", LUA_COLIBNAME),
-      RS_STR("LUA_TABLIBNAME", LUA_TABLIBNAME),
-      RS_STR("LUA_IOLIBNAME", LUA_IOLIBNAME),
-      RS_STR("LUA_OSLIBNAME", LUA_OSLIBNAME),
-      RS_STR("LUA_STRLIBNAME", LUA_STRLIBNAME),
-#ifdef LUA_UTF8LIBNAME
-      RS_STR("LUA_UTF8LIBNAME", LUA_UTF8LIBNAME),
-#endif
-#ifdef LUA_BITLIBNAME
-      RS_STR("LUA_BITLIBNAME", LUA_BITLIBNAME),
-#endif
-      RS_STR("LUA_MATHLIBNAME", LUA_MATHLIBNAME),
-      RS_STR("LUA_DBLIBNAME", LUA_DBLIBNAME),
-      RS_STR("LUA_LOADLIBNAME", LUA_LOADLIBNAME),
-#ifdef LUA_JITLIBNAME
-      RS_STR("LUA_JITLIBNAME", LUA_JITLIBNAME),
-#endif
-#ifdef LUA_FFILIBNAME
-      RS_STR("LUA_FFILIBNAME", LUA_FFILIBNAME),
-#endif
-  };
-
-  if (!write_items(f, glue_entries)) {
-    printf("%s: error generating %s; aborting\n", argv[0], filename);
-    return EXIT_FAILURE;
-  }
-
-  fclose(f);
-
-  return EXIT_SUCCESS;
-}
@@ -1,306 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-// Copyright (c) 2014 J.C. Moyer
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//! Contains definitions from `lauxlib.h`.
-
-use std::os::raw::{c_char, c_int, c_long, c_void};
-use std::ptr;
-
-use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use super::glue::LUAL_NUMSIZES;
-
-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-pub use super::compat53::{luaL_getmetafield, luaL_newmetatable, luaL_requiref, luaL_tolstring};
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-pub use super::compat53::{
-    luaL_checkstack, luaL_checkversion, luaL_getsubtable, luaL_len, luaL_loadbufferx,
-    luaL_setfuncs, luaL_setmetatable, luaL_testudata, luaL_traceback,
-};
-
-// extra error code for 'luaL_load'
-pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
-
-#[repr(C)]
-pub struct luaL_Reg {
-    pub name: *const c_char,
-    pub func: lua_CFunction,
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn luaL_checkversion(L: *mut lua_State) {
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    luaL_checkversion_(
-        L,
-        lua::LUA_VERSION_NUM as lua_Number,
-        LUAL_NUMSIZES as usize,
-    );
-    #[cfg(feature = "lua52")]
-    luaL_checkversion_(L, lua::LUA_VERSION_NUM as lua_Number);
-}
-
-extern "C" {
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number, sz: usize);
-    #[cfg(feature = "lua52")]
-    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "luaL_getmetafield"]
-    pub fn luaL_getmetafield_old(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
-
-    pub fn luaL_callmeta(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
-    pub fn luaL_argerror(L: *mut lua_State, arg: c_int, l: *const c_char) -> c_int;
-    pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
-    pub fn luaL_optlstring(
-        L: *mut lua_State,
-        arg: c_int,
-        def: *const c_char,
-        l: *mut usize,
-    ) -> *const c_char;
-    pub fn luaL_checknumber(L: *mut lua_State, arg: c_int) -> lua_Number;
-    pub fn luaL_optnumber(L: *mut lua_State, arg: c_int, def: lua_Number) -> lua_Number;
-    pub fn luaL_checkinteger(L: *mut lua_State, arg: c_int) -> lua_Integer;
-    pub fn luaL_optinteger(L: *mut lua_State, arg: c_int, def: lua_Integer) -> lua_Integer;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char);
-    pub fn luaL_checktype(L: *mut lua_State, arg: c_int, t: c_int);
-    pub fn luaL_checkany(L: *mut lua_State, arg: c_int);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_int;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "luaL_newmetatable"]
-    pub fn luaL_newmetatable_old(L: *mut lua_State, tname: *const c_char) -> c_int;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char);
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_testudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
-    pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
-
-    pub fn luaL_where(L: *mut lua_State, lvl: c_int);
-    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
-
-    // TODO: test this
-    pub fn luaL_checkoption(
-        L: *mut lua_State,
-        arg: c_int,
-        def: *const c_char,
-        lst: *const *const c_char,
-    ) -> c_int;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_fileresult(L: *mut lua_State, stat: c_int, fname: *const c_char) -> c_int;
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_execresult(L: *mut lua_State, stat: c_int) -> c_int;
-}
-
-// pre-defined references
-pub const LUA_NOREF: c_int = -2;
-pub const LUA_REFNIL: c_int = -1;
-
-extern "C" {
-    pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
-    pub fn luaL_unref(L: *mut lua_State, t: c_int, r: c_int);
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char)
-        -> c_int;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn luaL_loadfile(L: *mut lua_State, filename: *const c_char) -> c_int;
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
-    luaL_loadfilex(L, f, ptr::null())
-}
-
-extern "C" {
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_loadbufferx(
-        L: *mut lua_State,
-        buff: *const c_char,
-        sz: usize,
-        name: *const c_char,
-        mode: *const c_char,
-    ) -> c_int;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn luaL_loadbuffer(
-        L: *mut lua_State,
-        buff: *const c_char,
-        sz: usize,
-        name: *const c_char,
-    ) -> c_int;
-    pub fn luaL_loadstring(L: *mut lua_State, s: *const c_char) -> c_int;
-
-    pub fn luaL_newstate() -> *mut lua_State;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer;
-
-    // TODO (lua54): luaL_addgsub
-
-    pub fn luaL_gsub(
-        L: *mut lua_State,
-        s: *const c_char,
-        p: *const c_char,
-        r: *const c_char,
-    ) -> *const c_char;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_setfuncs(L: *mut lua_State, l: *const luaL_Reg, nup: c_int);
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_char) -> c_int;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, level: c_int);
-
-    // Skip Lua 5.2 implementation in favor of the compat53 one
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn luaL_requiref(
-        L: *mut lua_State,
-        modname: *const c_char,
-        openf: lua_CFunction,
-        glb: c_int,
-    );
-}
-
-#[inline(always)]
-#[allow(unused_variables)]
-pub unsafe fn luaL_newlibtable(L: *mut lua_State, l: *const luaL_Reg) {
-    // TODO: figure out how to pass an appropriate hint for the second param
-    // this involves correcting the second parameter's type; in C this is
-    // sizeof(l)/sizeof(l[0])
-    lua::lua_createtable(L, 0, 0)
-}
-
-#[inline(always)]
-pub unsafe fn luaL_newlib(L: *mut lua_State, l: *const luaL_Reg) {
-    luaL_checkversion(L);
-    luaL_newlibtable(L, l);
-    luaL_setfuncs(L, l, 0)
-}
-
-#[inline(always)]
-pub unsafe fn luaL_argcheck(L: *mut lua_State, cond: c_int, arg: c_int, extramsg: *const c_char) {
-    if cond == 0 {
-        luaL_argerror(L, arg, extramsg);
-    }
-}
-
-#[inline(always)]
-pub unsafe fn luaL_checkstring(L: *mut lua_State, n: c_int) -> *const c_char {
-    luaL_checklstring(L, n, ptr::null_mut())
-}
-
-#[inline(always)]
-pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *const c_char {
-    luaL_optlstring(L, n, d, ptr::null_mut())
-}
-
-// From 5.3 user manual:
-// Macros to project non-default integer types (luaL_checkint, luaL_optint,
-// luaL_checklong, luaL_optlong) were deprecated. Use their equivalent over
-// lua_Integer with a type cast (or, when possible, use lua_Integer in your
-// code).
-#[inline(always)]
-//#[deprecated]
-pub unsafe fn luaL_checkint(L: *mut lua_State, n: c_int) -> c_int {
-    luaL_checkinteger(L, n) as c_int
-}
-
-#[inline(always)]
-//#[deprecated]
-pub unsafe fn luaL_optint(L: *mut lua_State, n: c_int, d: c_int) -> c_int {
-    luaL_optinteger(L, n, d as lua_Integer) as c_int
-}
-
-#[inline(always)]
-//#[deprecated]
-pub unsafe fn luaL_checklong(L: *mut lua_State, n: c_int) -> c_long {
-    luaL_checkinteger(L, n) as c_long
-}
-
-#[inline(always)]
-//#[deprecated]
-pub unsafe fn luaL_optlong(L: *mut lua_State, n: c_int, d: c_long) -> c_long {
-    luaL_optinteger(L, n, d as lua_Integer) as c_long
-}
-
-#[inline(always)]
-pub unsafe fn luaL_typename(L: *mut lua_State, i: c_int) -> *const c_char {
-    lua::lua_typename(L, lua::lua_type(L, i))
-}
-
-#[inline(always)]
-pub unsafe fn luaL_dofile(L: *mut lua_State, filename: *const c_char) -> c_int {
-    let status = luaL_loadfile(L, filename);
-    if status == 0 {
-        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
-    } else {
-        status
-    }
-}
-
-#[inline(always)]
-pub unsafe fn luaL_dostring(L: *mut lua_State, s: *const c_char) -> c_int {
-    let status = luaL_loadstring(L, s);
-    if status == 0 {
-        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
-    } else {
-        status
-    }
-}
-
-#[inline(always)]
-pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
-    lua::lua_getfield(L, lua::LUA_REGISTRYINDEX, n);
-}
-
-// luaL_opt would be implemented here but it is undocumented, so it's omitted
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn luaL_loadbuffer(
-    L: *mut lua_State,
-    s: *const c_char,
-    sz: usize,
-    n: *const c_char,
-) -> c_int {
-    luaL_loadbufferx(L, s, sz, n, ptr::null())
-}
-
-// TODO: Add buffer API
-
-// omitted: old module system compatibility (removed in 5.4)
@@ -1,830 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-// Copyright (c) 2014 J.C. Moyer
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//! Contains definitions from `lua.h`.
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-use std::os::raw::c_uchar;
-use std::os::raw::{c_char, c_int, c_void};
-#[cfg(feature = "lua54")]
-use std::os::raw::{c_uint, c_ushort};
-use std::ptr;
-
-use super::luaconf;
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-pub use super::glue::{LUA_ENVIRONINDEX, LUA_GLOBALSINDEX};
-pub use super::glue::{LUA_REGISTRYINDEX, LUA_VERSION_NUM};
-
-#[cfg(not(feature = "luajit"))]
-pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
-#[cfg(feature = "luajit")]
-pub const LUA_SIGNATURE: &[u8] = b"\x1bLJ";
-
-// option for multiple returns in 'lua_pcall' and 'lua_call'
-pub const LUA_MULTRET: c_int = -1;
-
-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-pub use super::compat53::{
-    lua_dump, lua_getextraspace, lua_getfield, lua_geti, lua_gettable, lua_getuservalue,
-    lua_isinteger, lua_pushlstring, lua_rawget, lua_rawgeti, lua_rawgetp, lua_rotate, lua_seti,
-    lua_stringtonumber, lua_tointegerx,
-};
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-pub use super::compat53::{
-    lua_absindex, lua_arith, lua_compare, lua_copy, lua_len, lua_pushglobaltable, lua_pushstring,
-    lua_rawlen, lua_rawsetp, lua_resume as lua_resume_53, lua_setuservalue, lua_tonumberx,
-    lua_upvalueindex,
-};
-
-#[cfg(feature = "lua52")]
-pub use super::compat53::lua_getglobal;
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub fn lua_upvalueindex(i: c_int) -> c_int {
-    LUA_REGISTRYINDEX - i
-}
-
-// thread status
-pub const LUA_OK: c_int = 0;
-pub const LUA_YIELD: c_int = 1;
-pub const LUA_ERRRUN: c_int = 2;
-pub const LUA_ERRSYNTAX: c_int = 3;
-pub const LUA_ERRMEM: c_int = 4;
-#[cfg(any(feature = "lua53", feature = "lua52"))]
-pub const LUA_ERRGCMM: c_int = 5;
-#[cfg(any(feature = "lua54", feature = "lua51", feature = "luajit"))]
-pub const LUA_ERRERR: c_int = 5;
-#[cfg(any(feature = "lua53", feature = "lua52"))]
-pub const LUA_ERRERR: c_int = 6;
-
-/// A raw Lua state associated with a thread.
-pub type lua_State = c_void;
-
-// basic types
-pub const LUA_TNONE: c_int = -1;
-
-pub const LUA_TNIL: c_int = 0;
-pub const LUA_TBOOLEAN: c_int = 1;
-pub const LUA_TLIGHTUSERDATA: c_int = 2;
-pub const LUA_TNUMBER: c_int = 3;
-pub const LUA_TSTRING: c_int = 4;
-pub const LUA_TTABLE: c_int = 5;
-pub const LUA_TFUNCTION: c_int = 6;
-pub const LUA_TUSERDATA: c_int = 7;
-pub const LUA_TTHREAD: c_int = 8;
-
-#[cfg(feature = "lua54")]
-pub const LUA_NUMTYPES: c_int = 9;
-#[cfg(any(feature = "lua53", feature = "lua52"))]
-pub const LUA_NUMTAGS: c_int = 9;
-
-// minimum stack available to a C function
-pub const LUA_MINSTACK: c_int = 20;
-
-// predefined values in the registry
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub const LUA_RIDX_MAINTHREAD: lua_Integer = 1;
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub const LUA_RIDX_GLOBALS: lua_Integer = 2;
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub const LUA_RIDX_LAST: lua_Integer = LUA_RIDX_GLOBALS;
-
-// I believe `luaL_traceback` < 5.4 requires this much free stack to not error.
-// 5.4 uses `luaL_Buffer`
-pub const LUA_TRACEBACK_STACK: c_int = 11;
-
-/// A Lua number, usually equivalent to `f64`.
-pub type lua_Number = luaconf::LUA_NUMBER;
-
-/// A Lua integer, usually equivalent to `i64`.
-pub type lua_Integer = luaconf::LUA_INTEGER;
-
-/// A Lua unsigned integer, usually equivalent to `u64`.
-pub type lua_Unsigned = luaconf::LUA_UNSIGNED;
-
-// type for continuation-function contexts
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub type lua_KContext = luaconf::LUA_KCONTEXT;
-
-/// Type for native C functions that can be passed to Lua.
-pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;
-
-// Type for continuation functions
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub type lua_KFunction =
-    unsafe extern "C" fn(L: *mut lua_State, status: c_int, ctx: lua_KContext) -> c_int;
-
-// Type for functions that read/write blocks when loading/dumping Lua chunks
-pub type lua_Reader =
-    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
-pub type lua_Writer =
-    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
-
-// Type for memory-allocation functions.
-pub type lua_Alloc = unsafe extern "C" fn(
-    ud: *mut c_void,
-    ptr: *mut c_void,
-    osize: usize,
-    nsize: usize,
-) -> *mut c_void;
-
-// Type for warning functions
-#[cfg(feature = "lua54")]
-pub type lua_WarnFunction =
-    unsafe extern "C" fn(ud: *mut c_void, msg: *const c_char, tocont: c_int);
-
-extern "C" {
-    // state manipulation
-    pub fn lua_newstate(f: lua_Alloc, ud: *mut c_void) -> *mut lua_State;
-    pub fn lua_close(L: *mut lua_State);
-    pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
-
-    #[cfg(feature = "lua54")]
-    #[link_name = "lua_resetthread"]
-    pub fn lua_resetthread_54(L: *mut lua_State) -> c_int;
-    #[cfg(all(feature = "luajit", feature = "vendored"))]
-    #[link_name = "lua_resetthread"]
-    pub fn lua_resetthread_jit(L: *mut lua_State, th: *mut lua_State);
-
-    pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
-
-    #[cfg(feature = "lua54")]
-    pub fn lua_version(L: *mut lua_State) -> lua_Number;
-    #[cfg(feature = "lua53")]
-    pub fn lua_version(L: *mut lua_State) -> *const lua_Number;
-
-    // basic stack manipulation
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_absindex(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_gettop(L: *mut lua_State) -> c_int;
-    pub fn lua_settop(L: *mut lua_State, idx: c_int);
-    pub fn lua_pushvalue(L: *mut lua_State, idx: c_int);
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    pub fn lua_remove(L: *mut lua_State, idx: c_int);
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    pub fn lua_insert(L: *mut lua_State, idx: c_int);
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    pub fn lua_replace(L: *mut lua_State, idx: c_int);
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_rotate(L: *mut lua_State, idx: c_int, n: c_int);
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int);
-    pub fn lua_checkstack(L: *mut lua_State, sz: c_int) -> c_int;
-
-    pub fn lua_xmove(from: *mut lua_State, to: *mut lua_State, n: c_int);
-
-    // access functions (stack -> C)
-    pub fn lua_isnumber(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_isstring(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_iscfunction(L: *mut lua_State, idx: c_int) -> c_int;
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_isuserdata(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_type(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_typename(L: *mut lua_State, tp: c_int) -> *const c_char;
-
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_tonumber(L: *mut lua_State, idx: c_int) -> lua_Number;
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_tonumberx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Number;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_tointeger(L: *mut lua_State, idx: c_int) -> lua_Integer;
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_tointegerx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Integer;
-    pub fn lua_toboolean(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_objlen(L: *mut lua_State, idx: c_int) -> usize;
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize;
-    pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> lua_CFunction;
-    pub fn lua_touserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
-    pub fn lua_tothread(L: *mut lua_State, idx: c_int) -> *mut lua_State;
-    pub fn lua_topointer(L: *mut lua_State, idx: c_int) -> *const c_void;
-}
-
-#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
-pub unsafe fn lua_resetthread(_L: *mut lua_State, th: *mut lua_State) -> c_int {
-    #[cfg(all(feature = "luajit", feature = "vendored"))]
-    {
-        lua_resetthread_jit(_L, th);
-        LUA_OK
-    }
-    #[cfg(feature = "lua54")]
-    lua_resetthread_54(th)
-}
-
-// Comparison and arithmetic functions
-pub const LUA_OPADD: c_int = 0;
-pub const LUA_OPSUB: c_int = 1;
-pub const LUA_OPMUL: c_int = 2;
-
-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-pub const LUA_OPDIV: c_int = 3;
-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-pub const LUA_OPMOD: c_int = 4;
-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-pub const LUA_OPPOW: c_int = 5;
-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-pub const LUA_OPUNM: c_int = 6;
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPMOD: c_int = 3;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPPOW: c_int = 4;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPDIV: c_int = 5;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPIDIV: c_int = 6;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPBAND: c_int = 7;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPBOR: c_int = 8;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPBXOR: c_int = 9;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPSHL: c_int = 10;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPSHR: c_int = 11;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPUNM: c_int = 12;
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub const LUA_OPBNOT: c_int = 13;
-
-extern "C" {
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_arith(L: *mut lua_State, op: c_int);
-}
-
-pub const LUA_OPEQ: c_int = 0;
-pub const LUA_OPLT: c_int = 1;
-pub const LUA_OPLE: c_int = 2;
-
-extern "C" {
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_equal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
-    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_lessthan(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
-}
-
-// push functions (C -> stack)
-extern "C" {
-    pub fn lua_pushnil(L: *mut lua_State);
-    pub fn lua_pushnumber(L: *mut lua_State, n: lua_Number);
-    pub fn lua_pushinteger(L: *mut lua_State, n: lua_Integer);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_pushlstring(L: *mut lua_State, s: *const c_char, l: usize) -> *const c_char;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_pushlstring"]
-    pub fn lua_pushlstring_old(L: *mut lua_State, s: *const c_char, l: usize) -> *const c_char;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_pushstring(L: *mut lua_State, s: *const c_char) -> *const c_char;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_pushstring"]
-    pub fn lua_pushstring_old(L: *mut lua_State, s: *const c_char) -> *const c_char;
-
-    // TODO: omitted:
-    // lua_pushvfstring
-    pub fn lua_pushfstring(L: *mut lua_State, fmt: *const c_char, ...) -> *const c_char;
-    pub fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, n: c_int);
-    pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
-    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void);
-    pub fn lua_pushthread(L: *mut lua_State) -> c_int;
-}
-
-// get functions (Lua -> stack)
-extern "C" {
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_getglobal(L: *mut lua_State, var: *const c_char) -> c_int;
-    #[cfg(feature = "lua52")]
-    #[link_name = "lua_getglobal"]
-    pub fn lua_getglobal_old(L: *mut lua_State, var: *const c_char);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_gettable(L: *mut lua_State, idx: c_int) -> c_int;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_gettable"]
-    pub fn lua_gettable_old(L: *mut lua_State, idx: c_int);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_getfield"]
-    pub fn lua_getfield_old(L: *mut lua_State, idx: c_int, k: *const c_char);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_geti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int;
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_rawget"]
-    pub fn lua_rawget_old(L: *mut lua_State, idx: c_int);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_rawgeti"]
-    pub fn lua_rawgeti_old(L: *mut lua_State, idx: c_int, n: lua_Integer);
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int;
-    #[cfg(feature = "lua52")]
-    #[link_name = "lua_rawgetp"]
-    pub fn lua_rawgetp_old(L: *mut lua_State, idx: c_int, p: *const c_void);
-
-    pub fn lua_createtable(L: *mut lua_State, narr: c_int, nrec: c_int);
-    #[cfg(feature = "lua54")]
-    pub fn lua_newuserdatauv(L: *mut lua_State, sz: usize, nuvalue: c_int) -> *mut c_void;
-    #[cfg(any(
-        feature = "lua53",
-        feature = "lua52",
-        feature = "lua51",
-        feature = "luajit"
-    ))]
-    pub fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void;
-    pub fn lua_getmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
-
-    #[cfg(feature = "lua54")]
-    pub fn lua_getiuservalue(L: *mut lua_State, idx: c_int, n: c_int) -> c_int;
-    #[cfg(feature = "lua53")]
-    pub fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int;
-    #[cfg(feature = "lua52")]
-    #[link_name = "lua_getuservalue"]
-    pub fn lua_getuservalue_old(L: *mut lua_State, idx: c_int);
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_getfenv(L: *mut lua_State, idx: c_int);
-}
-
-#[cfg(feature = "lua54")]
-#[inline(always)]
-pub unsafe fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void {
-    lua_newuserdatauv(L, sz, 1)
-}
-
-#[cfg(feature = "lua54")]
-#[inline(always)]
-pub unsafe fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int {
-    lua_getiuservalue(L, idx, 1)
-}
-
-// set functions (stack -> Lua)
-extern "C" {
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_setglobal(L: *mut lua_State, var: *const c_char);
-    pub fn lua_settable(L: *mut lua_State, idx: c_int);
-    pub fn lua_setfield(L: *mut lua_State, idx: c_int, k: *const c_char);
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_seti(L: *mut lua_State, idx: c_int, n: lua_Integer);
-    pub fn lua_rawset(L: *mut lua_State, idx: c_int);
-    pub fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer);
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void);
-    pub fn lua_setmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
-    #[cfg(feature = "lua54")]
-    pub fn lua_setiuservalue(L: *mut lua_State, idx: c_int, n: c_int) -> c_int;
-    #[cfg(any(feature = "lua53", feature = "lua52"))]
-    pub fn lua_setuservalue(L: *mut lua_State, idx: c_int);
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_setfenv(L: *mut lua_State, idx: c_int) -> c_int;
-}
-
-#[cfg(feature = "lua54")]
-#[inline(always)]
-pub unsafe fn lua_setuservalue(L: *mut lua_State, idx: c_int) {
-    lua_setiuservalue(L, idx, 1);
-}
-
-// 'load' and 'call' functions (load and run Lua code)
-extern "C" {
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_callk(
-        L: *mut lua_State,
-        nargs: c_int,
-        nresults: c_int,
-        ctx: lua_KContext,
-        k: Option<lua_KFunction>,
-    );
-    #[cfg(feature = "lua52")]
-    pub fn lua_callk(
-        L: *mut lua_State,
-        nargs: c_int,
-        nresults: c_int,
-        ctx: c_int,
-        k: Option<lua_CFunction>,
-    );
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_pcallk(
-        L: *mut lua_State,
-        nargs: c_int,
-        nresults: c_int,
-        errfunc: c_int,
-        ctx: lua_KContext,
-        k: Option<lua_KFunction>,
-    ) -> c_int;
-    #[cfg(feature = "lua52")]
-    pub fn lua_pcallk(
-        L: *mut lua_State,
-        nargs: c_int,
-        nresults: c_int,
-        errfunc: c_int,
-        ctx: c_int,
-        k: Option<lua_CFunction>,
-    ) -> c_int;
-
-    #[cfg(feature = "lua52")]
-    pub fn lua_getctx(L: *mut lua_State, ctx: *mut c_int) -> c_int;
-
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_call(L: *mut lua_State, nargs: c_int, nresults: c_int);
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_pcall(L: *mut lua_State, nargs: c_int, nresults: c_int, errfunc: c_int) -> c_int;
-
-    // TODO
-    pub fn lua_load(
-        L: *mut lua_State,
-        reader: lua_Reader,
-        dt: *mut c_void,
-        chunkname: *const c_char,
-        mode: *const c_char,
-    ) -> c_int;
-
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_dump(
-        L: *mut lua_State,
-        writer: lua_Writer,
-        data: *mut c_void,
-        strip: c_int,
-    ) -> c_int;
-    #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_dump"]
-    pub fn lua_dump_old(L: *mut lua_State, writer: lua_Writer, data: *mut c_void) -> c_int;
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn lua_call(L: *mut lua_State, n: c_int, r: c_int) {
-    lua_callk(L, n, r, 0, None)
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_int {
-    lua_pcallk(L, n, r, f, 0, None)
-}
-
-// coroutine functions
-extern "C" {
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_yieldk(
-        L: *mut lua_State,
-        nresults: c_int,
-        ctx: lua_KContext,
-        k: Option<lua_KFunction>,
-    ) -> c_int;
-    #[cfg(feature = "lua52")]
-    pub fn lua_yieldk(
-        L: *mut lua_State,
-        nresults: c_int,
-        ctx: c_int,
-        k: Option<lua_CFunction>,
-    ) -> c_int;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    pub fn lua_yield(L: *mut lua_State, nresults: c_int) -> c_int;
-
-    #[cfg(feature = "lua54")]
-    pub fn lua_resume(
-        L: *mut lua_State,
-        from: *mut lua_State,
-        narg: c_int,
-        nres: *mut c_int,
-    ) -> c_int;
-    #[cfg(any(feature = "lua53", feature = "lua52"))]
-    #[link_name = "lua_resume"]
-    pub fn lua_resume_53(L: *mut lua_State, from: *mut lua_State, narg: c_int) -> c_int;
-    #[cfg(any(feature = "lua51", feature = "luajit"))]
-    #[link_name = "lua_resume"]
-    pub fn lua_resume_old(L: *mut lua_State, narg: c_int) -> c_int;
-
-    pub fn lua_status(L: *mut lua_State) -> c_int;
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_isyieldable(L: *mut lua_State) -> c_int;
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn lua_yield(L: *mut lua_State, n: c_int) -> c_int {
-    lua_yieldk(L, n, 0, None)
-}
-
-#[cfg(any(
-    feature = "lua53",
-    feature = "lua52",
-    feature = "lua51",
-    feature = "luajit"
-))]
-#[inline(always)]
-pub unsafe fn lua_resume(
-    L: *mut lua_State,
-    from: *mut lua_State,
-    narg: c_int,
-    nres: *mut c_int,
-) -> c_int {
-    let ret = lua_resume_53(L, from, narg);
-    if ret == LUA_OK || ret == LUA_YIELD {
-        *nres = lua_gettop(L);
-    }
-    ret
-}
-
-// warning-related functions
-#[cfg(feature = "lua54")]
-extern "C" {
-    pub fn lua_setwarnf(L: *mut lua_State, f: lua_WarnFunction, ud: *mut c_void);
-    pub fn lua_warning(L: *mut lua_State, msg: *const c_char, tocont: c_int);
-}
-
-// garbage-collection function and options
-pub const LUA_GCSTOP: c_int = 0;
-pub const LUA_GCRESTART: c_int = 1;
-pub const LUA_GCCOLLECT: c_int = 2;
-pub const LUA_GCCOUNT: c_int = 3;
-pub const LUA_GCCOUNTB: c_int = 4;
-pub const LUA_GCSTEP: c_int = 5;
-pub const LUA_GCSETPAUSE: c_int = 6;
-pub const LUA_GCSETSTEPMUL: c_int = 7;
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub const LUA_GCISRUNNING: c_int = 9;
-#[cfg(feature = "lua54")]
-pub const LUA_GCGEN: c_int = 10;
-#[cfg(feature = "lua54")]
-pub const LUA_GCINC: c_int = 11;
-
-extern "C" {
-    #[cfg(feature = "lua54")]
-    pub fn lua_gc(L: *mut lua_State, what: c_int, ...) -> c_int;
-    #[cfg(any(
-        feature = "lua53",
-        feature = "lua52",
-        feature = "lua51",
-        feature = "luajit"
-    ))]
-    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
-}
-
-// miscellaneous functions
-extern "C" {
-    pub fn lua_error(L: *mut lua_State) -> !;
-    pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
-    pub fn lua_concat(L: *mut lua_State, n: c_int);
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_len(L: *mut lua_State, idx: c_int);
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn lua_stringtonumber(L: *mut lua_State, s: *const c_char) -> usize;
-    pub fn lua_getallocf(L: *mut lua_State, ud: *mut *mut c_void) -> lua_Alloc;
-    pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut c_void);
-    #[cfg(feature = "lua54")]
-    pub fn lua_toclose(L: *mut lua_State, idx: c_int);
-}
-
-// some useful macros
-// here, implemented as Rust functions
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-#[inline(always)]
-pub unsafe fn lua_getextraspace(L: *mut lua_State) -> *mut c_void {
-    L.offset(-super::glue::LUA_EXTRASPACE as isize) as *mut c_void
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn lua_tonumber(L: *mut lua_State, i: c_int) -> lua_Number {
-    lua_tonumberx(L, i, ptr::null_mut())
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn lua_tointeger(L: *mut lua_State, i: c_int) -> lua_Integer {
-    lua_tointegerx(L, i, ptr::null_mut())
-}
-
-#[inline(always)]
-pub unsafe fn lua_pop(L: *mut lua_State, n: c_int) {
-    lua_settop(L, -n - 1)
-}
-
-#[inline(always)]
-pub unsafe fn lua_newtable(L: *mut lua_State) {
-    lua_createtable(L, 0, 0)
-}
-
-#[inline(always)]
-pub unsafe fn lua_register(L: *mut lua_State, n: *const c_char, f: lua_CFunction) {
-    lua_pushcfunction(L, f);
-    lua_setglobal(L, n)
-}
-
-#[inline(always)]
-pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
-    lua_pushcclosure(L, f, 0)
-}
-
-#[inline(always)]
-pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) == LUA_TFUNCTION) as c_int
-}
-
-#[inline(always)]
-pub unsafe fn lua_istable(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) == LUA_TTABLE) as c_int
-}
-
-#[inline(always)]
-pub unsafe fn lua_islightuserdata(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) == LUA_TLIGHTUSERDATA) as c_int
-}
-
-#[inline(always)]
-pub unsafe fn lua_isnil(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) == LUA_TNIL) as c_int
-}
-
-#[inline(always)]
-pub unsafe fn lua_isboolean(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) == LUA_TBOOLEAN) as c_int
-}
-
-#[inline(always)]
-pub unsafe fn lua_isthread(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) == LUA_TTHREAD) as c_int
-}
-
-#[inline(always)]
-pub unsafe fn lua_isnone(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) == LUA_TNONE) as c_int
-}
-
-#[inline(always)]
-pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
-    (lua_type(L, n) <= 0) as c_int
-}
-
-#[inline(always)]
-pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) -> *const c_char {
-    use std::ffi::CString;
-    let c_str = CString::new(s).unwrap();
-    lua_pushlstring(L, c_str.as_ptr(), c_str.as_bytes().len())
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[inline(always)]
-pub unsafe fn lua_setglobal(L: *mut lua_State, var: *const c_char) {
-    lua_setfield(L, LUA_GLOBALSINDEX, var)
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[inline(always)]
-pub unsafe fn lua_getglobal(L: *mut lua_State, var: *const c_char) -> c_int {
-    lua_getfield(L, LUA_GLOBALSINDEX, var)
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[inline(always)]
-pub unsafe fn lua_pushglobaltable(L: *mut lua_State) -> c_int {
-    lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
-}
-
-#[inline(always)]
-pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
-    lua_tolstring(L, i, ptr::null_mut())
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-#[inline(always)]
-pub unsafe fn lua_insert(L: *mut lua_State, idx: c_int) {
-    lua_rotate(L, idx, 1)
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-#[inline(always)]
-pub unsafe fn lua_remove(L: *mut lua_State, idx: c_int) {
-    lua_rotate(L, idx, -1);
-    lua_pop(L, 1)
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-#[inline(always)]
-pub unsafe fn lua_replace(L: *mut lua_State, idx: c_int) {
-    lua_copy(L, -1, idx);
-    lua_pop(L, 1)
-}
-
-// Debug API
-// Event codes
-pub const LUA_HOOKCALL: c_int = 0;
-pub const LUA_HOOKRET: c_int = 1;
-pub const LUA_HOOKLINE: c_int = 2;
-pub const LUA_HOOKCOUNT: c_int = 3;
-pub const LUA_HOOKTAILCALL: c_int = 4;
-
-// Event masks
-pub const LUA_MASKCALL: c_int = 1 << (LUA_HOOKCALL as usize);
-pub const LUA_MASKRET: c_int = 1 << (LUA_HOOKRET as usize);
-pub const LUA_MASKLINE: c_int = 1 << (LUA_HOOKLINE as usize);
-pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
-
-/// Type for functions to be called on debug events.
-pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
-
-extern "C" {
-    pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
-    pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
-    pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
-    pub fn lua_setlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
-    pub fn lua_getupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
-    pub fn lua_setupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
-
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_upvalueid(L: *mut lua_State, fidx: c_int, n: c_int) -> *mut c_void;
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn lua_upvaluejoin(L: *mut lua_State, fidx1: c_int, n1: c_int, fidx2: c_int, n2: c_int);
-
-    pub fn lua_sethook(L: *mut lua_State, func: Option<lua_Hook>, mask: c_int, count: c_int);
-    pub fn lua_gethook(L: *mut lua_State) -> Option<lua_Hook>;
-    pub fn lua_gethookmask(L: *mut lua_State) -> c_int;
-    pub fn lua_gethookcount(L: *mut lua_State) -> c_int;
-
-    #[cfg(feature = "lua54")]
-    pub fn lua_setcstacklimit(L: *mut lua_State, limit: c_uint) -> c_int;
-}
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-#[repr(C)]
-pub struct lua_Debug {
-    pub event: c_int,
-    pub name: *const c_char,
-    pub namewhat: *const c_char,
-    pub what: *const c_char,
-    pub source: *const c_char,
-    #[cfg(feature = "lua54")]
-    pub srclen: usize,
-    pub currentline: c_int,
-    pub linedefined: c_int,
-    pub lastlinedefined: c_int,
-    pub nups: c_uchar,
-    pub nparams: c_uchar,
-    pub isvararg: c_char,
-    pub istailcall: c_char,
-    #[cfg(feature = "lua54")]
-    pub ftransfer: c_ushort,
-    #[cfg(feature = "lua54")]
-    pub ntransfer: c_ushort,
-    pub short_src: [c_char; luaconf::LUA_IDSIZE as usize],
-    // lua.h mentions this is for private use
-    i_ci: *mut c_void,
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[repr(C)]
-pub struct lua_Debug {
-    pub event: c_int,
-    pub name: *const c_char,
-    pub namewhat: *const c_char,
-    pub what: *const c_char,
-    pub source: *const c_char,
-    pub currentline: c_int,
-    pub nups: c_int,
-    pub linedefined: c_int,
-    pub lastlinedefined: c_int,
-    pub short_src: [c_char; luaconf::LUA_IDSIZE as usize],
-    // lua.h mentions this is for private use
-    i_ci: c_int,
-}
@@ -1,69 +1,16 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
+//! MLua compatibility layer for Lua 5.1/JIT
+//!
+//! Based on github.com/keplerproject/lua-compat-5.3

-// Based on github.com/keplerproject/lua-compat-5.3
-
-#![allow(clippy::needless_return)]
-
-use std::ffi::CStr;
+use std::convert::TryInto;
 use std::mem;
 use std::os::raw::{c_char, c_int, c_void};
 use std::ptr;

-use super::lauxlib::{
-    luaL_callmeta, luaL_error, luaL_getmetafield_old, luaL_loadbuffer, luaL_newmetatable_old,
-};
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-use super::lauxlib::{luaL_Reg, luaL_checktype, luaL_getmetatable};
-
-#[cfg(feature = "lua52")]
-use super::lauxlib::{luaL_checkstack, luaL_getsubtable};
-
-use super::lua::{
-    self, lua_CFunction, lua_Debug, lua_Integer, lua_Number, lua_State, lua_Writer, lua_call,
-    lua_createtable, lua_dump_old, lua_error, lua_getfield_old, lua_getstack, lua_gettable_old,
-    lua_gettop, lua_insert, lua_isstring, lua_istable, lua_newuserdata, lua_pop, lua_pushboolean,
-    lua_pushcfunction, lua_pushfstring, lua_pushinteger, lua_pushliteral, lua_pushlstring_old,
-    lua_pushnil, lua_pushnumber, lua_pushthread, lua_pushvalue, lua_rawget_old, lua_rawgeti_old,
-    lua_rawset, lua_replace, lua_setfield, lua_setglobal, lua_setmetatable, lua_settable,
-    lua_toboolean, lua_tointeger, lua_tolstring, lua_tonumber, lua_topointer, lua_tostring,
-    lua_touserdata, lua_type, lua_typename,
-};
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-use super::lua::{
-    lua_checkstack, lua_concat, lua_equal, lua_getfenv, lua_getinfo, lua_getmetatable,
-    lua_isnumber, lua_lessthan, lua_newtable, lua_next, lua_objlen, lua_pushcclosure,
-    lua_pushlightuserdata, lua_pushstring_old, lua_rawequal, lua_remove, lua_resume_old,
-    lua_setfenv, lua_settop, LUA_OPADD, LUA_OPUNM,
-};
-
-#[cfg(feature = "lua52")]
-use super::lua::{
-    lua_absindex, lua_getglobal_old, lua_getuservalue_old, lua_pushstring, lua_rawgetp_old,
-    lua_rawsetp, lua_tonumberx,
-};
+use super::lauxlib::*;
+use super::lua::*;

+#[inline(always)]
 unsafe fn compat53_reverse(L: *mut lua_State, mut a: c_int, mut b: c_int) {
    while a < b {
        lua_pushvalue(L, a);
@@ -125,10 +72,9 @@ unsafe fn compat53_checkmode(
        );
        return err;
    }
-    lua::LUA_OK
+    LUA_OK
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
 unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) -> c_int {
    if level == 0 || lua_istable(L, -1) == 0 {
        return 0; // not found
@@ -137,7 +83,7 @@ unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) ->
    lua_pushnil(L); // start 'next' loop
    while lua_next(L, -2) != 0 {
        // for each pair in table
-        if lua_type(L, -2) == lua::LUA_TSTRING {
+        if lua_type(L, -2) == LUA_TSTRING {
            // ignore non-string keys
            if lua_rawequal(L, objidx, -1) != 0 {
                // found object?
@@ -154,25 +100,23 @@ unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) ->
        }
        lua_pop(L, 1); // remove value
    }
-    return 0; // not found
+    0 // not found
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
 unsafe fn compat53_pushglobalfuncname(L: *mut lua_State, ar: *mut lua_Debug) -> c_int {
    let top = lua_gettop(L);
    lua_getinfo(L, cstr!("f"), ar); // push function
-    lua_pushvalue(L, lua::LUA_GLOBALSINDEX);
+    lua_pushvalue(L, LUA_GLOBALSINDEX);
    if compat53_findfield(L, top + 1, 2) != 0 {
        lua_copy(L, -1, top + 1); // move name to proper place
        lua_pop(L, 2); // remove pushed values
-        return 1;
+        1
    } else {
        lua_settop(L, top); // remove function and global table
-        return 0;
+        0
    }
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
 unsafe fn compat53_pushfuncname(L: *mut lua_State, ar: *mut lua_Debug) {
    if *(*ar).namewhat != b'\0' as c_char {
        // is there a name?
@@ -197,73 +141,18 @@ unsafe fn compat53_pushfuncname(L: *mut lua_State, ar: *mut lua_Debug) {
    }
 }

-unsafe fn compat53_call_lua(L: *mut lua_State, code: &str, nargs: c_int, nret: c_int) {
-    lua_rawgetp(L, lua::LUA_REGISTRYINDEX, code.as_ptr() as *const c_void);
-    if lua_type(L, -1) != lua::LUA_TFUNCTION {
-        lua_pop(L, 1);
-        if luaL_loadbuffer(
-            L,
-            code.as_ptr() as *const c_char,
-            code.as_bytes().len(),
-            cstr!("=none"),
-        ) != 0
-        {
-            lua_error(L);
-        }
-        lua_pushvalue(L, -1);
-        lua_rawsetp(L, lua::LUA_REGISTRYINDEX, code.as_ptr() as *const c_void);
-    }
-    lua_insert(L, -nargs - 1);
-    lua_call(L, nargs, nret);
-}
-
 //
 // lua ported functions
 //

-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[inline(always)]
-pub fn lua_upvalueindex(i: c_int) -> c_int {
-    lua::LUA_GLOBALSINDEX - i
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_absindex(L: *mut lua_State, mut idx: c_int) -> c_int {
-    if idx < 0 && idx > lua::LUA_REGISTRYINDEX {
+    if idx < 0 && idx > LUA_REGISTRYINDEX {
        idx += lua_gettop(L) + 1;
    }
    idx
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
-static COMPAT53_ARITH_CODE: &str = r#"
-local op,a,b=...
-if op == 0 then return a+b
-elseif op == 1 then return a-b
-elseif op == 2 then return a*b
-elseif op == 3 then return a/b
-elseif op == 4 then return a%b
-elseif op == 5 then return a^b
-elseif op == 6 then return -a
-end
-"#;
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-pub unsafe fn lua_arith(L: *mut lua_State, op: c_int) {
-    #[allow(clippy::manual_range_contains)]
-    if op < LUA_OPADD || op > LUA_OPUNM {
-        luaL_error(L, cstr!("invalid 'op' argument for lua_arith"));
-    }
-    luaL_checkstack(L, 5, cstr!("not enough stack slots"));
-    if op == LUA_OPUNM {
-        lua_pushvalue(L, -1);
-    }
-    lua_pushnumber(L, op as lua_Number);
-    lua_insert(L, -3);
-    compat53_call_lua(L, COMPAT53_ARITH_CODE, 3, 1);
-}
-
 pub unsafe fn lua_rotate(L: *mut lua_State, mut idx: c_int, mut n: c_int) {
    idx = lua_absindex(L, idx);
    let n_elems = lua_gettop(L) - idx + 1;
@@ -279,7 +168,6 @@ pub unsafe fn lua_rotate(L: *mut lua_State, mut idx: c_int, mut n: c_int) {
    }
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int) {
    let abs_to = lua_absindex(L, toidx);
@@ -290,32 +178,30 @@ pub unsafe fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int) {

 #[inline(always)]
 pub unsafe fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int {
-    if lua_type(L, idx) == lua::LUA_TNUMBER {
+    if lua_type(L, idx) == LUA_TNUMBER {
        let n = lua_tonumber(L, idx);
        let i = lua_tointeger(L, idx);
        if (n - i as lua_Number).abs() < lua_Number::EPSILON {
            return 1;
        }
    }
-    return 0;
+    0
+}
+
+#[inline(always)]
+pub unsafe fn lua_tointeger(L: *mut lua_State, i: c_int) -> lua_Integer {
+    lua_tointegerx(L, i, ptr::null_mut())
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_tonumberx(L: *mut lua_State, i: c_int, isnum: *mut c_int) -> lua_Number {
    let n = lua_tonumber(L, i);
    if !isnum.is_null() {
-        *isnum = if n != 0.0 || lua_isnumber(L, i) != 0 {
-            1
-        } else {
-            0
-        };
+        *isnum = (n != 0.0 || lua_isnumber(L, i) != 0) as c_int;
    }
-    return n;
+    n
 }

-// Implemented for Lua 5.2 as well
-// See https://github.com/keplerproject/lua-compat-5.3/issues/40
 #[inline(always)]
 pub unsafe fn lua_tointegerx(L: *mut lua_State, i: c_int, isnum: *mut c_int) -> lua_Integer {
    let mut ok = 0;
@@ -330,80 +216,45 @@ pub unsafe fn lua_tointegerx(L: *mut lua_State, i: c_int, isnum: *mut c_int) ->
    if !isnum.is_null() {
        *isnum = 0;
    }
-    return 0;
+    0
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize {
    lua_objlen(L, idx)
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[inline(always)]
-pub unsafe fn lua_compare(L: *mut lua_State, mut idx1: c_int, mut idx2: c_int, op: c_int) -> c_int {
-    match op {
-        lua::LUA_OPEQ => lua_equal(L, idx1, idx2),
-        lua::LUA_OPLT => lua_lessthan(L, idx1, idx2),
-        lua::LUA_OPLE => {
-            luaL_checkstack(L, 5, cstr!("not enough stack slots"));
-            idx1 = lua_absindex(L, idx1);
-            idx2 = lua_absindex(L, idx2);
-            lua_pushvalue(L, idx1);
-            lua_pushvalue(L, idx2);
-            compat53_call_lua(L, "local a,b=...\nreturn a<=b\n", 2, 1);
-            let result = lua_toboolean(L, -1);
-            lua_pop(L, 1);
-            result
-        }
-        _ => luaL_error(L, cstr!("invalid 'op' argument for lua_compare")),
-    }
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_pushlstring(L: *mut lua_State, s: *const c_char, l: usize) -> *const c_char {
    if l == 0 {
-        lua_pushlstring_old(L, cstr!(""), 0);
+        lua_pushlstring_(L, cstr!(""), 0);
    } else {
-        lua_pushlstring_old(L, s, l);
+        lua_pushlstring_(L, s, l);
    }
    lua_tostring(L, -1)
 }

-#[cfg(feature = "lua52")]
-#[inline(always)]
-pub unsafe fn lua_pushlstring(L: *mut lua_State, s: *const c_char, l: usize) -> *const c_char {
-    if l == 0 {
-        lua_pushlstring_old(L, cstr!(""), 0)
-    } else {
-        lua_pushlstring_old(L, s, l)
-    }
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_pushstring(L: *mut lua_State, s: *const c_char) -> *const c_char {
-    lua_pushstring_old(L, s);
+    lua_pushstring_(L, s);
    lua_tostring(L, -1)
 }

-#[cfg(feature = "lua52")]
 #[inline(always)]
 pub unsafe fn lua_getglobal(L: *mut lua_State, var: *const c_char) -> c_int {
-    lua_getglobal_old(L, var);
+    lua_getglobal_(L, var);
    lua_type(L, -1)
 }

 #[inline(always)]
 pub unsafe fn lua_gettable(L: *mut lua_State, idx: c_int) -> c_int {
-    lua_gettable_old(L, idx);
+    lua_gettable_(L, idx);
    lua_type(L, -1)
 }

 #[inline(always)]
 pub unsafe fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int {
-    lua_getfield_old(L, idx, k);
+    lua_getfield_(L, idx, k);
    lua_type(L, -1)
 }

@@ -411,54 +262,35 @@ pub unsafe fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c
 pub unsafe fn lua_geti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) -> c_int {
    idx = lua_absindex(L, idx);
    lua_pushinteger(L, n);
-    lua_gettable(L, idx);
-    lua_type(L, -1)
+    lua_gettable(L, idx)
 }

-// A new version which returns c_int
 #[inline(always)]
 pub unsafe fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int {
-    lua_rawget_old(L, idx);
+    lua_rawget_(L, idx);
    lua_type(L, -1)
 }

-// A new version which returns c_int
 #[inline(always)]
 pub unsafe fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int {
-    lua_rawgeti_old(L, idx, n);
+    let n = n.try_into().expect("cannot convert index to lua_Integer");
+    lua_rawgeti_(L, idx, n);
    lua_type(L, -1)
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int {
    let abs_i = lua_absindex(L, idx);
    lua_pushlightuserdata(L, p as *mut c_void);
-    lua_rawget(L, abs_i);
-    lua_type(L, -1)
+    lua_rawget(L, abs_i)
 }

-#[cfg(feature = "lua52")]
-#[inline(always)]
-pub unsafe fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int {
-    lua_rawgetp_old(L, idx, p);
-    lua_type(L, -1)
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int {
    lua_getfenv(L, idx);
    lua_type(L, -1)
 }

-#[cfg(feature = "lua52")]
-#[inline(always)]
-pub unsafe fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int {
-    lua_getuservalue_old(L, idx);
-    lua_type(L, -1)
-}
-
 #[inline(always)]
 pub unsafe fn lua_seti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) {
    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
@@ -468,7 +300,12 @@ pub unsafe fn lua_seti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) {
    lua_settable(L, idx);
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
+#[inline(always)]
+pub unsafe fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer) {
+    let n = n.try_into().expect("cannot convert index from lua_Integer");
+    lua_rawseti_(L, idx, n)
+}
+
 #[inline(always)]
 pub unsafe fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void) {
    let abs_i = lua_absindex(L, idx);
@@ -478,10 +315,9 @@ pub unsafe fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void) {
    lua_rawset(L, abs_i);
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_setuservalue(L: *mut lua_State, idx: c_int) {
-    luaL_checktype(L, -1, lua::LUA_TTABLE);
+    luaL_checktype(L, -1, LUA_TTABLE);
    lua_setfenv(L, idx);
 }

@@ -492,28 +328,21 @@ pub unsafe fn lua_dump(
    data: *mut c_void,
    _strip: c_int,
 ) -> c_int {
-    lua_dump_old(L, writer, data)
+    lua_dump_(L, writer, data)
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[inline(always)]
-pub unsafe fn lua_resume(L: *mut lua_State, _from: *mut lua_State, narg: c_int) -> c_int {
-    lua_resume_old(L, narg)
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_len(L: *mut lua_State, idx: c_int) {
    match lua_type(L, idx) {
-        lua::LUA_TSTRING => {
+        LUA_TSTRING => {
            lua_pushnumber(L, lua_objlen(L, idx) as lua_Number);
        }
-        lua::LUA_TTABLE => {
+        LUA_TTABLE => {
            if luaL_callmeta(L, idx, cstr!("__len")) == 0 {
                lua_pushnumber(L, lua_objlen(L, idx) as lua_Number);
            }
        }
-        lua::LUA_TUSERDATA if luaL_callmeta(L, idx, cstr!("__len")) != 0 => {}
+        LUA_TUSERDATA if luaL_callmeta(L, idx, cstr!("__len")) != 0 => {}
        _ => {
            luaL_error(
                L,
@@ -524,88 +353,32 @@ pub unsafe fn lua_len(L: *mut lua_State, idx: c_int) {
    }
 }

-#[inline(always)]
-pub unsafe fn lua_stringtonumber(L: *mut lua_State, s: *const c_char) -> usize {
-    use std::str::FromStr;
-
-    let cs = CStr::from_ptr(s);
-    if let Ok(rs) = cs.to_str() {
-        if let Ok(n) = f64::from_str(rs.trim()) {
-            lua_pushnumber(L, n as lua_Number);
-            return cs.to_bytes_with_nul().len();
-        }
-    }
-    0
-}
-
-#[allow(clippy::branches_sharing_code)]
-pub unsafe fn lua_getextraspace(L: *mut lua_State) -> *mut c_void {
-    use super::glue::LUA_EXTRASPACE;
-
-    luaL_checkstack(L, 4, cstr!("not enough stack slots available"));
-    lua_pushliteral(L, "__compat53_extraspace");
-    lua_pushvalue(L, -1);
-    lua_rawget(L, lua::LUA_REGISTRYINDEX);
-    if lua_istable(L, -1) == 0 {
-        lua_pop(L, 1);
-        lua_createtable(L, 0, 2);
-        lua_createtable(L, 0, 1);
-        lua_pushliteral(L, "k");
-        lua_setfield(L, -2, cstr!("__mode"));
-        lua_setmetatable(L, -2);
-        lua_pushvalue(L, -2);
-        lua_pushvalue(L, -2);
-        lua_rawset(L, lua::LUA_REGISTRYINDEX);
-    }
-    lua_replace(L, -2);
-    let is_main = lua_pushthread(L);
-    lua_rawget(L, -2);
-    let mut _ptr = lua_touserdata(L, -1);
-    if _ptr.is_null() {
-        lua_pop(L, 1);
-        _ptr = lua_newuserdata(L, LUA_EXTRASPACE as usize);
-        if is_main != 0 {
-            // mem::size_of::<c_void>() == 1
-            ptr::write_bytes(_ptr, 0, LUA_EXTRASPACE as usize);
-            lua_pushthread(L);
-            lua_pushvalue(L, -2);
-            lua_rawset(L, -4);
-            lua_pushboolean(L, 1);
-            lua_pushvalue(L, -2);
-            lua_rawset(L, -4);
-        } else {
-            lua_pushboolean(L, 1);
-            lua_rawget(L, -3);
-            let mptr = lua_touserdata(L, -1);
-            if !mptr.is_null() {
-                ptr::copy_nonoverlapping(mptr, _ptr, LUA_EXTRASPACE as usize)
-            } else {
-                ptr::write_bytes(_ptr, 0, LUA_EXTRASPACE as usize);
-            }
-            lua_pop(L, 1);
-            lua_pushthread(L);
-            lua_pushvalue(L, -2);
-            lua_rawset(L, -4);
-        }
-    }
-    lua_pop(L, 2);
-    return _ptr;
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn lua_pushglobaltable(L: *mut lua_State) {
-    lua_pushvalue(L, lua::LUA_GLOBALSINDEX);
+    lua_pushvalue(L, LUA_GLOBALSINDEX);
+}
+
+#[inline(always)]
+pub unsafe fn lua_resume(
+    L: *mut lua_State,
+    _from: *mut lua_State,
+    narg: c_int,
+    nres: *mut c_int,
+) -> c_int {
+    let ret = lua_resume_(L, narg);
+    if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
+        *nres = lua_gettop(L);
+    }
+    ret
 }

 //
 // lauxlib ported functions
 //

-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char) {
-    if lua_checkstack(L, sz + lua::LUA_MINSTACK) == 0 {
+    if lua_checkstack(L, sz + LUA_MINSTACK) == 0 {
        if !msg.is_null() {
            luaL_error(L, cstr!("stack overflow (%s)"), msg);
        } else {
@@ -615,23 +388,19 @@ pub unsafe fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char)
    }
 }

-pub unsafe fn luaL_checkversion(_L: *mut lua_State) {
-    // Void
-}
-
 #[inline(always)]
 pub unsafe fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int {
-    if luaL_getmetafield_old(L, obj, e) != 0 {
+    if luaL_getmetafield_(L, obj, e) != 0 {
        lua_type(L, -1)
    } else {
-        lua::LUA_TNIL
+        LUA_TNIL
    }
 }

 #[inline(always)]
 pub unsafe fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_int {
-    if luaL_newmetatable_old(L, tname) != 0 {
-        lua_pushstring(L, tname);
+    if luaL_newmetatable_(L, tname) != 0 {
+        lua_pushstring_(L, tname);
        lua_setfield(L, -2, cstr!("__name"));
        1
    } else {
@@ -639,7 +408,6 @@ pub unsafe fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_in
    }
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn luaL_loadbufferx(
    L: *mut lua_State,
@@ -648,32 +416,30 @@ pub unsafe fn luaL_loadbufferx(
    name: *const c_char,
    mode: *const c_char,
 ) -> c_int {
-    let status = if sz > 0 && *buff as u8 == lua::LUA_SIGNATURE[0] {
-        compat53_checkmode(L, mode, cstr!("binary"), lua::LUA_ERRSYNTAX)
+    let status = if sz > 0 && *buff as u8 == LUA_SIGNATURE[0] {
+        compat53_checkmode(L, mode, cstr!("binary"), LUA_ERRSYNTAX)
    } else {
-        compat53_checkmode(L, mode, cstr!("text"), lua::LUA_ERRSYNTAX)
+        compat53_checkmode(L, mode, cstr!("text"), LUA_ERRSYNTAX)
    };
-    if status != lua::LUA_OK {
+    if status != LUA_OK {
        return status;
    }
    luaL_loadbuffer(L, buff, sz, name)
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer {
    let mut isnum = 0;
    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
    lua_len(L, idx);
    let res = lua_tointegerx(L, -1, &mut isnum);
-    lua::lua_pop(L, 1);
+    lua_pop(L, 1);
    if isnum == 0 {
        luaL_error(L, cstr!("object length is not an integer"));
    }
    res
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
 pub unsafe fn luaL_traceback(
    L: *mut lua_State,
    L1: *mut lua_State,
@@ -717,13 +483,13 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
    if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
        let t = lua_type(L, idx);
        match t {
-            lua::LUA_TNIL => {
+            LUA_TNIL => {
                lua_pushliteral(L, "nil");
            }
-            lua::LUA_TSTRING | lua::LUA_TNUMBER => {
+            LUA_TSTRING | LUA_TNUMBER => {
                lua_pushvalue(L, idx);
            }
-            lua::LUA_TBOOLEAN => {
+            LUA_TBOOLEAN => {
                if lua_toboolean(L, idx) == 0 {
                    lua_pushliteral(L, "false");
                } else {
@@ -732,13 +498,13 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
            }
            _ => {
                let tt = luaL_getmetafield(L, idx, cstr!("__name"));
-                let name = if tt == lua::LUA_TSTRING {
+                let name = if tt == LUA_TSTRING {
                    lua_tostring(L, -1)
                } else {
                    lua_typename(L, t)
                };
                lua_pushfstring(L, cstr!("%s: %p"), name, lua_topointer(L, idx));
-                if tt != lua::LUA_TNIL {
+                if tt != LUA_TNIL {
                    lua_replace(L, -2);
                }
            }
@@ -749,7 +515,6 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
    lua_tolstring(L, -1, len)
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
 #[inline(always)]
 pub unsafe fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char) {
    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
@@ -757,57 +522,19 @@ pub unsafe fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char) {
    lua_setmetatable(L, -2);
 }

-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[inline(always)]
-pub unsafe fn luaL_testudata(L: *mut lua_State, i: c_int, tname: *const c_char) -> *mut c_void {
-    let mut p = lua_touserdata(L, i);
-    luaL_checkstack(L, 2, cstr!("not enough stack slots"));
-    if p.is_null() || lua_getmetatable(L, i) == 0 {
-        return ptr::null_mut();
-    } else {
-        luaL_getmetatable(L, tname);
-        let res = lua_rawequal(L, -1, -2);
-        lua_pop(L, 2);
-        if res == 0 {
-            p = ptr::null_mut();
-        }
-    }
-    return p;
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-#[inline(always)]
-pub unsafe fn luaL_setfuncs(L: *mut lua_State, mut l: *const luaL_Reg, nup: c_int) {
-    luaL_checkstack(L, nup + 1, cstr!("too many upvalues"));
-    while !(*l).name.is_null() {
-        // fill the table with given functions
-        l = l.offset(1);
-        lua_pushstring(L, (*l).name);
-        for _ in 0..nup {
-            // copy upvalues to the top
-            lua_pushvalue(L, -(nup + 1));
-        }
-        lua_pushcclosure(L, (*l).func, nup); // closure with those upvalues
-        lua_settable(L, -(nup + 3)); // table must be below the upvalues, the name and the closure
-    }
-    lua_pop(L, nup); // remove upvalues
-}
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
 pub unsafe fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_char) -> c_int {
    let abs_i = lua_absindex(L, idx);
    luaL_checkstack(L, 3, cstr!("not enough stack slots"));
-    lua_pushstring(L, fname);
-    lua_gettable(L, abs_i);
-    if lua_istable(L, -1) != 0 {
+    lua_pushstring_(L, fname);
+    if lua_gettable(L, abs_i) == LUA_TTABLE {
        return 1;
    }
    lua_pop(L, 1);
    lua_newtable(L);
-    lua_pushstring(L, fname);
+    lua_pushstring_(L, fname);
    lua_pushvalue(L, -2);
    lua_settable(L, abs_i);
-    return 0;
+    0
 }

 pub unsafe fn luaL_requiref(
@@ -817,12 +544,12 @@ pub unsafe fn luaL_requiref(
    glb: c_int,
 ) {
    luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
-    luaL_getsubtable(L, lua::LUA_REGISTRYINDEX, cstr!("_LOADED"));
-    if lua_getfield(L, -1, modname) == lua::LUA_TNIL {
+    luaL_getsubtable(L, LUA_REGISTRYINDEX, cstr!("_LOADED"));
+    if lua_getfield(L, -1, modname) == LUA_TNIL {
        lua_pop(L, 1);
        lua_pushcfunction(L, openf);
        lua_pushstring(L, modname);
-        #[cfg(any(feature = "lua52", feature = "lua51"))]
+        #[cfg(feature = "lua51")]
        {
            lua_call(L, 1, 1);
            lua_pushvalue(L, -1);
@@ -834,7 +561,7 @@ pub unsafe fn luaL_requiref(
            lua_getfield(L, -1, modname);
        }
    }
-    if cfg!(any(feature = "lua52", feature = "lua51")) && glb != 0 {
+    if cfg!(feature = "lua51") && glb != 0 {
        lua_pushvalue(L, -1);
        lua_setglobal(L, modname);
    }
@@ -0,0 +1,145 @@
+//! Contains definitions from `lauxlib.h`.
+
+use std::os::raw::{c_char, c_int, c_void};
+use std::ptr;
+
+use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
+
+// Extra error code for 'luaL_load'
+pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
+
+#[repr(C)]
+pub struct luaL_Reg {
+    pub name: *const c_char,
+    pub func: lua_CFunction,
+}
+
+extern "C" {
+    pub fn luaL_register(L: *mut lua_State, libname: *const c_char, l: *const luaL_Reg);
+    #[link_name = "luaL_getmetafield"]
+    pub fn luaL_getmetafield_(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    pub fn luaL_callmeta(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    pub fn luaL_typerror(L: *mut lua_State, narg: c_int, tname: *const c_char) -> c_int;
+    pub fn luaL_argerror(L: *mut lua_State, narg: c_int, extramsg: *const c_char) -> c_int;
+    pub fn luaL_checklstring(L: *mut lua_State, narg: c_int, l: *mut usize) -> *const c_char;
+    pub fn luaL_optlstring(
+        L: *mut lua_State,
+        narg: c_int,
+        def: *const c_char,
+        l: *mut usize,
+    ) -> *const c_char;
+    pub fn luaL_checknumber(L: *mut lua_State, narg: c_int) -> lua_Number;
+    pub fn luaL_optnumber(L: *mut lua_State, narg: c_int, def: lua_Number) -> lua_Number;
+    pub fn luaL_checkinteger(L: *mut lua_State, narg: c_int) -> lua_Integer;
+    pub fn luaL_optinteger(L: *mut lua_State, narg: c_int, def: lua_Integer) -> lua_Integer;
+    #[link_name = "luaL_checkstack"]
+    pub fn luaL_checkstack_(L: *mut lua_State, sz: c_int, msg: *const c_char);
+    pub fn luaL_checktype(L: *mut lua_State, narg: c_int, t: c_int);
+    pub fn luaL_checkany(L: *mut lua_State, narg: c_int);
+
+    #[link_name = "luaL_newmetatable"]
+    pub fn luaL_newmetatable_(L: *mut lua_State, tname: *const c_char) -> c_int;
+    pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
+
+    pub fn luaL_where(L: *mut lua_State, lvl: c_int);
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
+
+    pub fn luaL_checkoption(
+        L: *mut lua_State,
+        narg: c_int,
+        def: *const c_char,
+        lst: *const *const c_char,
+    ) -> c_int;
+}
+
+// Pre-defined references
+pub const LUA_NOREF: c_int = -2;
+pub const LUA_REFNIL: c_int = -1;
+
+extern "C" {
+    pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
+    pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
+
+    pub fn luaL_loadfile(L: *mut lua_State, filename: *const c_char) -> c_int;
+    pub fn luaL_loadbuffer(
+        L: *mut lua_State,
+        buff: *const c_char,
+        sz: usize,
+        name: *const c_char,
+    ) -> c_int;
+    pub fn luaL_loadstring(L: *mut lua_State, s: *const c_char) -> c_int;
+
+    pub fn luaL_newstate() -> *mut lua_State;
+
+    pub fn luaL_gsub(
+        L: *mut lua_State,
+        s: *const c_char,
+        p: *const c_char,
+        r: *const c_char,
+    ) -> *const c_char;
+
+    pub fn luaL_findtable(
+        L: *mut lua_State,
+        idx: c_int,
+        fname: *const c_char,
+        szhint: c_int,
+    ) -> *const c_char;
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+
+#[inline(always)]
+pub unsafe fn luaL_argcheck(L: *mut lua_State, cond: c_int, narg: c_int, extramsg: *const c_char) {
+    if cond == 0 {
+        luaL_argerror(L, narg, extramsg);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_checkstring(L: *mut lua_State, n: c_int) -> *const c_char {
+    luaL_checklstring(L, n, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *const c_char {
+    luaL_optlstring(L, n, d, ptr::null_mut())
+}
+
+// Deprecated from 5.3: luaL_checkint, luaL_optint, luaL_checklong, luaL_optlong
+
+#[inline(always)]
+pub unsafe fn luaL_typename(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua::lua_typename(L, lua::lua_type(L, i))
+}
+
+pub unsafe fn luaL_dofile(L: *mut lua_State, filename: *const c_char) -> c_int {
+    let status = luaL_loadfile(L, filename);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dostring(L: *mut lua_State, s: *const c_char) -> c_int {
+    let status = luaL_loadstring(L, s);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
+    lua::lua_getfield_(L, lua::LUA_REGISTRYINDEX, n);
+}
+
+// TODO: luaL_opt
+
+//
+// TODO: Generic Buffer Manipulation
+//
@@ -0,0 +1,380 @@
+//! Contains definitions from `lua.h`.
+
+use std::marker::{PhantomData, PhantomPinned};
+use std::os::raw::{c_char, c_double, c_int, c_void};
+use std::ptr;
+
+// Mark for precompiled code (`<esc>Lua`)
+#[cfg(not(feature = "luajit"))]
+pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
+#[cfg(feature = "luajit")]
+pub const LUA_SIGNATURE: &[u8] = b"\x1bLJ";
+
+// Option for multiple returns in 'lua_pcall' and 'lua_call'
+pub const LUA_MULTRET: c_int = -1;
+
+//
+// Pseudo-indices
+//
+pub const LUA_REGISTRYINDEX: c_int = -10000;
+pub const LUA_ENVIRONINDEX: c_int = -10001;
+pub const LUA_GLOBALSINDEX: c_int = -10002;
+
+pub const fn lua_upvalueindex(i: c_int) -> c_int {
+    LUA_GLOBALSINDEX - i
+}
+
+//
+// Thread status
+//
+pub const LUA_OK: c_int = 0;
+pub const LUA_YIELD: c_int = 1;
+pub const LUA_ERRRUN: c_int = 2;
+pub const LUA_ERRSYNTAX: c_int = 3;
+pub const LUA_ERRMEM: c_int = 4;
+pub const LUA_ERRERR: c_int = 5;
+
+/// A raw Lua state associated with a thread.
+#[repr(C)]
+pub struct lua_State {
+    _data: [u8; 0],
+    _marker: PhantomData<(*mut u8, PhantomPinned)>,
+}
+
+//
+// Basic types
+//
+pub const LUA_TNONE: c_int = -1;
+
+pub const LUA_TNIL: c_int = 0;
+pub const LUA_TBOOLEAN: c_int = 1;
+pub const LUA_TLIGHTUSERDATA: c_int = 2;
+pub const LUA_TNUMBER: c_int = 3;
+pub const LUA_TSTRING: c_int = 4;
+pub const LUA_TTABLE: c_int = 5;
+pub const LUA_TFUNCTION: c_int = 6;
+pub const LUA_TUSERDATA: c_int = 7;
+pub const LUA_TTHREAD: c_int = 8;
+
+/// Type produced by LuaJIT FFI module
+#[cfg(feature = "luajit")]
+pub const LUA_TCDATA: c_int = 10;
+
+/// Minimum Lua stack available to a C function
+pub const LUA_MINSTACK: c_int = 20;
+
+/// A Lua number, usually equivalent to `f64`
+pub type lua_Number = c_double;
+
+/// A Lua integer, usually equivalent to `i64`
+pub type lua_Integer = isize;
+
+/// Type for native C functions that can be passed to Lua.
+pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;
+
+// Type for functions that read/write blocks when loading/dumping Lua chunks
+pub type lua_Reader =
+    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+pub type lua_Writer =
+    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+
+/// Type for memory-allocation functions
+pub type lua_Alloc = unsafe extern "C" fn(
+    ud: *mut c_void,
+    ptr: *mut c_void,
+    osize: usize,
+    nsize: usize,
+) -> *mut c_void;
+
+extern "C" {
+    //
+    // State manipulation
+    //
+    pub fn lua_newstate(f: lua_Alloc, ud: *mut c_void) -> *mut lua_State;
+    pub fn lua_close(L: *mut lua_State);
+    pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
+
+    #[cfg(all(feature = "luajit", feature = "vendored"))]
+    pub fn lua_resetthread(L: *mut lua_State, th: *mut lua_State);
+
+    pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
+
+    //
+    // Basic stack manipulation
+    //
+    pub fn lua_gettop(L: *mut lua_State) -> c_int;
+    pub fn lua_settop(L: *mut lua_State, idx: c_int);
+    pub fn lua_pushvalue(L: *mut lua_State, idx: c_int);
+    pub fn lua_remove(L: *mut lua_State, idx: c_int);
+    pub fn lua_insert(L: *mut lua_State, idx: c_int);
+    pub fn lua_replace(L: *mut lua_State, idx: c_int);
+    pub fn lua_checkstack(L: *mut lua_State, sz: c_int) -> c_int;
+
+    pub fn lua_xmove(from: *mut lua_State, to: *mut lua_State, n: c_int);
+
+    //
+    // Access functions (stack -> C)
+    //
+    pub fn lua_isnumber(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isstring(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_iscfunction(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isuserdata(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_type(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_typename(L: *mut lua_State, tp: c_int) -> *const c_char;
+
+    pub fn lua_equal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_lessthan(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+
+    pub fn lua_tonumber(L: *mut lua_State, idx: c_int) -> lua_Number;
+    #[link_name = "lua_tointeger"]
+    pub fn lua_tointeger_(L: *mut lua_State, idx: c_int) -> lua_Integer;
+    pub fn lua_toboolean(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+    pub fn lua_objlen(L: *mut lua_State, idx: c_int) -> usize;
+    pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> Option<lua_CFunction>;
+    pub fn lua_touserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
+    pub fn lua_tothread(L: *mut lua_State, idx: c_int) -> *mut lua_State;
+    pub fn lua_topointer(L: *mut lua_State, idx: c_int) -> *const c_void;
+
+    //
+    // Push functions (C -> stack)
+    //
+    pub fn lua_pushnil(L: *mut lua_State);
+    pub fn lua_pushnumber(L: *mut lua_State, n: lua_Number);
+    pub fn lua_pushinteger(L: *mut lua_State, n: lua_Integer);
+    #[link_name = "lua_pushlstring"]
+    pub fn lua_pushlstring_(L: *mut lua_State, s: *const c_char, l: usize);
+    #[link_name = "lua_pushstring"]
+    pub fn lua_pushstring_(L: *mut lua_State, s: *const c_char);
+    // lua_pushvfstring
+    pub fn lua_pushfstring(L: *mut lua_State, fmt: *const c_char, ...) -> *const c_char;
+    pub fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, n: c_int);
+    pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
+    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void);
+    pub fn lua_pushthread(L: *mut lua_State) -> c_int;
+
+    //
+    // Get functions (Lua -> stack)
+    //
+    #[link_name = "lua_gettable"]
+    pub fn lua_gettable_(L: *mut lua_State, idx: c_int);
+    #[link_name = "lua_getfield"]
+    pub fn lua_getfield_(L: *mut lua_State, idx: c_int, k: *const c_char);
+    #[link_name = "lua_rawget"]
+    pub fn lua_rawget_(L: *mut lua_State, idx: c_int);
+    #[link_name = "lua_rawgeti"]
+    pub fn lua_rawgeti_(L: *mut lua_State, idx: c_int, n: c_int);
+    pub fn lua_createtable(L: *mut lua_State, narr: c_int, nrec: c_int);
+    pub fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void;
+    pub fn lua_getmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_getfenv(L: *mut lua_State, idx: c_int);
+
+    //
+    // Set functions (stack -> Lua)
+    //
+    pub fn lua_settable(L: *mut lua_State, idx: c_int);
+    pub fn lua_setfield(L: *mut lua_State, idx: c_int, k: *const c_char);
+    pub fn lua_rawset(L: *mut lua_State, idx: c_int);
+    #[link_name = "lua_rawseti"]
+    pub fn lua_rawseti_(L: *mut lua_State, idx: c_int, n: c_int);
+    pub fn lua_setmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_setfenv(L: *mut lua_State, idx: c_int) -> c_int;
+
+    //
+    // 'load' and 'call' functions (load and run Lua code)
+    //
+    pub fn lua_call(L: *mut lua_State, nargs: c_int, nresults: c_int);
+    pub fn lua_pcall(L: *mut lua_State, nargs: c_int, nresults: c_int, errfunc: c_int) -> c_int;
+    pub fn lua_cpcall(L: *mut lua_State, f: lua_CFunction, ud: *mut c_void) -> c_int;
+    pub fn lua_load(
+        L: *mut lua_State,
+        reader: lua_Reader,
+        data: *mut c_void,
+        chunkname: *const c_char,
+    ) -> c_int;
+
+    #[link_name = "lua_dump"]
+    pub fn lua_dump_(L: *mut lua_State, writer: lua_Writer, data: *mut c_void) -> c_int;
+
+    //
+    // Coroutine functions
+    //
+    pub fn lua_yield(L: *mut lua_State, nresults: c_int) -> c_int;
+    #[link_name = "lua_resume"]
+    pub fn lua_resume_(L: *mut lua_State, narg: c_int) -> c_int;
+    pub fn lua_status(L: *mut lua_State) -> c_int;
+}
+
+//
+// Garbage-collection function and options
+//
+pub const LUA_GCSTOP: c_int = 0;
+pub const LUA_GCRESTART: c_int = 1;
+pub const LUA_GCCOLLECT: c_int = 2;
+pub const LUA_GCCOUNT: c_int = 3;
+pub const LUA_GCCOUNTB: c_int = 4;
+pub const LUA_GCSTEP: c_int = 5;
+pub const LUA_GCSETPAUSE: c_int = 6;
+pub const LUA_GCSETSTEPMUL: c_int = 7;
+
+extern "C" {
+    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
+}
+
+//
+// Miscellaneous functions
+//
+extern "C" {
+    pub fn lua_error(L: *mut lua_State) -> !;
+    pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_concat(L: *mut lua_State, n: c_int);
+    pub fn lua_getallocf(L: *mut lua_State, ud: *mut *mut c_void) -> lua_Alloc;
+    pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut c_void);
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+#[inline(always)]
+pub unsafe fn lua_pop(L: *mut lua_State, n: c_int) {
+    lua_settop(L, -n - 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newtable(L: *mut lua_State) {
+    lua_createtable(L, 0, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_register(L: *mut lua_State, n: *const c_char, f: lua_CFunction) {
+    lua_pushcfunction(L, f);
+    lua_setglobal(L, n)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
+    lua_pushcclosure(L, f, 0)
+}
+
+// TODO: lua_strlen
+
+#[inline(always)]
+pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TFUNCTION) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_istable(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTABLE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_islightuserdata(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TLIGHTUSERDATA) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNIL) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isboolean(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TBOOLEAN) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isthread(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTHREAD) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnone(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNONE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) <= LUA_TNIL) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) {
+    use std::ffi::CString;
+    let c_str = CString::new(s).unwrap();
+    lua_pushlstring_(L, c_str.as_ptr(), c_str.as_bytes().len())
+}
+
+#[inline(always)]
+pub unsafe fn lua_setglobal(L: *mut lua_State, var: *const c_char) {
+    lua_setfield(L, LUA_GLOBALSINDEX, var)
+}
+
+#[inline(always)]
+pub unsafe fn lua_getglobal_(L: *mut lua_State, var: *const c_char) {
+    lua_getfield_(L, LUA_GLOBALSINDEX, var)
+}
+
+#[inline(always)]
+pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua_tolstring(L, i, ptr::null_mut())
+}
+
+//
+// Debug API
+//
+
+// Maximum size for the description of the source of a function in debug information.
+const LUA_IDSIZE: usize = 60;
+
+// Event codes
+pub const LUA_HOOKCALL: c_int = 0;
+pub const LUA_HOOKRET: c_int = 1;
+pub const LUA_HOOKLINE: c_int = 2;
+pub const LUA_HOOKCOUNT: c_int = 3;
+pub const LUA_HOOKTAILCALL: c_int = 4;
+
+// Event masks
+pub const LUA_MASKCALL: c_int = 1 << (LUA_HOOKCALL as usize);
+pub const LUA_MASKRET: c_int = 1 << (LUA_HOOKRET as usize);
+pub const LUA_MASKLINE: c_int = 1 << (LUA_HOOKLINE as usize);
+pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
+
+/// Type for functions to be called on debug events.
+pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+
+extern "C" {
+    pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    pub fn lua_setlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    pub fn lua_getupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
+    pub fn lua_setupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
+
+    pub fn lua_sethook(
+        L: *mut lua_State,
+        func: Option<lua_Hook>,
+        mask: c_int,
+        count: c_int,
+    ) -> c_int;
+    pub fn lua_gethook(L: *mut lua_State) -> Option<lua_Hook>;
+    pub fn lua_gethookmask(L: *mut lua_State) -> c_int;
+    pub fn lua_gethookcount(L: *mut lua_State) -> c_int;
+}
+
+#[repr(C)]
+pub struct lua_Debug {
+    pub event: c_int,
+    pub name: *const c_char,
+    pub namewhat: *const c_char,
+    pub what: *const c_char,
+    pub source: *const c_char,
+    pub currentline: c_int,
+    pub nups: c_int,
+    pub linedefined: c_int,
+    pub lastlinedefined: c_int,
+    pub short_src: [c_char; LUA_IDSIZE],
+    // lua.h mentions this is for private use
+    i_ci: c_int,
+}
@@ -0,0 +1,42 @@
+//! Contains definitions from `lualib.h`.
+
+use std::os::raw::c_int;
+
+use super::lua::lua_State;
+
+pub const LUA_COLIBNAME: &str = "coroutine";
+pub const LUA_TABLIBNAME: &str = "table";
+pub const LUA_IOLIBNAME: &str = "io";
+pub const LUA_OSLIBNAME: &str = "os";
+pub const LUA_STRLIBNAME: &str = "string";
+pub const LUA_MATHLIBNAME: &str = "math";
+pub const LUA_DBLIBNAME: &str = "debug";
+pub const LUA_LOADLIBNAME: &str = "package";
+
+#[cfg(feature = "luajit")]
+pub const LUA_BITLIBNAME: &str = "bit";
+#[cfg(feature = "luajit")]
+pub const LUA_JITLIBNAME: &str = "jit";
+#[cfg(feature = "luajit")]
+pub const LUA_FFILIBNAME: &str = "ffi";
+
+extern "C" {
+    pub fn luaopen_base(L: *mut lua_State) -> c_int;
+    pub fn luaopen_table(L: *mut lua_State) -> c_int;
+    pub fn luaopen_io(L: *mut lua_State) -> c_int;
+    pub fn luaopen_os(L: *mut lua_State) -> c_int;
+    pub fn luaopen_string(L: *mut lua_State) -> c_int;
+    pub fn luaopen_math(L: *mut lua_State) -> c_int;
+    pub fn luaopen_debug(L: *mut lua_State) -> c_int;
+    pub fn luaopen_package(L: *mut lua_State) -> c_int;
+
+    #[cfg(feature = "luajit")]
+    pub fn luaopen_bit(L: *mut lua_State) -> c_int;
+    #[cfg(feature = "luajit")]
+    pub fn luaopen_jit(L: *mut lua_State) -> c_int;
+    #[cfg(feature = "luajit")]
+    pub fn luaopen_ffi(L: *mut lua_State) -> c_int;
+
+    // open all builtin libraries
+    pub fn luaL_openlibs(L: *mut lua_State);
+}
@@ -0,0 +1,11 @@
+//! Low level bindings to Lua 5.1.
+
+pub use compat::*;
+pub use lauxlib::*;
+pub use lua::*;
+pub use lualib::*;
+
+pub mod compat;
+pub mod lauxlib;
+pub mod lua;
+pub mod lualib;
@@ -0,0 +1,258 @@
+//! MLua compatibility layer for Lua 5.2
+//!
+//! Based on github.com/keplerproject/lua-compat-5.3
+
+use std::convert::TryInto;
+use std::os::raw::{c_char, c_int, c_void};
+use std::ptr;
+
+use super::lauxlib::*;
+use super::lua::*;
+
+#[inline(always)]
+unsafe fn compat53_reverse(L: *mut lua_State, mut a: c_int, mut b: c_int) {
+    while a < b {
+        lua_pushvalue(L, a);
+        lua_pushvalue(L, b);
+        lua_replace(L, a);
+        lua_replace(L, b);
+        a += 1;
+        b -= 1;
+    }
+}
+
+//
+// lua ported functions
+//
+
+pub unsafe fn lua_rotate(L: *mut lua_State, mut idx: c_int, mut n: c_int) {
+    idx = lua_absindex(L, idx);
+    let n_elems = lua_gettop(L) - idx + 1;
+    if n < 0 {
+        n += n_elems;
+    }
+    if n > 0 && n < n_elems {
+        luaL_checkstack(L, 2, cstr!("not enough stack slots available"));
+        n = n_elems - n;
+        compat53_reverse(L, idx, idx + n - 1);
+        compat53_reverse(L, idx + n, idx + n_elems - 1);
+        compat53_reverse(L, idx, idx + n_elems - 1);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int {
+    if lua_type(L, idx) == LUA_TNUMBER {
+        let n = lua_tonumber(L, idx);
+        let i = lua_tointeger(L, idx);
+        if (n - i as lua_Number).abs() < lua_Number::EPSILON {
+            return 1;
+        }
+    }
+    0
+}
+
+#[inline(always)]
+pub unsafe fn lua_tointeger(L: *mut lua_State, i: c_int) -> lua_Integer {
+    lua_tointegerx(L, i, ptr::null_mut())
+}
+
+// Implemented for Lua 5.2 as well
+// See https://github.com/keplerproject/lua-compat-5.3/issues/40
+#[inline(always)]
+pub unsafe fn lua_tointegerx(L: *mut lua_State, i: c_int, isnum: *mut c_int) -> lua_Integer {
+    let mut ok = 0;
+    let n = lua_tonumberx(L, i, &mut ok);
+    let n_int = n as lua_Integer;
+    if ok != 0 && (n - n_int as lua_Number).abs() < lua_Number::EPSILON {
+        if !isnum.is_null() {
+            *isnum = 1;
+        }
+        return n_int;
+    }
+    if !isnum.is_null() {
+        *isnum = 0;
+    }
+    0
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushlstring(L: *mut lua_State, s: *const c_char, l: usize) -> *const c_char {
+    if l == 0 {
+        lua_pushlstring_(L, cstr!(""), 0)
+    } else {
+        lua_pushlstring_(L, s, l)
+    }
+}
+
+#[inline(always)]
+pub unsafe fn lua_getglobal(L: *mut lua_State, var: *const c_char) -> c_int {
+    lua_getglobal_(L, var);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_gettable(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_gettable_(L, idx);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int {
+    lua_getfield_(L, idx, k);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_geti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) -> c_int {
+    idx = lua_absindex(L, idx);
+    lua_pushinteger(L, n);
+    lua_gettable(L, idx)
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_rawget_(L, idx);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int {
+    let n = n.try_into().expect("cannot convert index to lua_Integer");
+    lua_rawgeti_(L, idx, n);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int {
+    lua_rawgetp_(L, idx, p);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_getuservalue_(L, idx);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_seti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) {
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
+    idx = lua_absindex(L, idx);
+    lua_pushinteger(L, n);
+    lua_insert(L, -2);
+    lua_settable(L, idx);
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer) {
+    let n = n.try_into().expect("cannot convert index from lua_Integer");
+    lua_rawseti_(L, idx, n)
+}
+
+#[inline(always)]
+pub unsafe fn lua_dump(
+    L: *mut lua_State,
+    writer: lua_Writer,
+    data: *mut c_void,
+    _strip: c_int,
+) -> c_int {
+    lua_dump_(L, writer, data)
+}
+
+#[inline(always)]
+pub unsafe fn lua_resume(
+    L: *mut lua_State,
+    from: *mut lua_State,
+    narg: c_int,
+    nres: *mut c_int,
+) -> c_int {
+    let ret = lua_resume_(L, from, narg);
+    if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
+        *nres = lua_gettop(L);
+    }
+    ret
+}
+
+//
+// lauxlib ported functions
+//
+
+#[inline(always)]
+pub unsafe fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int {
+    if luaL_getmetafield_(L, obj, e) != 0 {
+        lua_type(L, -1)
+    } else {
+        LUA_TNIL
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_int {
+    if luaL_newmetatable_(L, tname) != 0 {
+        lua_pushstring(L, tname);
+        lua_setfield(L, -2, cstr!("__name"));
+        1
+    } else {
+        0
+    }
+}
+
+pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char {
+    if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
+        let t = lua_type(L, idx);
+        match t {
+            LUA_TNIL => {
+                lua_pushliteral(L, "nil");
+            }
+            LUA_TSTRING | LUA_TNUMBER => {
+                lua_pushvalue(L, idx);
+            }
+            LUA_TBOOLEAN => {
+                if lua_toboolean(L, idx) == 0 {
+                    lua_pushliteral(L, "false");
+                } else {
+                    lua_pushliteral(L, "true");
+                }
+            }
+            _ => {
+                let tt = luaL_getmetafield(L, idx, cstr!("__name"));
+                let name = if tt == LUA_TSTRING {
+                    lua_tostring(L, -1)
+                } else {
+                    lua_typename(L, t)
+                };
+                lua_pushfstring(L, cstr!("%s: %p"), name, lua_topointer(L, idx));
+                if tt != LUA_TNIL {
+                    lua_replace(L, -2);
+                }
+            }
+        };
+    } else if lua_isstring(L, -1) == 0 {
+        luaL_error(L, cstr!("'__tostring' must return a string"));
+    }
+    lua_tolstring(L, -1, len)
+}
+
+pub unsafe fn luaL_requiref(
+    L: *mut lua_State,
+    modname: *const c_char,
+    openf: lua_CFunction,
+    glb: c_int,
+) {
+    luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
+    luaL_getsubtable(L, LUA_REGISTRYINDEX, cstr!("_LOADED"));
+    if lua_getfield(L, -1, modname) == LUA_TNIL {
+        lua_pop(L, 1);
+        lua_pushcfunction(L, openf);
+        lua_pushstring(L, modname);
+        lua_call(L, 1, 1);
+        lua_pushvalue(L, -1);
+        lua_setfield(L, -3, modname);
+    }
+    if glb != 0 {
+        lua_pushvalue(L, -1);
+        lua_setglobal(L, modname);
+    }
+    lua_replace(L, -2);
+}
@@ -0,0 +1,184 @@
+//! Contains definitions from `lauxlib.h`.
+
+use std::os::raw::{c_char, c_int, c_void};
+use std::ptr;
+
+use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State, lua_Unsigned};
+
+// Extra error code for 'luaL_load'
+pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
+
+#[repr(C)]
+pub struct luaL_Reg {
+    pub name: *const c_char,
+    pub func: lua_CFunction,
+}
+
+extern "C" {
+    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number);
+
+    #[link_name = "luaL_getmetafield"]
+    pub fn luaL_getmetafield_(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    pub fn luaL_callmeta(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    #[link_name = "luaL_tolstring"]
+    pub fn luaL_tolstring_(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+    pub fn luaL_argerror(L: *mut lua_State, arg: c_int, extramsg: *const c_char) -> c_int;
+    pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
+    pub fn luaL_optlstring(
+        L: *mut lua_State,
+        arg: c_int,
+        def: *const c_char,
+        l: *mut usize,
+    ) -> *const c_char;
+    pub fn luaL_checknumber(L: *mut lua_State, arg: c_int) -> lua_Number;
+    pub fn luaL_optnumber(L: *mut lua_State, arg: c_int, def: lua_Number) -> lua_Number;
+    pub fn luaL_checkinteger(L: *mut lua_State, arg: c_int) -> lua_Integer;
+    pub fn luaL_optinteger(L: *mut lua_State, arg: c_int, def: lua_Integer) -> lua_Integer;
+    pub fn luaL_checkunsigned(L: *mut lua_State, arg: c_int) -> lua_Unsigned;
+    pub fn luaL_optunsigned(L: *mut lua_State, arg: c_int, def: lua_Unsigned) -> lua_Unsigned;
+
+    pub fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char);
+    pub fn luaL_checktype(L: *mut lua_State, arg: c_int, t: c_int);
+    pub fn luaL_checkany(L: *mut lua_State, arg: c_int);
+
+    #[link_name = "luaL_newmetatable"]
+    pub fn luaL_newmetatable_(L: *mut lua_State, tname: *const c_char) -> c_int;
+    pub fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char);
+    pub fn luaL_testudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
+    pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
+
+    pub fn luaL_where(L: *mut lua_State, lvl: c_int);
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
+
+    pub fn luaL_checkoption(
+        L: *mut lua_State,
+        arg: c_int,
+        def: *const c_char,
+        lst: *const *const c_char,
+    ) -> c_int;
+
+    pub fn luaL_fileresult(L: *mut lua_State, stat: c_int, fname: *const c_char) -> c_int;
+    pub fn luaL_execresult(L: *mut lua_State, stat: c_int) -> c_int;
+}
+
+// Pre-defined references
+pub const LUA_NOREF: c_int = -2;
+pub const LUA_REFNIL: c_int = -1;
+
+extern "C" {
+    pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
+    pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
+
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char)
+        -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
+    luaL_loadfilex(L, f, ptr::null())
+}
+
+extern "C" {
+    pub fn luaL_loadbufferx(
+        L: *mut lua_State,
+        buff: *const c_char,
+        sz: usize,
+        name: *const c_char,
+        mode: *const c_char,
+    ) -> c_int;
+    pub fn luaL_loadstring(L: *mut lua_State, s: *const c_char) -> c_int;
+
+    pub fn luaL_newstate() -> *mut lua_State;
+
+    pub fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer;
+
+    pub fn luaL_gsub(
+        L: *mut lua_State,
+        s: *const c_char,
+        p: *const c_char,
+        r: *const c_char,
+    ) -> *const c_char;
+
+    pub fn luaL_setfuncs(L: *mut lua_State, l: *const luaL_Reg, nup: c_int);
+
+    pub fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_char) -> c_int;
+
+    pub fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, level: c_int);
+
+    #[link_name = "luaL_requiref"]
+    pub fn luaL_requiref_(
+        L: *mut lua_State,
+        modname: *const c_char,
+        openf: lua_CFunction,
+        glb: c_int,
+    );
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+
+// TODO: luaL_newlibtable, luaL_newlib
+
+#[inline(always)]
+pub unsafe fn luaL_argcheck(L: *mut lua_State, cond: c_int, arg: c_int, extramsg: *const c_char) {
+    if cond == 0 {
+        luaL_argerror(L, arg, extramsg);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_checkstring(L: *mut lua_State, n: c_int) -> *const c_char {
+    luaL_checklstring(L, n, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *const c_char {
+    luaL_optlstring(L, n, d, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_typename(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua::lua_typename(L, lua::lua_type(L, i))
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dofile(L: *mut lua_State, filename: *const c_char) -> c_int {
+    let status = luaL_loadfile(L, filename);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dostring(L: *mut lua_State, s: *const c_char) -> c_int {
+    let status = luaL_loadstring(L, s);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
+    lua::lua_getfield_(L, lua::LUA_REGISTRYINDEX, n);
+}
+
+// luaL_opt would be implemented here but it is undocumented, so it's omitted
+
+#[inline(always)]
+pub unsafe fn luaL_loadbuffer(
+    L: *mut lua_State,
+    s: *const c_char,
+    sz: usize,
+    n: *const c_char,
+) -> c_int {
+    luaL_loadbufferx(L, s, sz, n, ptr::null())
+}
+
+//
+// TODO: Generic Buffer Manipulation
+//
@@ -0,0 +1,467 @@
+//! Contains definitions from `lua.h`.
+
+use std::marker::{PhantomData, PhantomPinned};
+use std::os::raw::{c_char, c_double, c_int, c_uchar, c_uint, c_void};
+use std::ptr;
+
+// Mark for precompiled code (`<esc>Lua`)
+pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
+
+// Option for multiple returns in 'lua_pcall' and 'lua_call'
+pub const LUA_MULTRET: c_int = -1;
+
+// Size of the Lua stack
+pub const LUAI_MAXSTACK: c_int = 1000000;
+
+//
+// Pseudo-indices
+//
+pub const LUA_REGISTRYINDEX: c_int = -LUAI_MAXSTACK - 1000;
+
+pub const fn lua_upvalueindex(i: c_int) -> c_int {
+    LUA_REGISTRYINDEX - i
+}
+
+//
+// Thread status
+//
+pub const LUA_OK: c_int = 0;
+pub const LUA_YIELD: c_int = 1;
+pub const LUA_ERRRUN: c_int = 2;
+pub const LUA_ERRSYNTAX: c_int = 3;
+pub const LUA_ERRMEM: c_int = 4;
+pub const LUA_ERRGCMM: c_int = 5;
+pub const LUA_ERRERR: c_int = 6;
+
+/// A raw Lua state associated with a thread.
+#[repr(C)]
+pub struct lua_State {
+    _data: [u8; 0],
+    _marker: PhantomData<(*mut u8, PhantomPinned)>,
+}
+
+//
+// Basic types
+//
+pub const LUA_TNONE: c_int = -1;
+
+pub const LUA_TNIL: c_int = 0;
+pub const LUA_TBOOLEAN: c_int = 1;
+pub const LUA_TLIGHTUSERDATA: c_int = 2;
+pub const LUA_TNUMBER: c_int = 3;
+pub const LUA_TSTRING: c_int = 4;
+pub const LUA_TTABLE: c_int = 5;
+pub const LUA_TFUNCTION: c_int = 6;
+pub const LUA_TUSERDATA: c_int = 7;
+pub const LUA_TTHREAD: c_int = 8;
+
+pub const LUA_NUMTAGS: c_int = 9;
+
+/// Minimum Lua stack available to a C function
+pub const LUA_MINSTACK: c_int = 20;
+
+// Predefined values in the registry
+pub const LUA_RIDX_MAINTHREAD: lua_Integer = 1;
+pub const LUA_RIDX_GLOBALS: lua_Integer = 2;
+pub const LUA_RIDX_LAST: lua_Integer = LUA_RIDX_GLOBALS;
+
+/// A Lua number, usually equivalent to `f64`
+pub type lua_Number = c_double;
+
+/// A Lua integer, usually equivalent to `i64`
+pub type lua_Integer = isize;
+
+/// A Lua unsigned integer, equivalent to `u32` in Lua 5.2
+pub type lua_Unsigned = c_uint;
+
+/// Type for native C functions that can be passed to Lua
+pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;
+
+// Type for functions that read/write blocks when loading/dumping Lua chunks
+pub type lua_Reader =
+    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+pub type lua_Writer =
+    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+
+/// Type for memory-allocation functions
+pub type lua_Alloc = unsafe extern "C" fn(
+    ud: *mut c_void,
+    ptr: *mut c_void,
+    osize: usize,
+    nsize: usize,
+) -> *mut c_void;
+
+extern "C" {
+    //
+    // State manipulation
+    //
+    pub fn lua_newstate(f: lua_Alloc, ud: *mut c_void) -> *mut lua_State;
+    pub fn lua_close(L: *mut lua_State);
+    pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
+
+    pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
+
+    pub fn lua_version(L: *mut lua_State) -> *const lua_Number;
+
+    //
+    // Basic stack manipulation
+    //
+    pub fn lua_absindex(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_gettop(L: *mut lua_State) -> c_int;
+    pub fn lua_settop(L: *mut lua_State, idx: c_int);
+    pub fn lua_pushvalue(L: *mut lua_State, idx: c_int);
+    pub fn lua_remove(L: *mut lua_State, idx: c_int);
+    pub fn lua_insert(L: *mut lua_State, idx: c_int);
+    pub fn lua_replace(L: *mut lua_State, idx: c_int);
+    pub fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int);
+    pub fn lua_checkstack(L: *mut lua_State, sz: c_int) -> c_int;
+
+    pub fn lua_xmove(from: *mut lua_State, to: *mut lua_State, n: c_int);
+
+    //
+    // Access functions (stack -> C)
+    //
+    pub fn lua_isnumber(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isstring(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_iscfunction(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isuserdata(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_type(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_typename(L: *mut lua_State, tp: c_int) -> *const c_char;
+
+    pub fn lua_tonumberx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Number;
+    #[link_name = "lua_tointegerx"]
+    pub fn lua_tointegerx_(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Integer;
+    pub fn lua_tounsignedx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Unsigned;
+    pub fn lua_toboolean(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+    pub fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize;
+    pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> Option<lua_CFunction>;
+    pub fn lua_touserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
+    pub fn lua_tothread(L: *mut lua_State, idx: c_int) -> *mut lua_State;
+    pub fn lua_topointer(L: *mut lua_State, idx: c_int) -> *const c_void;
+}
+
+//
+// Comparison and arithmetic functions
+//
+pub const LUA_OPADD: c_int = 0;
+pub const LUA_OPSUB: c_int = 1;
+pub const LUA_OPMUL: c_int = 2;
+pub const LUA_OPDIV: c_int = 3;
+pub const LUA_OPMOD: c_int = 4;
+pub const LUA_OPPOW: c_int = 5;
+pub const LUA_OPUNM: c_int = 6;
+
+extern "C" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
+}
+
+pub const LUA_OPEQ: c_int = 0;
+pub const LUA_OPLT: c_int = 1;
+pub const LUA_OPLE: c_int = 2;
+
+extern "C" {
+    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
+}
+
+extern "C" {
+    //
+    // Push functions (C -> stack)
+    //
+    pub fn lua_pushnil(L: *mut lua_State);
+    pub fn lua_pushnumber(L: *mut lua_State, n: lua_Number);
+    pub fn lua_pushinteger(L: *mut lua_State, n: lua_Integer);
+    pub fn lua_pushunsigned(L: *mut lua_State, n: lua_Unsigned);
+    #[link_name = "lua_pushlstring"]
+    pub fn lua_pushlstring_(L: *mut lua_State, s: *const c_char, l: usize) -> *const c_char;
+    pub fn lua_pushstring(L: *mut lua_State, s: *const c_char) -> *const c_char;
+    // lua_pushvfstring
+    pub fn lua_pushfstring(L: *mut lua_State, fmt: *const c_char, ...) -> *const c_char;
+    pub fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, n: c_int);
+    pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
+    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void);
+    pub fn lua_pushthread(L: *mut lua_State) -> c_int;
+
+    //
+    // Get functions (Lua -> stack)
+    //
+    #[link_name = "lua_getglobal"]
+    pub fn lua_getglobal_(L: *mut lua_State, name: *const c_char);
+    #[link_name = "lua_gettable"]
+    pub fn lua_gettable_(L: *mut lua_State, idx: c_int);
+    #[link_name = "lua_getfield"]
+    pub fn lua_getfield_(L: *mut lua_State, idx: c_int, k: *const c_char);
+    #[link_name = "lua_rawget"]
+    pub fn lua_rawget_(L: *mut lua_State, idx: c_int);
+    #[link_name = "lua_rawgeti"]
+    pub fn lua_rawgeti_(L: *mut lua_State, idx: c_int, n: c_int);
+    #[link_name = "lua_rawgetp"]
+    pub fn lua_rawgetp_(L: *mut lua_State, idx: c_int, p: *const c_void);
+    pub fn lua_createtable(L: *mut lua_State, narr: c_int, nrec: c_int);
+    pub fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void;
+    pub fn lua_getmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    #[link_name = "lua_getuservalue"]
+    pub fn lua_getuservalue_(L: *mut lua_State, idx: c_int);
+
+    //
+    // Set functions (stack -> Lua)
+    //
+    pub fn lua_setglobal(L: *mut lua_State, var: *const c_char);
+    pub fn lua_settable(L: *mut lua_State, idx: c_int);
+    pub fn lua_setfield(L: *mut lua_State, idx: c_int, k: *const c_char);
+    pub fn lua_rawset(L: *mut lua_State, idx: c_int);
+    #[link_name = "lua_rawseti"]
+    pub fn lua_rawseti_(L: *mut lua_State, idx: c_int, n: c_int);
+    pub fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void);
+    pub fn lua_setmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_setuservalue(L: *mut lua_State, idx: c_int);
+
+    //
+    // 'load' and 'call' functions (load and run Lua code)
+    //
+    pub fn lua_callk(
+        L: *mut lua_State,
+        nargs: c_int,
+        nresults: c_int,
+        ctx: c_int,
+        k: Option<lua_CFunction>,
+    );
+    pub fn lua_pcallk(
+        L: *mut lua_State,
+        nargs: c_int,
+        nresults: c_int,
+        errfunc: c_int,
+        ctx: c_int,
+        k: Option<lua_CFunction>,
+    ) -> c_int;
+
+    pub fn lua_getctx(L: *mut lua_State, ctx: *mut c_int) -> c_int;
+
+    pub fn lua_load(
+        L: *mut lua_State,
+        reader: lua_Reader,
+        data: *mut c_void,
+        chunkname: *const c_char,
+        mode: *const c_char,
+    ) -> c_int;
+    #[link_name = "lua_dump"]
+    pub fn lua_dump_(L: *mut lua_State, writer: lua_Writer, data: *mut c_void) -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn lua_call(L: *mut lua_State, n: c_int, r: c_int) {
+    lua_callk(L, n, r, 0, None)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_int {
+    lua_pcallk(L, n, r, f, 0, None)
+}
+
+extern "C" {
+    //
+    // Coroutine functions
+    //
+    pub fn lua_yieldk(
+        L: *mut lua_State,
+        nresults: c_int,
+        ctx: c_int,
+        k: Option<lua_CFunction>,
+    ) -> c_int;
+    #[link_name = "lua_resume"]
+    pub fn lua_resume_(L: *mut lua_State, from: *mut lua_State, narg: c_int) -> c_int;
+    pub fn lua_status(L: *mut lua_State) -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn lua_yield(L: *mut lua_State, n: c_int) -> c_int {
+    lua_yieldk(L, n, 0, None)
+}
+
+//
+// Garbage-collection function and options
+//
+pub const LUA_GCSTOP: c_int = 0;
+pub const LUA_GCRESTART: c_int = 1;
+pub const LUA_GCCOLLECT: c_int = 2;
+pub const LUA_GCCOUNT: c_int = 3;
+pub const LUA_GCCOUNTB: c_int = 4;
+pub const LUA_GCSTEP: c_int = 5;
+pub const LUA_GCSETPAUSE: c_int = 6;
+pub const LUA_GCSETSTEPMUL: c_int = 7;
+pub const LUA_GCSETMAJORINC: c_int = 8;
+pub const LUA_GCISRUNNING: c_int = 9;
+pub const LUA_GCGEN: c_int = 10;
+pub const LUA_GCINC: c_int = 11;
+
+extern "C" {
+    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
+}
+
+extern "C" {
+    //
+    // Miscellaneous functions
+    //
+    pub fn lua_error(L: *mut lua_State) -> !;
+    pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_concat(L: *mut lua_State, n: c_int);
+    pub fn lua_len(L: *mut lua_State, idx: c_int);
+    pub fn lua_getallocf(L: *mut lua_State, ud: *mut *mut c_void) -> lua_Alloc;
+    pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut c_void);
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+#[inline(always)]
+pub unsafe fn lua_tonumber(L: *mut lua_State, i: c_int) -> lua_Number {
+    lua_tonumberx(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_tointeger_(L: *mut lua_State, i: c_int) -> lua_Integer {
+    lua_tointegerx_(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_tounsigned(L: *mut lua_State, i: c_int) -> lua_Unsigned {
+    lua_tounsignedx(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_pop(L: *mut lua_State, n: c_int) {
+    lua_settop(L, -n - 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newtable(L: *mut lua_State) {
+    lua_createtable(L, 0, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_register(L: *mut lua_State, n: *const c_char, f: lua_CFunction) {
+    lua_pushcfunction(L, f);
+    lua_setglobal(L, n)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
+    lua_pushcclosure(L, f, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TFUNCTION) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_istable(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTABLE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_islightuserdata(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TLIGHTUSERDATA) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNIL) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isboolean(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TBOOLEAN) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isthread(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTHREAD) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnone(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNONE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) <= 0) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) -> *const c_char {
+    use std::ffi::CString;
+    let c_str = CString::new(s).unwrap();
+    lua_pushlstring_(L, c_str.as_ptr(), c_str.as_bytes().len())
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushglobaltable(L: *mut lua_State) {
+    lua_rawgeti_(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS as _)
+}
+
+#[inline(always)]
+pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua_tolstring(L, i, ptr::null_mut())
+}
+
+//
+// Debug API
+//
+
+// Maximum size for the description of the source of a function in debug information.
+const LUA_IDSIZE: usize = 60;
+
+// Event codes
+pub const LUA_HOOKCALL: c_int = 0;
+pub const LUA_HOOKRET: c_int = 1;
+pub const LUA_HOOKLINE: c_int = 2;
+pub const LUA_HOOKCOUNT: c_int = 3;
+pub const LUA_HOOKTAILCALL: c_int = 4;
+
+// Event masks
+pub const LUA_MASKCALL: c_int = 1 << (LUA_HOOKCALL as usize);
+pub const LUA_MASKRET: c_int = 1 << (LUA_HOOKRET as usize);
+pub const LUA_MASKLINE: c_int = 1 << (LUA_HOOKLINE as usize);
+pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
+
+/// Type for functions to be called on debug events.
+pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+
+extern "C" {
+    pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    pub fn lua_setlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    pub fn lua_getupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
+    pub fn lua_setupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
+
+    pub fn lua_upvalueid(L: *mut lua_State, fidx: c_int, n: c_int) -> *mut c_void;
+    pub fn lua_upvaluejoin(L: *mut lua_State, fidx1: c_int, n1: c_int, fidx2: c_int, n2: c_int);
+
+    pub fn lua_sethook(L: *mut lua_State, func: Option<lua_Hook>, mask: c_int, count: c_int);
+    pub fn lua_gethook(L: *mut lua_State) -> Option<lua_Hook>;
+    pub fn lua_gethookmask(L: *mut lua_State) -> c_int;
+    pub fn lua_gethookcount(L: *mut lua_State) -> c_int;
+}
+
+#[repr(C)]
+pub struct lua_Debug {
+    pub event: c_int,
+    pub name: *const c_char,
+    pub namewhat: *const c_char,
+    pub what: *const c_char,
+    pub source: *const c_char,
+    pub currentline: c_int,
+    pub linedefined: c_int,
+    pub lastlinedefined: c_int,
+    pub nups: c_uchar,
+    pub nparams: c_uchar,
+    pub isvararg: c_char,
+    pub istailcall: c_char,
+    pub short_src: [c_char; LUA_IDSIZE],
+    // lua.h mentions this is for private use
+    i_ci: *mut c_void,
+}
@@ -0,0 +1,31 @@
+//! Contains definitions from `lualib.h`.
+
+use std::os::raw::c_int;
+
+use super::lua::lua_State;
+
+pub const LUA_COLIBNAME: &str = "coroutine";
+pub const LUA_TABLIBNAME: &str = "table";
+pub const LUA_IOLIBNAME: &str = "io";
+pub const LUA_OSLIBNAME: &str = "os";
+pub const LUA_STRLIBNAME: &str = "string";
+pub const LUA_BITLIBNAME: &str = "bit32";
+pub const LUA_MATHLIBNAME: &str = "math";
+pub const LUA_DBLIBNAME: &str = "debug";
+pub const LUA_LOADLIBNAME: &str = "package";
+
+extern "C" {
+    pub fn luaopen_base(L: *mut lua_State) -> c_int;
+    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
+    pub fn luaopen_table(L: *mut lua_State) -> c_int;
+    pub fn luaopen_io(L: *mut lua_State) -> c_int;
+    pub fn luaopen_os(L: *mut lua_State) -> c_int;
+    pub fn luaopen_string(L: *mut lua_State) -> c_int;
+    pub fn luaopen_bit32(L: *mut lua_State) -> c_int;
+    pub fn luaopen_math(L: *mut lua_State) -> c_int;
+    pub fn luaopen_debug(L: *mut lua_State) -> c_int;
+    pub fn luaopen_package(L: *mut lua_State) -> c_int;
+
+    // open all builtin libraries
+    pub fn luaL_openlibs(L: *mut lua_State);
+}
@@ -0,0 +1,11 @@
+//! Low level bindings to Lua 5.2.
+
+pub use compat::*;
+pub use lauxlib::*;
+pub use lua::*;
+pub use lualib::*;
+
+pub mod compat;
+pub mod lauxlib;
+pub mod lua;
+pub mod lualib;
@@ -0,0 +1,19 @@
+//! MLua compatibility layer for Lua 5.2
+
+use std::os::raw::c_int;
+
+use super::lua::*;
+
+#[inline(always)]
+pub unsafe fn lua_resume(
+    L: *mut lua_State,
+    from: *mut lua_State,
+    narg: c_int,
+    nres: *mut c_int,
+) -> c_int {
+    let ret = lua_resume_(L, from, narg);
+    if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
+        *nres = lua_gettop(L);
+    }
+    ret
+}
@@ -0,0 +1,184 @@
+//! Contains definitions from `lauxlib.h`.
+
+use std::os::raw::{c_char, c_int, c_void};
+use std::ptr;
+
+use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
+
+// Extra error code for 'luaL_loadfilex'
+pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
+
+// Key, in the registry, for table of loaded modules
+pub const LUA_LOADED_TABLE: &str = "_LOADED";
+
+// Key, in the registry, for table of preloaded loaders
+pub const LUA_PRELOAD_TABLE: &str = "_PRELOAD";
+
+#[repr(C)]
+pub struct luaL_Reg {
+    pub name: *const c_char,
+    pub func: lua_CFunction,
+}
+
+extern "C" {
+    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number, sz: usize);
+
+    pub fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    pub fn luaL_callmeta(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    pub fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+    pub fn luaL_argerror(L: *mut lua_State, arg: c_int, extramsg: *const c_char) -> c_int;
+    pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
+    pub fn luaL_optlstring(
+        L: *mut lua_State,
+        arg: c_int,
+        def: *const c_char,
+        l: *mut usize,
+    ) -> *const c_char;
+    pub fn luaL_checknumber(L: *mut lua_State, arg: c_int) -> lua_Number;
+    pub fn luaL_optnumber(L: *mut lua_State, arg: c_int, def: lua_Number) -> lua_Number;
+    pub fn luaL_checkinteger(L: *mut lua_State, arg: c_int) -> lua_Integer;
+    pub fn luaL_optinteger(L: *mut lua_State, arg: c_int, def: lua_Integer) -> lua_Integer;
+
+    pub fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char);
+    pub fn luaL_checktype(L: *mut lua_State, arg: c_int, t: c_int);
+    pub fn luaL_checkany(L: *mut lua_State, arg: c_int);
+
+    pub fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_int;
+    pub fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char);
+    pub fn luaL_testudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
+    pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
+
+    pub fn luaL_where(L: *mut lua_State, lvl: c_int);
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
+
+    pub fn luaL_checkoption(
+        L: *mut lua_State,
+        arg: c_int,
+        def: *const c_char,
+        lst: *const *const c_char,
+    ) -> c_int;
+
+    pub fn luaL_fileresult(L: *mut lua_State, stat: c_int, fname: *const c_char) -> c_int;
+    pub fn luaL_execresult(L: *mut lua_State, stat: c_int) -> c_int;
+}
+
+// Pre-defined references
+pub const LUA_NOREF: c_int = -2;
+pub const LUA_REFNIL: c_int = -1;
+
+extern "C" {
+    pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
+    pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
+
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char)
+        -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
+    luaL_loadfilex(L, f, ptr::null())
+}
+
+extern "C" {
+    pub fn luaL_loadbufferx(
+        L: *mut lua_State,
+        buff: *const c_char,
+        sz: usize,
+        name: *const c_char,
+        mode: *const c_char,
+    ) -> c_int;
+    pub fn luaL_loadstring(L: *mut lua_State, s: *const c_char) -> c_int;
+
+    pub fn luaL_newstate() -> *mut lua_State;
+
+    pub fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer;
+
+    pub fn luaL_gsub(
+        L: *mut lua_State,
+        s: *const c_char,
+        p: *const c_char,
+        r: *const c_char,
+    ) -> *const c_char;
+
+    pub fn luaL_setfuncs(L: *mut lua_State, l: *const luaL_Reg, nup: c_int);
+
+    pub fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_char) -> c_int;
+
+    pub fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, level: c_int);
+
+    pub fn luaL_requiref(
+        L: *mut lua_State,
+        modname: *const c_char,
+        openf: lua_CFunction,
+        glb: c_int,
+    );
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+
+// TODO: luaL_newlibtable, luaL_newlib
+
+#[inline(always)]
+pub unsafe fn luaL_argcheck(L: *mut lua_State, cond: c_int, arg: c_int, extramsg: *const c_char) {
+    if cond == 0 {
+        luaL_argerror(L, arg, extramsg);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_checkstring(L: *mut lua_State, n: c_int) -> *const c_char {
+    luaL_checklstring(L, n, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *const c_char {
+    luaL_optlstring(L, n, d, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_typename(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua::lua_typename(L, lua::lua_type(L, i))
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dofile(L: *mut lua_State, filename: *const c_char) -> c_int {
+    let status = luaL_loadfile(L, filename);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dostring(L: *mut lua_State, s: *const c_char) -> c_int {
+    let status = luaL_loadstring(L, s);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
+    lua::lua_getfield(L, lua::LUA_REGISTRYINDEX, n);
+}
+
+// luaL_opt would be implemented here but it is undocumented, so it's omitted
+
+#[inline(always)]
+pub unsafe fn luaL_loadbuffer(
+    L: *mut lua_State,
+    s: *const c_char,
+    sz: usize,
+    n: *const c_char,
+) -> c_int {
+    luaL_loadbufferx(L, s, sz, n, ptr::null())
+}
+
+//
+// TODO: Generic Buffer Manipulation
+//
@@ -0,0 +1,494 @@
+//! Contains definitions from `lua.h`.
+
+use std::marker::{PhantomData, PhantomPinned};
+use std::mem;
+use std::os::raw::{c_char, c_double, c_int, c_uchar, c_void};
+use std::ptr;
+
+// Mark for precompiled code (`<esc>Lua`)
+pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
+
+// Option for multiple returns in 'lua_pcall' and 'lua_call'
+pub const LUA_MULTRET: c_int = -1;
+
+// Size of the Lua stack
+pub const LUAI_MAXSTACK: c_int = 1000000;
+
+// Size of a raw memory area associated with  a Lua state with very fast access.
+pub const LUA_EXTRASPACE: usize = mem::size_of::<*const ()>();
+
+//
+// Pseudo-indices
+//
+pub const LUA_REGISTRYINDEX: c_int = -LUAI_MAXSTACK - 1000;
+
+pub const fn lua_upvalueindex(i: c_int) -> c_int {
+    LUA_REGISTRYINDEX - i
+}
+
+//
+// Thread status
+//
+pub const LUA_OK: c_int = 0;
+pub const LUA_YIELD: c_int = 1;
+pub const LUA_ERRRUN: c_int = 2;
+pub const LUA_ERRSYNTAX: c_int = 3;
+pub const LUA_ERRMEM: c_int = 4;
+pub const LUA_ERRGCMM: c_int = 5;
+pub const LUA_ERRERR: c_int = 6;
+
+/// A raw Lua state associated with a thread.
+#[repr(C)]
+pub struct lua_State {
+    _data: [u8; 0],
+    _marker: PhantomData<(*mut u8, PhantomPinned)>,
+}
+
+//
+// Basic types
+//
+pub const LUA_TNONE: c_int = -1;
+
+pub const LUA_TNIL: c_int = 0;
+pub const LUA_TBOOLEAN: c_int = 1;
+pub const LUA_TLIGHTUSERDATA: c_int = 2;
+pub const LUA_TNUMBER: c_int = 3;
+pub const LUA_TSTRING: c_int = 4;
+pub const LUA_TTABLE: c_int = 5;
+pub const LUA_TFUNCTION: c_int = 6;
+pub const LUA_TUSERDATA: c_int = 7;
+pub const LUA_TTHREAD: c_int = 8;
+
+pub const LUA_NUMTAGS: c_int = 9;
+
+/// Minimum Lua stack available to a C function
+pub const LUA_MINSTACK: c_int = 20;
+
+// Predefined values in the registry
+pub const LUA_RIDX_MAINTHREAD: lua_Integer = 1;
+pub const LUA_RIDX_GLOBALS: lua_Integer = 2;
+pub const LUA_RIDX_LAST: lua_Integer = LUA_RIDX_GLOBALS;
+
+/// A Lua number, usually equivalent to `f64`
+pub type lua_Number = c_double;
+
+/// A Lua integer, usually equivalent to `i64`
+pub type lua_Integer = i64;
+
+/// A Lua unsigned integer, usually equivalent to `u64`
+pub type lua_Unsigned = u64;
+
+/// Type for continuation-function contexts
+pub type lua_KContext = isize;
+
+/// Type for native C functions that can be passed to Lua
+pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;
+
+/// Type for continuation functions
+pub type lua_KFunction =
+    unsafe extern "C" fn(L: *mut lua_State, status: c_int, ctx: lua_KContext) -> c_int;
+
+// Type for functions that read/write blocks when loading/dumping Lua chunks
+pub type lua_Reader =
+    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+pub type lua_Writer =
+    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+
+/// Type for memory-allocation functions
+pub type lua_Alloc = unsafe extern "C" fn(
+    ud: *mut c_void,
+    ptr: *mut c_void,
+    osize: usize,
+    nsize: usize,
+) -> *mut c_void;
+
+extern "C" {
+    //
+    // State manipulation
+    //
+    pub fn lua_newstate(f: lua_Alloc, ud: *mut c_void) -> *mut lua_State;
+    pub fn lua_close(L: *mut lua_State);
+    pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
+
+    pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
+
+    pub fn lua_version(L: *mut lua_State) -> *const lua_Number;
+
+    //
+    // Basic stack manipulation
+    //
+    pub fn lua_absindex(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_gettop(L: *mut lua_State) -> c_int;
+    pub fn lua_settop(L: *mut lua_State, idx: c_int);
+    pub fn lua_pushvalue(L: *mut lua_State, idx: c_int);
+    pub fn lua_rotate(L: *mut lua_State, idx: c_int, n: c_int);
+    pub fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int);
+    pub fn lua_checkstack(L: *mut lua_State, sz: c_int) -> c_int;
+
+    pub fn lua_xmove(from: *mut lua_State, to: *mut lua_State, n: c_int);
+
+    //
+    // Access functions (stack -> C)
+    //
+    pub fn lua_isnumber(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isstring(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_iscfunction(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isuserdata(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_type(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_typename(L: *mut lua_State, tp: c_int) -> *const c_char;
+
+    pub fn lua_tonumberx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Number;
+    pub fn lua_tointegerx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Integer;
+    pub fn lua_toboolean(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+    pub fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize;
+    pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> Option<lua_CFunction>;
+    pub fn lua_touserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
+    pub fn lua_tothread(L: *mut lua_State, idx: c_int) -> *mut lua_State;
+    pub fn lua_topointer(L: *mut lua_State, idx: c_int) -> *const c_void;
+}
+
+//
+// Comparison and arithmetic functions
+//
+pub const LUA_OPADD: c_int = 0;
+pub const LUA_OPSUB: c_int = 1;
+pub const LUA_OPMUL: c_int = 2;
+pub const LUA_OPMOD: c_int = 3;
+pub const LUA_OPPOW: c_int = 4;
+pub const LUA_OPDIV: c_int = 5;
+pub const LUA_OPIDIV: c_int = 6;
+pub const LUA_OPBAND: c_int = 7;
+pub const LUA_OPBOR: c_int = 8;
+pub const LUA_OPBXOR: c_int = 9;
+pub const LUA_OPSHL: c_int = 10;
+pub const LUA_OPSHR: c_int = 11;
+pub const LUA_OPUNM: c_int = 12;
+pub const LUA_OPBNOT: c_int = 13;
+
+extern "C" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
+}
+
+pub const LUA_OPEQ: c_int = 0;
+pub const LUA_OPLT: c_int = 1;
+pub const LUA_OPLE: c_int = 2;
+
+extern "C" {
+    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
+}
+
+extern "C" {
+    //
+    // Push functions (C -> stack)
+    //
+    pub fn lua_pushnil(L: *mut lua_State);
+    pub fn lua_pushnumber(L: *mut lua_State, n: lua_Number);
+    pub fn lua_pushinteger(L: *mut lua_State, n: lua_Integer);
+    pub fn lua_pushlstring(L: *mut lua_State, s: *const c_char, len: usize) -> *const c_char;
+    pub fn lua_pushstring(L: *mut lua_State, s: *const c_char) -> *const c_char;
+    // lua_pushvfstring
+    pub fn lua_pushfstring(L: *mut lua_State, fmt: *const c_char, ...) -> *const c_char;
+    pub fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, n: c_int);
+    pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
+    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void);
+    pub fn lua_pushthread(L: *mut lua_State) -> c_int;
+
+    //
+    // Get functions (Lua -> stack)
+    //
+    pub fn lua_getglobal(L: *mut lua_State, name: *const c_char) -> c_int;
+    pub fn lua_gettable(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int;
+    pub fn lua_geti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int;
+    pub fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int;
+    pub fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int;
+
+    pub fn lua_createtable(L: *mut lua_State, narr: c_int, nrec: c_int);
+    pub fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void;
+    pub fn lua_getmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int;
+
+    //
+    // Set functions (stack -> Lua)
+    //
+    pub fn lua_setglobal(L: *mut lua_State, name: *const c_char);
+    pub fn lua_settable(L: *mut lua_State, idx: c_int);
+    pub fn lua_setfield(L: *mut lua_State, idx: c_int, k: *const c_char);
+    pub fn lua_seti(L: *mut lua_State, idx: c_int, n: lua_Integer);
+    pub fn lua_rawset(L: *mut lua_State, idx: c_int);
+    pub fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer);
+    pub fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void);
+    pub fn lua_setmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_setuservalue(L: *mut lua_State, idx: c_int);
+
+    //
+    // 'load' and 'call' functions (load and run Lua code)
+    //
+    pub fn lua_callk(
+        L: *mut lua_State,
+        nargs: c_int,
+        nresults: c_int,
+        ctx: lua_KContext,
+        k: Option<lua_KFunction>,
+    );
+    pub fn lua_pcallk(
+        L: *mut lua_State,
+        nargs: c_int,
+        nresults: c_int,
+        errfunc: c_int,
+        ctx: lua_KContext,
+        k: Option<lua_KFunction>,
+    ) -> c_int;
+
+    pub fn lua_load(
+        L: *mut lua_State,
+        reader: lua_Reader,
+        data: *mut c_void,
+        chunkname: *const c_char,
+        mode: *const c_char,
+    ) -> c_int;
+
+    pub fn lua_dump(
+        L: *mut lua_State,
+        writer: lua_Writer,
+        data: *mut c_void,
+        strip: c_int,
+    ) -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn lua_call(L: *mut lua_State, n: c_int, r: c_int) {
+    lua_callk(L, n, r, 0, None)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_int {
+    lua_pcallk(L, n, r, f, 0, None)
+}
+
+extern "C" {
+    //
+    // Coroutine functions
+    //
+    pub fn lua_yieldk(
+        L: *mut lua_State,
+        nresults: c_int,
+        ctx: lua_KContext,
+        k: Option<lua_KFunction>,
+    ) -> c_int;
+    #[link_name = "lua_resume"]
+    pub fn lua_resume_(L: *mut lua_State, from: *mut lua_State, narg: c_int) -> c_int;
+    pub fn lua_status(L: *mut lua_State) -> c_int;
+    pub fn lua_isyieldable(L: *mut lua_State) -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn lua_yield(L: *mut lua_State, n: c_int) -> c_int {
+    lua_yieldk(L, n, 0, None)
+}
+
+//
+// Garbage-collection function and options
+//
+pub const LUA_GCSTOP: c_int = 0;
+pub const LUA_GCRESTART: c_int = 1;
+pub const LUA_GCCOLLECT: c_int = 2;
+pub const LUA_GCCOUNT: c_int = 3;
+pub const LUA_GCCOUNTB: c_int = 4;
+pub const LUA_GCSTEP: c_int = 5;
+pub const LUA_GCSETPAUSE: c_int = 6;
+pub const LUA_GCSETSTEPMUL: c_int = 7;
+pub const LUA_GCISRUNNING: c_int = 9;
+
+extern "C" {
+    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
+}
+
+extern "C" {
+    //
+    // Miscellaneous functions
+    //
+    pub fn lua_error(L: *mut lua_State) -> !;
+    pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_concat(L: *mut lua_State, n: c_int);
+    pub fn lua_len(L: *mut lua_State, idx: c_int);
+    pub fn lua_stringtonumber(L: *mut lua_State, s: *const c_char) -> usize;
+    pub fn lua_getallocf(L: *mut lua_State, ud: *mut *mut c_void) -> lua_Alloc;
+    pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut c_void);
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+#[inline(always)]
+pub unsafe fn lua_getextraspace(L: *mut lua_State) -> *mut c_void {
+    (L as *mut c_char).sub(LUA_EXTRASPACE) as *mut c_void
+}
+
+#[inline(always)]
+pub unsafe fn lua_tonumber(L: *mut lua_State, i: c_int) -> lua_Number {
+    lua_tonumberx(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_tointeger(L: *mut lua_State, i: c_int) -> lua_Integer {
+    lua_tointegerx(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_pop(L: *mut lua_State, n: c_int) {
+    lua_settop(L, -n - 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newtable(L: *mut lua_State) {
+    lua_createtable(L, 0, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_register(L: *mut lua_State, n: *const c_char, f: lua_CFunction) {
+    lua_pushcfunction(L, f);
+    lua_setglobal(L, n)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
+    lua_pushcclosure(L, f, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TFUNCTION) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_istable(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTABLE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_islightuserdata(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TLIGHTUSERDATA) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNIL) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isboolean(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TBOOLEAN) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isthread(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTHREAD) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnone(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNONE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) <= 0) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) -> *const c_char {
+    use std::ffi::CString;
+    let c_str = CString::new(s).unwrap();
+    lua_pushlstring(L, c_str.as_ptr(), c_str.as_bytes().len())
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushglobaltable(L: *mut lua_State) -> c_int {
+    lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
+}
+
+#[inline(always)]
+pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua_tolstring(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_insert(L: *mut lua_State, idx: c_int) {
+    lua_rotate(L, idx, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_remove(L: *mut lua_State, idx: c_int) {
+    lua_rotate(L, idx, -1);
+    lua_pop(L, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_replace(L: *mut lua_State, idx: c_int) {
+    lua_copy(L, -1, idx);
+    lua_pop(L, 1)
+}
+
+//
+// Debug API
+//
+
+// Maximum size for the description of the source of a function in debug information.
+const LUA_IDSIZE: usize = 60;
+
+// Event codes
+pub const LUA_HOOKCALL: c_int = 0;
+pub const LUA_HOOKRET: c_int = 1;
+pub const LUA_HOOKLINE: c_int = 2;
+pub const LUA_HOOKCOUNT: c_int = 3;
+pub const LUA_HOOKTAILCALL: c_int = 4;
+
+// Event masks
+pub const LUA_MASKCALL: c_int = 1 << (LUA_HOOKCALL as usize);
+pub const LUA_MASKRET: c_int = 1 << (LUA_HOOKRET as usize);
+pub const LUA_MASKLINE: c_int = 1 << (LUA_HOOKLINE as usize);
+pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
+
+/// Type for functions to be called on debug events.
+pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+
+extern "C" {
+    pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    pub fn lua_setlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    pub fn lua_getupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
+    pub fn lua_setupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
+
+    pub fn lua_upvalueid(L: *mut lua_State, fidx: c_int, n: c_int) -> *mut c_void;
+    pub fn lua_upvaluejoin(L: *mut lua_State, fidx1: c_int, n1: c_int, fidx2: c_int, n2: c_int);
+
+    pub fn lua_sethook(L: *mut lua_State, func: Option<lua_Hook>, mask: c_int, count: c_int);
+    pub fn lua_gethook(L: *mut lua_State) -> Option<lua_Hook>;
+    pub fn lua_gethookmask(L: *mut lua_State) -> c_int;
+    pub fn lua_gethookcount(L: *mut lua_State) -> c_int;
+}
+
+#[repr(C)]
+pub struct lua_Debug {
+    pub event: c_int,
+    pub name: *const c_char,
+    pub namewhat: *const c_char,
+    pub what: *const c_char,
+    pub source: *const c_char,
+    pub currentline: c_int,
+    pub linedefined: c_int,
+    pub lastlinedefined: c_int,
+    pub nups: c_uchar,
+    pub nparams: c_uchar,
+    pub isvararg: c_char,
+    pub istailcall: c_char,
+    pub short_src: [c_char; LUA_IDSIZE],
+    // lua.h mentions this is for private use
+    i_ci: *mut c_void,
+}
@@ -0,0 +1,33 @@
+//! Contains definitions from `lualib.h`.
+
+use std::os::raw::c_int;
+
+use super::lua::lua_State;
+
+pub const LUA_COLIBNAME: &str = "coroutine";
+pub const LUA_TABLIBNAME: &str = "table";
+pub const LUA_IOLIBNAME: &str = "io";
+pub const LUA_OSLIBNAME: &str = "os";
+pub const LUA_STRLIBNAME: &str = "string";
+pub const LUA_UTF8LIBNAME: &str = "utf8";
+pub const LUA_BITLIBNAME: &str = "bit32";
+pub const LUA_MATHLIBNAME: &str = "math";
+pub const LUA_DBLIBNAME: &str = "debug";
+pub const LUA_LOADLIBNAME: &str = "package";
+
+extern "C" {
+    pub fn luaopen_base(L: *mut lua_State) -> c_int;
+    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
+    pub fn luaopen_table(L: *mut lua_State) -> c_int;
+    pub fn luaopen_io(L: *mut lua_State) -> c_int;
+    pub fn luaopen_os(L: *mut lua_State) -> c_int;
+    pub fn luaopen_string(L: *mut lua_State) -> c_int;
+    pub fn luaopen_utf8(L: *mut lua_State) -> c_int;
+    pub fn luaopen_bit32(L: *mut lua_State) -> c_int;
+    pub fn luaopen_math(L: *mut lua_State) -> c_int;
+    pub fn luaopen_debug(L: *mut lua_State) -> c_int;
+    pub fn luaopen_package(L: *mut lua_State) -> c_int;
+
+    // open all builtin libraries
+    pub fn luaL_openlibs(L: *mut lua_State);
+}
@@ -0,0 +1,11 @@
+//! Low level bindings to Lua 5.3.
+
+pub use compat::*;
+pub use lauxlib::*;
+pub use lua::*;
+pub use lualib::*;
+
+pub mod compat;
+pub mod lauxlib;
+pub mod lua;
+pub mod lualib;
@@ -0,0 +1,186 @@
+//! Contains definitions from `lauxlib.h`.
+
+use std::os::raw::{c_char, c_int, c_void};
+use std::ptr;
+
+use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State};
+
+// Extra error code for 'luaL_loadfilex'
+pub const LUA_ERRFILE: c_int = lua::LUA_ERRERR + 1;
+
+// Key, in the registry, for table of loaded modules
+pub const LUA_LOADED_TABLE: &str = "_LOADED";
+
+// Key, in the registry, for table of preloaded loaders
+pub const LUA_PRELOAD_TABLE: &str = "_PRELOAD";
+
+#[repr(C)]
+pub struct luaL_Reg {
+    pub name: *const c_char,
+    pub func: lua_CFunction,
+}
+
+extern "C" {
+    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number, sz: usize);
+
+    pub fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    pub fn luaL_callmeta(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    pub fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+    pub fn luaL_argerror(L: *mut lua_State, arg: c_int, extramsg: *const c_char) -> c_int;
+    pub fn luaL_checklstring(L: *mut lua_State, arg: c_int, l: *mut usize) -> *const c_char;
+    pub fn luaL_optlstring(
+        L: *mut lua_State,
+        arg: c_int,
+        def: *const c_char,
+        l: *mut usize,
+    ) -> *const c_char;
+    pub fn luaL_checknumber(L: *mut lua_State, arg: c_int) -> lua_Number;
+    pub fn luaL_optnumber(L: *mut lua_State, arg: c_int, def: lua_Number) -> lua_Number;
+    pub fn luaL_checkinteger(L: *mut lua_State, arg: c_int) -> lua_Integer;
+    pub fn luaL_optinteger(L: *mut lua_State, arg: c_int, def: lua_Integer) -> lua_Integer;
+
+    pub fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char);
+    pub fn luaL_checktype(L: *mut lua_State, arg: c_int, t: c_int);
+    pub fn luaL_checkany(L: *mut lua_State, arg: c_int);
+
+    pub fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_int;
+    pub fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char);
+    pub fn luaL_testudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
+    pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
+
+    pub fn luaL_where(L: *mut lua_State, lvl: c_int);
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
+
+    pub fn luaL_checkoption(
+        L: *mut lua_State,
+        arg: c_int,
+        def: *const c_char,
+        lst: *const *const c_char,
+    ) -> c_int;
+
+    pub fn luaL_fileresult(L: *mut lua_State, stat: c_int, fname: *const c_char) -> c_int;
+    pub fn luaL_execresult(L: *mut lua_State, stat: c_int) -> c_int;
+}
+
+// Pre-defined references
+pub const LUA_NOREF: c_int = -2;
+pub const LUA_REFNIL: c_int = -1;
+
+extern "C" {
+    pub fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int;
+    pub fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int);
+
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char)
+        -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
+    luaL_loadfilex(L, f, ptr::null())
+}
+
+extern "C" {
+    pub fn luaL_loadbufferx(
+        L: *mut lua_State,
+        buff: *const c_char,
+        sz: usize,
+        name: *const c_char,
+        mode: *const c_char,
+    ) -> c_int;
+    pub fn luaL_loadstring(L: *mut lua_State, s: *const c_char) -> c_int;
+
+    pub fn luaL_newstate() -> *mut lua_State;
+
+    pub fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer;
+
+    // TODO: luaL_addgsub
+
+    pub fn luaL_gsub(
+        L: *mut lua_State,
+        s: *const c_char,
+        p: *const c_char,
+        r: *const c_char,
+    ) -> *const c_char;
+
+    pub fn luaL_setfuncs(L: *mut lua_State, l: *const luaL_Reg, nup: c_int);
+
+    pub fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_char) -> c_int;
+
+    pub fn luaL_traceback(L: *mut lua_State, L1: *mut lua_State, msg: *const c_char, level: c_int);
+
+    pub fn luaL_requiref(
+        L: *mut lua_State,
+        modname: *const c_char,
+        openf: lua_CFunction,
+        glb: c_int,
+    );
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+
+// TODO: luaL_newlibtable, luaL_newlib
+
+#[inline(always)]
+pub unsafe fn luaL_argcheck(L: *mut lua_State, cond: c_int, arg: c_int, extramsg: *const c_char) {
+    if cond == 0 {
+        luaL_argerror(L, arg, extramsg);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_checkstring(L: *mut lua_State, n: c_int) -> *const c_char {
+    luaL_checklstring(L, n, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *const c_char {
+    luaL_optlstring(L, n, d, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_typename(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua::lua_typename(L, lua::lua_type(L, i))
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dofile(L: *mut lua_State, filename: *const c_char) -> c_int {
+    let status = luaL_loadfile(L, filename);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_dostring(L: *mut lua_State, s: *const c_char) -> c_int {
+    let status = luaL_loadstring(L, s);
+    if status == 0 {
+        lua::lua_pcall(L, 0, lua::LUA_MULTRET, 0)
+    } else {
+        status
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
+    lua::lua_getfield(L, lua::LUA_REGISTRYINDEX, n);
+}
+
+// luaL_opt would be implemented here but it is undocumented, so it's omitted
+
+#[inline(always)]
+pub unsafe fn luaL_loadbuffer(
+    L: *mut lua_State,
+    s: *const c_char,
+    sz: usize,
+    n: *const c_char,
+) -> c_int {
+    luaL_loadbufferx(L, s, sz, n, ptr::null())
+}
+
+//
+// TODO: Generic Buffer Manipulation
+//
@@ -0,0 +1,533 @@
+//! Contains definitions from `lua.h`.
+
+use std::marker::{PhantomData, PhantomPinned};
+use std::mem;
+use std::os::raw::{c_char, c_double, c_int, c_uchar, c_ushort, c_void};
+use std::ptr;
+
+// Mark for precompiled code (`<esc>Lua`)
+pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
+
+// Option for multiple returns in 'lua_pcall' and 'lua_call'
+pub const LUA_MULTRET: c_int = -1;
+
+// Size of the Lua stack
+pub const LUAI_MAXSTACK: c_int = 1000000;
+
+// Size of a raw memory area associated with  a Lua state with very fast access.
+pub const LUA_EXTRASPACE: usize = mem::size_of::<*const ()>();
+
+//
+// Pseudo-indices
+//
+pub const LUA_REGISTRYINDEX: c_int = -LUAI_MAXSTACK - 1000;
+
+pub const fn lua_upvalueindex(i: c_int) -> c_int {
+    LUA_REGISTRYINDEX - i
+}
+
+//
+// Thread status
+//
+pub const LUA_OK: c_int = 0;
+pub const LUA_YIELD: c_int = 1;
+pub const LUA_ERRRUN: c_int = 2;
+pub const LUA_ERRSYNTAX: c_int = 3;
+pub const LUA_ERRMEM: c_int = 4;
+pub const LUA_ERRERR: c_int = 5;
+
+/// A raw Lua state associated with a thread.
+#[repr(C)]
+pub struct lua_State {
+    _data: [u8; 0],
+    _marker: PhantomData<(*mut u8, PhantomPinned)>,
+}
+
+//
+// Basic types
+//
+pub const LUA_TNONE: c_int = -1;
+
+pub const LUA_TNIL: c_int = 0;
+pub const LUA_TBOOLEAN: c_int = 1;
+pub const LUA_TLIGHTUSERDATA: c_int = 2;
+pub const LUA_TNUMBER: c_int = 3;
+pub const LUA_TSTRING: c_int = 4;
+pub const LUA_TTABLE: c_int = 5;
+pub const LUA_TFUNCTION: c_int = 6;
+pub const LUA_TUSERDATA: c_int = 7;
+pub const LUA_TTHREAD: c_int = 8;
+
+pub const LUA_NUMTYPES: c_int = 9;
+
+/// Minimum Lua stack available to a C function
+pub const LUA_MINSTACK: c_int = 20;
+
+// Predefined values in the registry
+pub const LUA_RIDX_MAINTHREAD: lua_Integer = 1;
+pub const LUA_RIDX_GLOBALS: lua_Integer = 2;
+pub const LUA_RIDX_LAST: lua_Integer = LUA_RIDX_GLOBALS;
+
+/// A Lua number, usually equivalent to `f64`
+pub type lua_Number = c_double;
+
+/// A Lua integer, usually equivalent to `i64`
+pub type lua_Integer = i64;
+
+/// A Lua unsigned integer, usually equivalent to `u64`
+pub type lua_Unsigned = u64;
+
+/// Type for continuation-function contexts
+pub type lua_KContext = isize;
+
+/// Type for native C functions that can be passed to Lua
+pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;
+
+/// Type for continuation functions
+pub type lua_KFunction =
+    unsafe extern "C" fn(L: *mut lua_State, status: c_int, ctx: lua_KContext) -> c_int;
+
+// Type for functions that read/write blocks when loading/dumping Lua chunks
+pub type lua_Reader =
+    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+pub type lua_Writer =
+    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+
+/// Type for memory-allocation functions
+pub type lua_Alloc = unsafe extern "C" fn(
+    ud: *mut c_void,
+    ptr: *mut c_void,
+    osize: usize,
+    nsize: usize,
+) -> *mut c_void;
+
+/// Type for warning functions
+pub type lua_WarnFunction =
+    unsafe extern "C" fn(ud: *mut c_void, msg: *const c_char, tocont: c_int);
+
+extern "C" {
+    //
+    // State manipulation
+    //
+    pub fn lua_newstate(f: lua_Alloc, ud: *mut c_void) -> *mut lua_State;
+    pub fn lua_close(L: *mut lua_State);
+    pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
+    pub fn lua_resetthread(L: *mut lua_State) -> c_int;
+
+    pub fn lua_atpanic(L: *mut lua_State, panicf: lua_CFunction) -> lua_CFunction;
+
+    pub fn lua_version(L: *mut lua_State) -> lua_Number;
+
+    //
+    // Basic stack manipulation
+    //
+    pub fn lua_absindex(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_gettop(L: *mut lua_State) -> c_int;
+    pub fn lua_settop(L: *mut lua_State, idx: c_int);
+    pub fn lua_pushvalue(L: *mut lua_State, idx: c_int);
+    pub fn lua_rotate(L: *mut lua_State, idx: c_int, n: c_int);
+    pub fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int);
+    pub fn lua_checkstack(L: *mut lua_State, sz: c_int) -> c_int;
+
+    pub fn lua_xmove(from: *mut lua_State, to: *mut lua_State, n: c_int);
+
+    //
+    // Access functions (stack -> C)
+    //
+    pub fn lua_isnumber(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isstring(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_iscfunction(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isuserdata(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_type(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_typename(L: *mut lua_State, tp: c_int) -> *const c_char;
+
+    pub fn lua_tonumberx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Number;
+    pub fn lua_tointegerx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Integer;
+    pub fn lua_toboolean(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+    pub fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize;
+    pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> Option<lua_CFunction>;
+    pub fn lua_touserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
+    pub fn lua_tothread(L: *mut lua_State, idx: c_int) -> *mut lua_State;
+    pub fn lua_topointer(L: *mut lua_State, idx: c_int) -> *const c_void;
+}
+
+//
+// Comparison and arithmetic functions
+//
+pub const LUA_OPADD: c_int = 0;
+pub const LUA_OPSUB: c_int = 1;
+pub const LUA_OPMUL: c_int = 2;
+pub const LUA_OPMOD: c_int = 3;
+pub const LUA_OPPOW: c_int = 4;
+pub const LUA_OPDIV: c_int = 5;
+pub const LUA_OPIDIV: c_int = 6;
+pub const LUA_OPBAND: c_int = 7;
+pub const LUA_OPBOR: c_int = 8;
+pub const LUA_OPBXOR: c_int = 9;
+pub const LUA_OPSHL: c_int = 10;
+pub const LUA_OPSHR: c_int = 11;
+pub const LUA_OPUNM: c_int = 12;
+pub const LUA_OPBNOT: c_int = 13;
+
+extern "C" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
+}
+
+pub const LUA_OPEQ: c_int = 0;
+pub const LUA_OPLT: c_int = 1;
+pub const LUA_OPLE: c_int = 2;
+
+extern "C" {
+    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_compare(L: *mut lua_State, idx1: c_int, idx2: c_int, op: c_int) -> c_int;
+}
+
+extern "C" {
+    //
+    // Push functions (C -> stack)
+    //
+    pub fn lua_pushnil(L: *mut lua_State);
+    pub fn lua_pushnumber(L: *mut lua_State, n: lua_Number);
+    pub fn lua_pushinteger(L: *mut lua_State, n: lua_Integer);
+    pub fn lua_pushlstring(L: *mut lua_State, s: *const c_char, len: usize) -> *const c_char;
+    pub fn lua_pushstring(L: *mut lua_State, s: *const c_char) -> *const c_char;
+    // lua_pushvfstring
+    pub fn lua_pushfstring(L: *mut lua_State, fmt: *const c_char, ...) -> *const c_char;
+    pub fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, n: c_int);
+    pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
+    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void);
+    pub fn lua_pushthread(L: *mut lua_State) -> c_int;
+
+    //
+    // Get functions (Lua -> stack)
+    //
+    pub fn lua_getglobal(L: *mut lua_State, name: *const c_char) -> c_int;
+    pub fn lua_gettable(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int;
+    pub fn lua_geti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int;
+    pub fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int;
+    pub fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int;
+
+    pub fn lua_createtable(L: *mut lua_State, narr: c_int, nrec: c_int);
+    pub fn lua_newuserdatauv(L: *mut lua_State, sz: usize, nuvalue: c_int) -> *mut c_void;
+    pub fn lua_getmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_getiuservalue(L: *mut lua_State, idx: c_int, n: c_int) -> c_int;
+
+    //
+    // Set functions (stack -> Lua)
+    //
+    pub fn lua_setglobal(L: *mut lua_State, name: *const c_char);
+    pub fn lua_settable(L: *mut lua_State, idx: c_int);
+    pub fn lua_setfield(L: *mut lua_State, idx: c_int, k: *const c_char);
+    pub fn lua_seti(L: *mut lua_State, idx: c_int, n: lua_Integer);
+    pub fn lua_rawset(L: *mut lua_State, idx: c_int);
+    pub fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer);
+    pub fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void);
+    pub fn lua_setmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_setiuservalue(L: *mut lua_State, idx: c_int, n: c_int) -> c_int;
+
+    //
+    // 'load' and 'call' functions (load and run Lua code)
+    //
+    pub fn lua_callk(
+        L: *mut lua_State,
+        nargs: c_int,
+        nresults: c_int,
+        ctx: lua_KContext,
+        k: Option<lua_KFunction>,
+    );
+    pub fn lua_pcallk(
+        L: *mut lua_State,
+        nargs: c_int,
+        nresults: c_int,
+        errfunc: c_int,
+        ctx: lua_KContext,
+        k: Option<lua_KFunction>,
+    ) -> c_int;
+
+    pub fn lua_load(
+        L: *mut lua_State,
+        reader: lua_Reader,
+        data: *mut c_void,
+        chunkname: *const c_char,
+        mode: *const c_char,
+    ) -> c_int;
+
+    pub fn lua_dump(
+        L: *mut lua_State,
+        writer: lua_Writer,
+        data: *mut c_void,
+        strip: c_int,
+    ) -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn lua_call(L: *mut lua_State, n: c_int, r: c_int) {
+    lua_callk(L, n, r, 0, None)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_int {
+    lua_pcallk(L, n, r, f, 0, None)
+}
+
+extern "C" {
+    //
+    // Coroutine functions
+    //
+    pub fn lua_yieldk(
+        L: *mut lua_State,
+        nresults: c_int,
+        ctx: lua_KContext,
+        k: Option<lua_KFunction>,
+    ) -> c_int;
+    pub fn lua_resume(
+        L: *mut lua_State,
+        from: *mut lua_State,
+        narg: c_int,
+        nres: *mut c_int,
+    ) -> c_int;
+    pub fn lua_status(L: *mut lua_State) -> c_int;
+    pub fn lua_isyieldable(L: *mut lua_State) -> c_int;
+}
+
+#[inline(always)]
+pub unsafe fn lua_yield(L: *mut lua_State, n: c_int) -> c_int {
+    lua_yieldk(L, n, 0, None)
+}
+
+//
+// Warning-related functions
+//
+extern "C" {
+    pub fn lua_setwarnf(L: *mut lua_State, f: Option<lua_WarnFunction>, ud: *mut c_void);
+    pub fn lua_warning(L: *mut lua_State, msg: *const c_char, tocont: c_int);
+}
+
+//
+// Garbage-collection function and options
+//
+pub const LUA_GCSTOP: c_int = 0;
+pub const LUA_GCRESTART: c_int = 1;
+pub const LUA_GCCOLLECT: c_int = 2;
+pub const LUA_GCCOUNT: c_int = 3;
+pub const LUA_GCCOUNTB: c_int = 4;
+pub const LUA_GCSTEP: c_int = 5;
+pub const LUA_GCSETPAUSE: c_int = 6;
+pub const LUA_GCSETSTEPMUL: c_int = 7;
+pub const LUA_GCISRUNNING: c_int = 9;
+pub const LUA_GCGEN: c_int = 10;
+pub const LUA_GCINC: c_int = 11;
+
+extern "C" {
+    pub fn lua_gc(L: *mut lua_State, what: c_int, ...) -> c_int;
+}
+
+extern "C" {
+    //
+    // Miscellaneous functions
+    //
+    pub fn lua_error(L: *mut lua_State) -> !;
+    pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_concat(L: *mut lua_State, n: c_int);
+    pub fn lua_len(L: *mut lua_State, idx: c_int);
+    pub fn lua_stringtonumber(L: *mut lua_State, s: *const c_char) -> usize;
+    pub fn lua_getallocf(L: *mut lua_State, ud: *mut *mut c_void) -> lua_Alloc;
+    pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut c_void);
+
+    pub fn lua_toclose(L: *mut lua_State, idx: c_int);
+    pub fn lua_closeslot(L: *mut lua_State, idx: c_int);
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+#[inline(always)]
+pub unsafe fn lua_getextraspace(L: *mut lua_State) -> *mut c_void {
+    (L as *mut c_char).sub(LUA_EXTRASPACE) as *mut c_void
+}
+
+#[inline(always)]
+pub unsafe fn lua_tonumber(L: *mut lua_State, i: c_int) -> lua_Number {
+    lua_tonumberx(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_tointeger(L: *mut lua_State, i: c_int) -> lua_Integer {
+    lua_tointegerx(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_pop(L: *mut lua_State, n: c_int) {
+    lua_settop(L, -n - 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newtable(L: *mut lua_State) {
+    lua_createtable(L, 0, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_register(L: *mut lua_State, n: *const c_char, f: lua_CFunction) {
+    lua_pushcfunction(L, f);
+    lua_setglobal(L, n)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
+    lua_pushcclosure(L, f, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TFUNCTION) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_istable(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTABLE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_islightuserdata(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TLIGHTUSERDATA) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNIL) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isboolean(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TBOOLEAN) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isthread(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTHREAD) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnone(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNONE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) <= 0) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) -> *const c_char {
+    use std::ffi::CString;
+    let c_str = CString::new(s).unwrap();
+    lua_pushlstring(L, c_str.as_ptr(), c_str.as_bytes().len())
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushglobaltable(L: *mut lua_State) -> c_int {
+    lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
+}
+
+#[inline(always)]
+pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua_tolstring(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_insert(L: *mut lua_State, idx: c_int) {
+    lua_rotate(L, idx, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_remove(L: *mut lua_State, idx: c_int) {
+    lua_rotate(L, idx, -1);
+    lua_pop(L, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_replace(L: *mut lua_State, idx: c_int) {
+    lua_copy(L, -1, idx);
+    lua_pop(L, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void {
+    lua_newuserdatauv(L, sz, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_getuservalue(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_getiuservalue(L, idx, 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_setuservalue(L: *mut lua_State, idx: c_int) -> c_int {
+    lua_setiuservalue(L, idx, 1)
+}
+
+//
+// Debug API
+//
+
+// Maximum size for the description of the source of a function in debug information.
+const LUA_IDSIZE: usize = 60;
+
+// Event codes
+pub const LUA_HOOKCALL: c_int = 0;
+pub const LUA_HOOKRET: c_int = 1;
+pub const LUA_HOOKLINE: c_int = 2;
+pub const LUA_HOOKCOUNT: c_int = 3;
+pub const LUA_HOOKTAILCALL: c_int = 4;
+
+// Event masks
+pub const LUA_MASKCALL: c_int = 1 << (LUA_HOOKCALL as usize);
+pub const LUA_MASKRET: c_int = 1 << (LUA_HOOKRET as usize);
+pub const LUA_MASKLINE: c_int = 1 << (LUA_HOOKLINE as usize);
+pub const LUA_MASKCOUNT: c_int = 1 << (LUA_HOOKCOUNT as usize);
+
+/// Type for functions to be called on debug events.
+pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+
+extern "C" {
+    pub fn lua_getstack(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getinfo(L: *mut lua_State, what: *const c_char, ar: *mut lua_Debug) -> c_int;
+    pub fn lua_getlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    pub fn lua_setlocal(L: *mut lua_State, ar: *const lua_Debug, n: c_int) -> *const c_char;
+    pub fn lua_getupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
+    pub fn lua_setupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
+
+    pub fn lua_upvalueid(L: *mut lua_State, fidx: c_int, n: c_int) -> *mut c_void;
+    pub fn lua_upvaluejoin(L: *mut lua_State, fidx1: c_int, n1: c_int, fidx2: c_int, n2: c_int);
+
+    pub fn lua_sethook(L: *mut lua_State, func: Option<lua_Hook>, mask: c_int, count: c_int);
+    pub fn lua_gethook(L: *mut lua_State) -> Option<lua_Hook>;
+    pub fn lua_gethookmask(L: *mut lua_State) -> c_int;
+    pub fn lua_gethookcount(L: *mut lua_State) -> c_int;
+}
+
+#[repr(C)]
+pub struct lua_Debug {
+    pub event: c_int,
+    pub name: *const c_char,
+    pub namewhat: *const c_char,
+    pub what: *const c_char,
+    pub source: *const c_char,
+    pub srclen: usize,
+    pub currentline: c_int,
+    pub linedefined: c_int,
+    pub lastlinedefined: c_int,
+    pub nups: c_uchar,
+    pub nparams: c_uchar,
+    pub isvararg: c_char,
+    pub istailcall: c_char,
+    pub ftransfer: c_ushort,
+    pub ntransfer: c_ushort,
+    pub short_src: [c_char; LUA_IDSIZE],
+    // lua.h mentions this is for private use
+    i_ci: *mut c_void,
+}
@@ -0,0 +1,31 @@
+//! Contains definitions from `lualib.h`.
+
+use std::os::raw::c_int;
+
+use super::lua::lua_State;
+
+pub const LUA_COLIBNAME: &str = "coroutine";
+pub const LUA_TABLIBNAME: &str = "table";
+pub const LUA_IOLIBNAME: &str = "io";
+pub const LUA_OSLIBNAME: &str = "os";
+pub const LUA_STRLIBNAME: &str = "string";
+pub const LUA_UTF8LIBNAME: &str = "utf8";
+pub const LUA_MATHLIBNAME: &str = "math";
+pub const LUA_DBLIBNAME: &str = "debug";
+pub const LUA_LOADLIBNAME: &str = "package";
+
+extern "C" {
+    pub fn luaopen_base(L: *mut lua_State) -> c_int;
+    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
+    pub fn luaopen_table(L: *mut lua_State) -> c_int;
+    pub fn luaopen_io(L: *mut lua_State) -> c_int;
+    pub fn luaopen_os(L: *mut lua_State) -> c_int;
+    pub fn luaopen_string(L: *mut lua_State) -> c_int;
+    pub fn luaopen_utf8(L: *mut lua_State) -> c_int;
+    pub fn luaopen_math(L: *mut lua_State) -> c_int;
+    pub fn luaopen_debug(L: *mut lua_State) -> c_int;
+    pub fn luaopen_package(L: *mut lua_State) -> c_int;
+
+    // open all builtin libraries
+    pub fn luaL_openlibs(L: *mut lua_State);
+}
@@ -0,0 +1,9 @@
+//! Low level bindings to Lua 5.4.
+
+pub use lauxlib::*;
+pub use lua::*;
+pub use lualib::*;
+
+pub mod lauxlib;
+pub mod lua;
+pub mod lualib;
@@ -1,36 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-// Copyright (c) 2014 J.C. Moyer
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//! Contains definitions from `luaconf.h`.
-
-pub use super::glue::LUA_INTEGER;
-pub use super::glue::LUA_NUMBER;
-pub use super::glue::LUA_UNSIGNED;
-
-pub use super::glue::LUA_IDSIZE;
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use super::glue::LUAL_NUMSIZES;
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub type LUA_KCONTEXT = isize; // intptr_t
@@ -1,67 +0,0 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-// Copyright (c) 2014 J.C. Moyer
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//! Contains definitions from `lualib.h`.
-
-use std::os::raw::c_int;
-
-use super::lua::lua_State;
-
-pub use super::glue::{
-    LUA_COLIBNAME, LUA_DBLIBNAME, LUA_IOLIBNAME, LUA_LOADLIBNAME, LUA_MATHLIBNAME, LUA_OSLIBNAME,
-    LUA_STRLIBNAME, LUA_TABLIBNAME,
-};
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use super::glue::LUA_UTF8LIBNAME;
-
-#[cfg(any(feature = "lua52", feature = "luajit"))]
-pub use super::glue::LUA_BITLIBNAME;
-
-#[cfg(feature = "luajit")]
-pub use super::glue::{LUA_FFILIBNAME, LUA_JITLIBNAME};
-
-extern "C" {
-    pub fn luaopen_base(L: *mut lua_State) -> c_int;
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
-    pub fn luaopen_table(L: *mut lua_State) -> c_int;
-    pub fn luaopen_io(L: *mut lua_State) -> c_int;
-    pub fn luaopen_os(L: *mut lua_State) -> c_int;
-    pub fn luaopen_string(L: *mut lua_State) -> c_int;
-    #[cfg(any(feature = "lua54", feature = "lua53"))]
-    pub fn luaopen_utf8(L: *mut lua_State) -> c_int;
-    #[cfg(feature = "lua52")]
-    pub fn luaopen_bit32(L: *mut lua_State) -> c_int;
-    pub fn luaopen_math(L: *mut lua_State) -> c_int;
-    pub fn luaopen_debug(L: *mut lua_State) -> c_int;
-    pub fn luaopen_package(L: *mut lua_State) -> c_int;
-    #[cfg(feature = "luajit")]
-    pub fn luaopen_bit(L: *mut lua_State) -> c_int;
-    #[cfg(feature = "luajit")]
-    pub fn luaopen_jit(L: *mut lua_State) -> c_int;
-    #[cfg(feature = "luajit")]
-    pub fn luaopen_ffi(L: *mut lua_State) -> c_int;
-
-    pub fn luaL_openlibs(L: *mut lua_State);
-}
@@ -0,0 +1,511 @@
+//! MLua compatibility layer for Roblox Luau.
+//!
+//! Based on github.com/keplerproject/lua-compat-5.3
+
+use std::ffi::CStr;
+use std::mem;
+use std::os::raw::{c_char, c_int, c_void};
+use std::ptr;
+
+use super::lauxlib::*;
+use super::lua::*;
+use super::luacode::*;
+
+unsafe fn compat53_reverse(L: *mut lua_State, mut a: c_int, mut b: c_int) {
+    while a < b {
+        lua_pushvalue(L, a);
+        lua_pushvalue(L, b);
+        lua_replace(L, a);
+        lua_replace(L, b);
+        a += 1;
+        b -= 1;
+    }
+}
+
+const COMPAT53_LEVELS1: c_int = 12; // size of the first part of the stack
+const COMPAT53_LEVELS2: c_int = 10; // size of the second part of the stack
+
+unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) -> c_int {
+    if level == 0 || lua_istable(L, -1) == 0 {
+        return 0; // not found
+    }
+
+    lua_pushnil(L); // start 'next' loop
+    while lua_next(L, -2) != 0 {
+        // for each pair in table
+        if lua_type(L, -2) == LUA_TSTRING {
+            // ignore non-string keys
+            if lua_rawequal(L, objidx, -1) != 0 {
+                // found object?
+                lua_pop(L, 1); // remove value (but keep name)
+                return 1;
+            } else if compat53_findfield(L, objidx, level - 1) != 0 {
+                // try recursively
+                lua_remove(L, -2); // remove table (but keep name)
+                lua_pushliteral(L, ".");
+                lua_insert(L, -2); // place '.' between the two names
+                lua_concat(L, 3);
+                return 1;
+            }
+        }
+        lua_pop(L, 1); // remove value
+    }
+    0 // not found
+}
+
+unsafe fn compat53_pushglobalfuncname(
+    L: *mut lua_State,
+    level: c_int,
+    ar: *mut lua_Debug,
+) -> c_int {
+    let top = lua_gettop(L);
+    // push function
+    lua_getinfo(L, level, cstr!("f"), ar);
+    lua_pushvalue(L, LUA_GLOBALSINDEX);
+    if compat53_findfield(L, top + 1, 2) != 0 {
+        lua_copy(L, -1, top + 1); // move name to proper place
+        lua_pop(L, 2); // remove pushed values
+        1
+    } else {
+        lua_settop(L, top); // remove function and global table
+        0
+    }
+}
+
+unsafe fn compat53_pushfuncname(L: *mut lua_State, level: c_int, ar: *mut lua_Debug) {
+    if !(*ar).name.is_null() {
+        // is there a name?
+        lua_pushfstring(L, cstr!("function '%s'"), (*ar).name);
+    } else if compat53_pushglobalfuncname(L, level, ar) != 0 {
+        lua_pushfstring(L, cstr!("function '%s'"), lua_tostring(L, -1));
+        lua_remove(L, -2); // remove name
+    } else {
+        lua_pushliteral(L, "?");
+    }
+}
+
+//
+// lua ported functions
+//
+
+pub unsafe fn lua_rotate(L: *mut lua_State, mut idx: c_int, mut n: c_int) {
+    idx = lua_absindex(L, idx);
+    let n_elems = lua_gettop(L) - idx + 1;
+    if n < 0 {
+        n += n_elems;
+    }
+    if n > 0 && n < n_elems {
+        luaL_checkstack(L, 2, cstr!("not enough stack slots available"));
+        n = n_elems - n;
+        compat53_reverse(L, idx, idx + n - 1);
+        compat53_reverse(L, idx + n, idx + n_elems - 1);
+        compat53_reverse(L, idx, idx + n_elems - 1);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn lua_copy(L: *mut lua_State, fromidx: c_int, toidx: c_int) {
+    let abs_to = lua_absindex(L, toidx);
+    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    lua_pushvalue(L, fromidx);
+    lua_replace(L, abs_to);
+}
+
+#[inline(always)]
+pub unsafe fn lua_isinteger(L: *mut lua_State, idx: c_int) -> c_int {
+    if lua_type(L, idx) == LUA_TNUMBER {
+        let n = lua_tonumber(L, idx);
+        let i = lua_tointeger(L, idx);
+        if (n - i as lua_Number).abs() < lua_Number::EPSILON {
+            return 1;
+        }
+    }
+    0
+}
+
+#[inline(always)]
+pub unsafe fn lua_tointeger(L: *mut lua_State, i: c_int) -> lua_Integer {
+    lua_tointegerx(L, i, ptr::null_mut())
+}
+
+pub unsafe fn lua_tointegerx(L: *mut lua_State, i: c_int, isnum: *mut c_int) -> lua_Integer {
+    let mut ok = 0;
+    let n = lua_tonumberx(L, i, &mut ok);
+    let n_int = n as lua_Integer;
+    if ok != 0 && (n - n_int as lua_Number).abs() < lua_Number::EPSILON {
+        if !isnum.is_null() {
+            *isnum = 1;
+        }
+        return n_int;
+    }
+    if !isnum.is_null() {
+        *isnum = 0;
+    }
+    0
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize {
+    lua_objlen(L, idx)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushlstring(L: *mut lua_State, s: *const c_char, l: usize) -> *const c_char {
+    if l == 0 {
+        lua_pushlstring_(L, cstr!(""), 0);
+    } else {
+        lua_pushlstring_(L, s, l);
+    }
+    lua_tostring(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushstring(L: *mut lua_State, s: *const c_char) -> *const c_char {
+    lua_pushstring_(L, s);
+    lua_tostring(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_geti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) -> c_int {
+    idx = lua_absindex(L, idx);
+    lua_pushinteger(L, n);
+    lua_gettable(L, idx)
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawgeti(L: *mut lua_State, idx: c_int, n: lua_Integer) -> c_int {
+    lua_rawgeti_(L, idx, n)
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawgetp(L: *mut lua_State, idx: c_int, p: *const c_void) -> c_int {
+    let abs_i = lua_absindex(L, idx);
+    lua_pushlightuserdata(L, p as *mut c_void);
+    lua_rawget(L, abs_i)
+}
+
+#[inline(always)]
+pub unsafe fn lua_getuservalue(L: *mut lua_State, mut idx: c_int) -> c_int {
+    luaL_checkstack(L, 2, cstr!("not enough stack slots available"));
+    idx = lua_absindex(L, idx);
+    lua_pushliteral(L, "__mlua_uservalues");
+    if lua_rawget(L, LUA_REGISTRYINDEX) != LUA_TTABLE {
+        return LUA_TNIL;
+    }
+    lua_pushvalue(L, idx);
+    lua_rawget(L, -2);
+    lua_remove(L, -2);
+    lua_type(L, -1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_seti(L: *mut lua_State, mut idx: c_int, n: lua_Integer) {
+    luaL_checkstack(L, 1, cstr!("not enough stack slots available"));
+    idx = lua_absindex(L, idx);
+    lua_pushinteger(L, n);
+    lua_insert(L, -2);
+    lua_settable(L, idx);
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer) {
+    lua_rawseti_(L, idx, n)
+}
+
+#[inline(always)]
+pub unsafe fn lua_rawsetp(L: *mut lua_State, idx: c_int, p: *const c_void) {
+    let abs_i = lua_absindex(L, idx);
+    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    lua_pushlightuserdata(L, p as *mut c_void);
+    lua_insert(L, -2);
+    lua_rawset(L, abs_i);
+}
+
+#[inline(always)]
+pub unsafe fn lua_setuservalue(L: *mut lua_State, mut idx: c_int) {
+    luaL_checkstack(L, 4, cstr!("not enough stack slots available"));
+    idx = lua_absindex(L, idx);
+    lua_pushliteral(L, "__mlua_uservalues");
+    lua_pushvalue(L, -1);
+    if lua_rawget(L, LUA_REGISTRYINDEX) != LUA_TTABLE {
+        lua_pop(L, 1);
+        lua_createtable(L, 0, 2); // main table
+        lua_createtable(L, 0, 1); // metatable
+        lua_pushliteral(L, "k");
+        lua_setfield(L, -2, cstr!("__mode"));
+        lua_setmetatable(L, -2);
+        lua_pushvalue(L, -2);
+        lua_pushvalue(L, -2);
+        lua_rawset(L, LUA_REGISTRYINDEX);
+    }
+    lua_replace(L, -2);
+    lua_pushvalue(L, idx);
+    lua_pushvalue(L, -3);
+    lua_remove(L, -4);
+    lua_rawset(L, -3);
+    lua_pop(L, 1);
+}
+
+#[inline(always)]
+pub unsafe fn lua_len(L: *mut lua_State, idx: c_int) {
+    match lua_type(L, idx) {
+        LUA_TSTRING => {
+            lua_pushnumber(L, lua_objlen(L, idx) as lua_Number);
+        }
+        LUA_TTABLE => {
+            if luaL_callmeta(L, idx, cstr!("__len")) == 0 {
+                lua_pushnumber(L, lua_objlen(L, idx) as lua_Number);
+            }
+        }
+        LUA_TUSERDATA if luaL_callmeta(L, idx, cstr!("__len")) != 0 => {}
+        _ => {
+            luaL_error(
+                L,
+                cstr!("attempt to get length of a %s value"),
+                lua_typename(L, lua_type(L, idx)),
+            );
+        }
+    }
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushglobaltable(L: *mut lua_State) {
+    lua_pushvalue(L, LUA_GLOBALSINDEX);
+}
+
+#[inline(always)]
+pub unsafe fn lua_resume(
+    L: *mut lua_State,
+    from: *mut lua_State,
+    narg: c_int,
+    nres: *mut c_int,
+) -> c_int {
+    let ret = lua_resume_(L, from, narg);
+    if (ret == LUA_OK || ret == LUA_YIELD) && !(nres.is_null()) {
+        *nres = lua_gettop(L);
+    }
+    ret
+}
+
+//
+// lauxlib ported functions
+//
+
+#[inline(always)]
+pub unsafe fn luaL_checkstack(L: *mut lua_State, sz: c_int, msg: *const c_char) {
+    if lua_checkstack(L, sz + LUA_MINSTACK) == 0 {
+        if !msg.is_null() {
+            luaL_error(L, cstr!("stack overflow (%s)"), msg);
+        } else {
+            lua_pushliteral(L, "stack overflow");
+            lua_error(L);
+        }
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int {
+    if luaL_getmetafield_(L, obj, e) != 0 {
+        lua_type(L, -1)
+    } else {
+        LUA_TNIL
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_int {
+    if luaL_newmetatable_(L, tname) != 0 {
+        lua_pushstring(L, tname);
+        lua_setfield(L, -2, cstr!("__name"));
+        1
+    } else {
+        0
+    }
+}
+
+pub unsafe fn luaL_loadbufferx(
+    L: *mut lua_State,
+    data: *const c_char,
+    mut size: usize,
+    name: *const c_char,
+    mode: *const c_char,
+) -> c_int {
+    extern "C" {
+        fn free(p: *mut c_void);
+    }
+
+    let chunk_is_text = (*data as u8) >= b'\n';
+    if !mode.is_null() {
+        let modeb = CStr::from_ptr(mode).to_bytes();
+        if !chunk_is_text && !modeb.contains(&b'b') {
+            lua_pushfstring(
+                L,
+                cstr!("attempt to load a binary chunk (mode is '%s')"),
+                mode,
+            );
+            return LUA_ERRSYNTAX;
+        } else if chunk_is_text && !modeb.contains(&b't') {
+            lua_pushfstring(
+                L,
+                cstr!("attempt to load a text chunk (mode is '%s')"),
+                mode,
+            );
+            return LUA_ERRSYNTAX;
+        }
+    }
+
+    if chunk_is_text {
+        let data = luau_compile_(data, size, ptr::null_mut(), &mut size);
+        let ok = luau_load(L, name, data, size, 0) == 0;
+        free(data as *mut c_void);
+        if !ok {
+            return LUA_ERRSYNTAX;
+        }
+    } else if luau_load(L, name, data, size, 0) != 0 {
+        return LUA_ERRSYNTAX;
+    }
+    LUA_OK
+}
+
+#[inline(always)]
+pub unsafe fn luaL_loadbuffer(
+    L: *mut lua_State,
+    data: *const c_char,
+    size: usize,
+    name: *const c_char,
+) -> c_int {
+    luaL_loadbufferx(L, data, size, name, ptr::null())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer {
+    let mut isnum = 0;
+    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    lua_len(L, idx);
+    let res = lua_tointegerx(L, -1, &mut isnum);
+    lua_pop(L, 1);
+    if isnum == 0 {
+        luaL_error(L, cstr!("object length is not an integer"));
+    }
+    res
+}
+
+pub unsafe fn luaL_traceback(
+    L: *mut lua_State,
+    L1: *mut lua_State,
+    msg: *const c_char,
+    mut level: c_int,
+) {
+    let mut ar: lua_Debug = mem::zeroed();
+    let top = lua_gettop(L);
+    let numlevels = lua_stackdepth(L);
+    let mark = if numlevels > COMPAT53_LEVELS1 + COMPAT53_LEVELS2 {
+        COMPAT53_LEVELS1
+    } else {
+        0
+    };
+
+    if !msg.is_null() {
+        lua_pushfstring(L, cstr!("%s\n"), msg);
+    }
+    lua_pushliteral(L, "stack traceback:");
+    while lua_getinfo(L1, level, cstr!(""), &mut ar) != 0 {
+        if level + 1 == mark {
+            // too many levels?
+            lua_pushliteral(L, "\n\t..."); // add a '...'
+            level = numlevels - COMPAT53_LEVELS2; // and skip to last ones
+        } else {
+            lua_getinfo(L1, level, cstr!("sln"), &mut ar);
+            lua_pushfstring(L, cstr!("\n\t%s:"), ar.short_src.as_ptr());
+            if ar.currentline > 0 {
+                lua_pushfstring(L, cstr!("%d:"), ar.currentline);
+            }
+            lua_pushliteral(L, " in ");
+            compat53_pushfuncname(L, level, &mut ar);
+            lua_concat(L, lua_gettop(L) - top);
+        }
+        level += 1;
+    }
+    lua_concat(L, lua_gettop(L) - top);
+}
+
+pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char {
+    if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
+        let t = lua_type(L, idx);
+        match t {
+            LUA_TNIL => {
+                lua_pushliteral(L, "nil");
+            }
+            LUA_TSTRING | LUA_TNUMBER => {
+                lua_pushvalue(L, idx);
+            }
+            LUA_TBOOLEAN => {
+                if lua_toboolean(L, idx) == 0 {
+                    lua_pushliteral(L, "false");
+                } else {
+                    lua_pushliteral(L, "true");
+                }
+            }
+            _ => {
+                let tt = luaL_getmetafield(L, idx, cstr!("__name"));
+                let name = if tt == LUA_TSTRING {
+                    lua_tostring(L, -1)
+                } else {
+                    lua_typename(L, t)
+                };
+                lua_pushfstring(L, cstr!("%s: %p"), name, lua_topointer(L, idx));
+                if tt != LUA_TNIL {
+                    lua_replace(L, -2);
+                }
+            }
+        };
+    } else if lua_isstring(L, -1) == 0 {
+        luaL_error(L, cstr!("'__tostring' must return a string"));
+    }
+    lua_tolstring(L, -1, len)
+}
+
+#[inline(always)]
+pub unsafe fn luaL_setmetatable(L: *mut lua_State, tname: *const c_char) {
+    luaL_checkstack(L, 1, cstr!("not enough stack slots"));
+    luaL_getmetatable(L, tname);
+    lua_setmetatable(L, -2);
+}
+
+pub unsafe fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_char) -> c_int {
+    let abs_i = lua_absindex(L, idx);
+    luaL_checkstack(L, 3, cstr!("not enough stack slots"));
+    lua_pushstring_(L, fname);
+    if lua_gettable(L, abs_i) == LUA_TTABLE {
+        return 1;
+    }
+    lua_pop(L, 1);
+    lua_newtable(L);
+    lua_pushstring_(L, fname);
+    lua_pushvalue(L, -2);
+    lua_settable(L, abs_i);
+    0
+}
+
+pub unsafe fn luaL_requiref(
+    L: *mut lua_State,
+    modname: *const c_char,
+    openf: lua_CFunction,
+    glb: c_int,
+) {
+    luaL_checkstack(L, 3, cstr!("not enough stack slots available"));
+    luaL_getsubtable(L, LUA_REGISTRYINDEX, cstr!("_LOADED"));
+    if lua_getfield(L, -1, modname) == LUA_TNIL {
+        lua_pop(L, 1);
+        lua_pushcfunction(L, openf);
+        lua_pushstring(L, modname);
+        lua_call(L, 1, 1);
+        lua_pushvalue(L, -1);
+        lua_setfield(L, -3, modname);
+    }
+    if glb != 0 {
+        lua_pushvalue(L, -1);
+        lua_setglobal(L, modname);
+    }
+    lua_replace(L, -2);
+}
@@ -0,0 +1,128 @@
+//! Contains definitions from `lualib.h`.
+
+use std::os::raw::{c_char, c_float, c_int, c_void};
+use std::ptr;
+
+use super::lua::{
+    self, lua_CFunction, lua_Integer, lua_Number, lua_State, lua_Unsigned, LUA_REGISTRYINDEX,
+};
+
+#[repr(C)]
+pub struct luaL_Reg {
+    pub name: *const c_char,
+    pub func: lua_CFunction,
+}
+
+extern "C" {
+    pub fn luaL_register(L: *mut lua_State, libname: *const c_char, l: *const luaL_Reg);
+    #[link_name = "luaL_getmetafield"]
+    pub fn luaL_getmetafield_(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    pub fn luaL_callmeta(L: *mut lua_State, obj: c_int, e: *const c_char) -> c_int;
+    #[link_name = "luaL_typeerrorL"]
+    pub fn luaL_typeerror(L: *mut lua_State, narg: c_int, tname: *const c_char) -> !;
+    #[link_name = "luaL_argerrorL"]
+    pub fn luaL_argerror(L: *mut lua_State, narg: c_int, extramsg: *const c_char) -> !;
+    pub fn luaL_checklstring(L: *mut lua_State, narg: c_int, l: *mut usize) -> *const c_char;
+    pub fn luaL_optlstring(
+        L: *mut lua_State,
+        narg: c_int,
+        def: *const c_char,
+        l: *mut usize,
+    ) -> *const c_char;
+    pub fn luaL_checknumber(L: *mut lua_State, narg: c_int) -> lua_Number;
+    pub fn luaL_optnumber(L: *mut lua_State, narg: c_int, def: lua_Number) -> lua_Number;
+
+    pub fn luaL_checkboolean(L: *mut lua_State, narg: c_int) -> c_int;
+    pub fn luaL_optboolean(L: *mut lua_State, narg: c_int, def: c_int) -> c_int;
+
+    pub fn luaL_checkinteger(L: *mut lua_State, narg: c_int) -> lua_Integer;
+    pub fn luaL_optinteger(L: *mut lua_State, narg: c_int, def: lua_Integer) -> lua_Integer;
+    pub fn luaL_checkunsigned(L: *mut lua_State, narg: c_int) -> lua_Unsigned;
+    pub fn luaL_optunsigned(L: *mut lua_State, narg: c_int, def: lua_Unsigned) -> lua_Unsigned;
+
+    pub fn luaL_checkvector(L: *mut lua_State, narg: c_int) -> *const c_float;
+    pub fn luaL_optvector(L: *mut lua_State, narg: c_int, def: *const c_float) -> *const c_float;
+
+    #[link_name = "luaL_checkstack"]
+    pub fn luaL_checkstack_(L: *mut lua_State, sz: c_int, msg: *const c_char);
+    pub fn luaL_checktype(L: *mut lua_State, narg: c_int, t: c_int);
+    pub fn luaL_checkany(L: *mut lua_State, narg: c_int);
+
+    #[link_name = "luaL_newmetatable"]
+    pub fn luaL_newmetatable_(L: *mut lua_State, tname: *const c_char) -> c_int;
+    pub fn luaL_checkudata(L: *mut lua_State, ud: c_int, tname: *const c_char) -> *mut c_void;
+
+    pub fn luaL_where(L: *mut lua_State, lvl: c_int);
+
+    #[link_name = "luaL_errorL"]
+    pub fn luaL_error(L: *mut lua_State, fmt: *const c_char, ...) -> !;
+
+    pub fn luaL_checkoption(
+        L: *mut lua_State,
+        narg: c_int,
+        def: *const c_char,
+        lst: *const *const c_char,
+    ) -> c_int;
+
+    #[link_name = "luaL_tolstring"]
+    pub fn luaL_tolstring_(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+
+    pub fn luaL_newstate() -> *mut lua_State;
+
+    // TODO: luaL_findtable
+
+    pub fn luaL_typename(L: *mut lua_State, idx: c_int) -> *const c_char;
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+
+#[inline(always)]
+pub unsafe fn luaL_argcheck(L: *mut lua_State, cond: c_int, arg: c_int, extramsg: *const c_char) {
+    if cond == 0 {
+        luaL_argerror(L, arg, extramsg);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_argexpected(L: *mut lua_State, cond: c_int, arg: c_int, tname: *const c_char) {
+    if cond == 0 {
+        luaL_typeerror(L, arg, tname);
+    }
+}
+
+#[inline(always)]
+pub unsafe fn luaL_checkstring(L: *mut lua_State, n: c_int) -> *const c_char {
+    luaL_checklstring(L, n, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn luaL_optstring(L: *mut lua_State, n: c_int, d: *const c_char) -> *const c_char {
+    luaL_optlstring(L, n, d, ptr::null_mut())
+}
+
+// TODO: luaL_opt
+
+#[inline(always)]
+pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) -> c_int {
+    lua::lua_getfield(L, LUA_REGISTRYINDEX, n)
+}
+
+#[inline(always)]
+pub unsafe fn luaL_ref(L: *mut lua_State, t: c_int) -> c_int {
+    assert_eq!(t, LUA_REGISTRYINDEX);
+    let r = lua::lua_ref(L, -1);
+    lua::lua_pop(L, 1);
+    r
+}
+
+#[inline(always)]
+pub unsafe fn luaL_unref(L: *mut lua_State, t: c_int, r#ref: c_int) {
+    assert_eq!(t, LUA_REGISTRYINDEX);
+    lua::lua_unref(L, r#ref)
+}
+
+//
+// TODO: Generic Buffer Manipulation
+//
@@ -0,0 +1,493 @@
+//! Contains definitions from `lua.h`.
+
+use std::marker::{PhantomData, PhantomPinned};
+use std::os::raw::{c_char, c_double, c_float, c_int, c_uint, c_void};
+use std::ptr;
+
+// Option for multiple returns in 'lua_pcall' and 'lua_call'
+pub const LUA_MULTRET: c_int = -1;
+
+//
+// Pseudo-indices
+//
+pub const LUA_REGISTRYINDEX: c_int = -10000;
+pub const LUA_ENVIRONINDEX: c_int = -10001;
+pub const LUA_GLOBALSINDEX: c_int = -10002;
+
+pub const fn lua_upvalueindex(i: c_int) -> c_int {
+    LUA_GLOBALSINDEX - i
+}
+
+//
+// Thread status
+//
+pub const LUA_OK: c_int = 0;
+pub const LUA_YIELD: c_int = 1;
+pub const LUA_ERRRUN: c_int = 2;
+pub const LUA_ERRSYNTAX: c_int = 3;
+pub const LUA_ERRMEM: c_int = 4;
+pub const LUA_ERRERR: c_int = 5;
+
+/// A raw Lua state associated with a thread.
+#[repr(C)]
+pub struct lua_State {
+    _data: [u8; 0],
+    _marker: PhantomData<(*mut u8, PhantomPinned)>,
+}
+
+//
+// Basic types
+//
+pub const LUA_TNONE: c_int = -1;
+
+pub const LUA_TNIL: c_int = 0;
+pub const LUA_TBOOLEAN: c_int = 1;
+
+pub const LUA_TLIGHTUSERDATA: c_int = 2;
+pub const LUA_TNUMBER: c_int = 3;
+pub const LUA_TVECTOR: c_int = 4;
+
+pub const LUA_TSTRING: c_int = 5;
+pub const LUA_TTABLE: c_int = 6;
+pub const LUA_TFUNCTION: c_int = 7;
+pub const LUA_TUSERDATA: c_int = 8;
+pub const LUA_TTHREAD: c_int = 9;
+
+/// Guaranteed number of Lua stack slots available to a C function.
+pub const LUA_MINSTACK: c_int = 20;
+
+/// A Lua number, usually equivalent to `f64`.
+pub type lua_Number = c_double;
+
+/// A Lua integer, equivalent to `i32`.
+pub type lua_Integer = c_int;
+
+/// A Lua unsigned integer, equivalent to `u32`.
+pub type lua_Unsigned = c_uint;
+
+/// Type for native C functions that can be passed to Lua.
+pub type lua_CFunction = unsafe extern "C" fn(L: *mut lua_State) -> c_int;
+pub type lua_Continuation = unsafe extern "C" fn(L: *mut lua_State, status: c_int) -> c_int;
+
+/// Type for userdata destructor functions.
+pub type lua_Udestructor = unsafe extern "C" fn(*mut c_void);
+
+/// Type for memory-allocation functions.
+pub type lua_Alloc = unsafe extern "C" fn(
+    ud: *mut c_void,
+    ptr: *mut c_void,
+    osize: usize,
+    nsize: usize,
+) -> *mut c_void;
+
+extern "C" {
+    //
+    // State manipulation
+    //
+    pub fn lua_newstate(f: lua_Alloc, ud: *mut c_void) -> *mut lua_State;
+    pub fn lua_close(L: *mut lua_State);
+    pub fn lua_newthread(L: *mut lua_State) -> *mut lua_State;
+    pub fn lua_mainthread(L: *mut lua_State) -> *mut lua_State;
+    pub fn lua_resetthread(L: *mut lua_State);
+    pub fn lua_isthreadreset(L: *mut lua_State) -> c_int;
+
+    //
+    // Basic stack manipulation
+    //
+    pub fn lua_absindex(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_gettop(L: *mut lua_State) -> c_int;
+    pub fn lua_settop(L: *mut lua_State, idx: c_int);
+    pub fn lua_pushvalue(L: *mut lua_State, idx: c_int);
+    pub fn lua_remove(L: *mut lua_State, idx: c_int);
+    pub fn lua_insert(L: *mut lua_State, idx: c_int);
+    pub fn lua_replace(L: *mut lua_State, idx: c_int);
+    pub fn lua_checkstack(L: *mut lua_State, sz: c_int) -> c_int;
+    pub fn lua_rawcheckstack(L: *mut lua_State, sz: c_int);
+
+    pub fn lua_xmove(from: *mut lua_State, to: *mut lua_State, n: c_int);
+    pub fn lua_xpush(from: *mut lua_State, to: *mut lua_State, idx: c_int);
+
+    //
+    // Access functions (stack -> C)
+    //
+    pub fn lua_isnumber(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isstring(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_iscfunction(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isLfunction(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_isuserdata(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_type(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_typename(L: *mut lua_State, tp: c_int) -> *const c_char;
+
+    pub fn lua_equal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_rawequal(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+    pub fn lua_lessthan(L: *mut lua_State, idx1: c_int, idx2: c_int) -> c_int;
+
+    pub fn lua_tonumberx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Number;
+    #[link_name = "lua_tointegerx"]
+    pub fn lua_tointegerx_(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Integer;
+    pub fn lua_tounsignedx(L: *mut lua_State, idx: c_int, isnum: *mut c_int) -> lua_Unsigned;
+    pub fn lua_tovector(L: *mut lua_State, idx: c_int) -> *const c_float;
+    pub fn lua_toboolean(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char;
+    pub fn lua_tostringatom(L: *mut lua_State, idx: c_int, atom: *mut c_int) -> *const c_char;
+    pub fn lua_namecallatom(L: *mut lua_State, atom: *mut c_int) -> *const c_char;
+    pub fn lua_objlen(L: *mut lua_State, idx: c_int) -> usize;
+    pub fn lua_tocfunction(L: *mut lua_State, idx: c_int) -> Option<lua_CFunction>;
+    pub fn lua_touserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
+    pub fn lua_touserdatatagged(L: *mut lua_State, idx: c_int, tag: c_int) -> *mut c_void;
+    pub fn lua_userdatatag(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_tothread(L: *mut lua_State, idx: c_int) -> *mut lua_State;
+    pub fn lua_topointer(L: *mut lua_State, idx: c_int) -> *const c_void;
+
+    //
+    // Push functions (C -> stack)
+    //
+    pub fn lua_pushnil(L: *mut lua_State);
+    pub fn lua_pushnumber(L: *mut lua_State, n: lua_Number);
+    pub fn lua_pushinteger(L: *mut lua_State, n: lua_Integer);
+    pub fn lua_pushunsigned(L: *mut lua_State, n: lua_Unsigned);
+    pub fn lua_pushvector(L: *mut lua_State, x: c_float, y: c_float, z: c_float);
+    #[link_name = "lua_pushlstring"]
+    pub fn lua_pushlstring_(L: *mut lua_State, s: *const c_char, l: usize);
+    #[link_name = "lua_pushstring"]
+    pub fn lua_pushstring_(L: *mut lua_State, s: *const c_char);
+    // lua_pushvfstring
+    #[link_name = "lua_pushfstringL"]
+    pub fn lua_pushfstring(L: *mut lua_State, fmt: *const c_char, ...) -> *const c_char;
+    pub fn lua_pushcclosurek(
+        L: *mut lua_State,
+        f: lua_CFunction,
+        debugname: *const c_char,
+        nup: c_int,
+        cont: Option<lua_Continuation>,
+    );
+    pub fn lua_pushboolean(L: *mut lua_State, b: c_int);
+    pub fn lua_pushthread(L: *mut lua_State) -> c_int;
+
+    pub fn lua_pushlightuserdata(L: *mut lua_State, p: *mut c_void);
+    pub fn lua_newuserdatatagged(L: *mut lua_State, sz: usize, tag: c_int) -> *mut c_void;
+    pub fn lua_newuserdatadtor(L: *mut lua_State, sz: usize, dtor: lua_Udestructor) -> *mut c_void;
+
+    //
+    // Get functions (Lua -> stack)
+    //
+    pub fn lua_gettable(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_getfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int;
+    pub fn lua_rawgetfield(L: *mut lua_State, idx: c_int, k: *const c_char) -> c_int;
+    pub fn lua_rawget(L: *mut lua_State, idx: c_int) -> c_int;
+    #[link_name = "lua_rawgeti"]
+    pub fn lua_rawgeti_(L: *mut lua_State, idx: c_int, n: c_int) -> c_int;
+    pub fn lua_createtable(L: *mut lua_State, narr: c_int, nrec: c_int);
+
+    pub fn lua_setreadonly(L: *mut lua_State, idx: c_int, enabled: c_int);
+    pub fn lua_getreadonly(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_setsafeenv(L: *mut lua_State, idx: c_int, enabled: c_int);
+
+    pub fn lua_getmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_getfenv(L: *mut lua_State, idx: c_int);
+
+    //
+    // Set functions (stack -> Lua)
+    //
+    pub fn lua_settable(L: *mut lua_State, idx: c_int);
+    pub fn lua_setfield(L: *mut lua_State, idx: c_int, k: *const c_char);
+    pub fn lua_rawset(L: *mut lua_State, idx: c_int);
+    #[link_name = "lua_rawseti"]
+    pub fn lua_rawseti_(L: *mut lua_State, idx: c_int, n: c_int);
+    pub fn lua_setmetatable(L: *mut lua_State, objindex: c_int) -> c_int;
+    pub fn lua_setfenv(L: *mut lua_State, idx: c_int) -> c_int;
+
+    //
+    // `load' and `call' functions (load and run Luau bytecode)
+    //
+    pub fn luau_load(
+        L: *mut lua_State,
+        chunkname: *const c_char,
+        data: *const c_char,
+        size: usize,
+        env: c_int,
+    ) -> c_int;
+    pub fn lua_call(L: *mut lua_State, nargs: c_int, nresults: c_int);
+    pub fn lua_pcall(L: *mut lua_State, nargs: c_int, nresults: c_int, errfunc: c_int) -> c_int;
+
+    //
+    // Coroutine functions
+    //
+    pub fn lua_yield(L: *mut lua_State, nresults: c_int) -> c_int;
+    pub fn lua_break(L: *mut lua_State) -> c_int;
+    #[link_name = "lua_resume"]
+    pub fn lua_resume_(L: *mut lua_State, from: *mut lua_State, narg: c_int) -> c_int;
+    pub fn lua_resumeerror(L: *mut lua_State, from: *mut lua_State) -> c_int;
+    pub fn lua_status(L: *mut lua_State) -> c_int;
+    pub fn lua_isyieldable(L: *mut lua_State) -> c_int;
+    pub fn lua_getthreaddata(L: *mut lua_State) -> *mut c_void;
+    pub fn lua_setthreaddata(L: *mut lua_State, data: *mut c_void);
+}
+
+//
+// Garbage-collection function and options
+//
+pub const LUA_GCSTOP: c_int = 0;
+pub const LUA_GCRESTART: c_int = 1;
+pub const LUA_GCCOLLECT: c_int = 2;
+pub const LUA_GCCOUNT: c_int = 3;
+pub const LUA_GCCOUNTB: c_int = 4;
+pub const LUA_GCISRUNNING: c_int = 5;
+pub const LUA_GCSTEP: c_int = 6;
+pub const LUA_GCSETGOAL: c_int = 7;
+pub const LUA_GCSETSTEPMUL: c_int = 8;
+pub const LUA_GCSETSTEPSIZE: c_int = 9;
+
+extern "C" {
+    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
+}
+
+//
+// Memory statistics
+//
+extern "C" {
+    pub fn lua_setmemcat(L: *mut lua_State, category: c_int);
+    pub fn lua_totalbytes(L: *mut lua_State, category: c_int) -> usize;
+}
+
+//
+// Miscellaneous functions
+//
+extern "C" {
+    pub fn lua_error(L: *mut lua_State) -> !;
+    pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_concat(L: *mut lua_State, n: c_int);
+    // TODO: lua_encodepointer
+    pub fn lua_clock() -> c_double;
+    pub fn lua_setuserdatadtor(L: *mut lua_State, tag: c_int, dtor: Option<lua_Udestructor>);
+    pub fn lua_clonefunction(L: *mut lua_State, idx: c_int);
+}
+
+//
+// Reference system, can be used to pin objects
+//
+pub const LUA_NOREF: c_int = -1;
+pub const LUA_REFNIL: c_int = 0;
+
+extern "C" {
+    pub fn lua_ref(L: *mut lua_State, idx: c_int) -> c_int;
+    pub fn lua_unref(L: *mut lua_State, r#ref: c_int);
+}
+
+//
+// Some useful macros (implemented as Rust functions)
+//
+
+#[inline(always)]
+pub unsafe fn lua_tonumber(L: *mut lua_State, i: c_int) -> lua_Number {
+    lua_tonumberx(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_tointeger_(L: *mut lua_State, i: c_int) -> lua_Integer {
+    lua_tointegerx_(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_tounsigned(L: *mut lua_State, i: c_int) -> lua_Unsigned {
+    lua_tounsignedx(L, i, ptr::null_mut())
+}
+
+#[inline(always)]
+pub unsafe fn lua_pop(L: *mut lua_State, n: c_int) {
+    lua_settop(L, -n - 1)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newtable(L: *mut lua_State) {
+    lua_createtable(L, 0, 0)
+}
+
+#[inline(always)]
+pub unsafe fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void {
+    lua_newuserdatatagged(L, sz, 0)
+}
+
+// TODO: lua_strlen
+
+#[inline(always)]
+pub unsafe fn lua_isfunction(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TFUNCTION) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_istable(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTABLE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_islightuserdata(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TLIGHTUSERDATA) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNIL) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isboolean(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TBOOLEAN) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isvector(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TVECTOR) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isthread(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TTHREAD) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnone(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TNONE) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_isnoneornil(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) <= LUA_TNIL) as c_int
+}
+
+#[inline(always)]
+pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) {
+    use std::ffi::CString;
+    let c_str = CString::new(s).unwrap();
+    lua_pushlstring_(L, c_str.as_ptr(), c_str.as_bytes().len())
+}
+
+pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
+    lua_pushcclosurek(L, f, ptr::null(), 0, None)
+}
+
+pub unsafe fn lua_pushcfunctiond(L: *mut lua_State, f: lua_CFunction, debugname: *const c_char) {
+    lua_pushcclosurek(L, f, debugname, 0, None)
+}
+
+pub unsafe fn lua_pushcclosure(L: *mut lua_State, f: lua_CFunction, nup: c_int) {
+    lua_pushcclosurek(L, f, ptr::null(), nup, None)
+}
+
+pub unsafe fn lua_pushcclosured(
+    L: *mut lua_State,
+    f: lua_CFunction,
+    debugname: *const c_char,
+    nup: c_int,
+) {
+    lua_pushcclosurek(L, f, debugname, nup, None)
+}
+
+#[inline(always)]
+pub unsafe fn lua_setglobal(L: *mut lua_State, var: *const c_char) {
+    lua_setfield(L, LUA_GLOBALSINDEX, var)
+}
+
+#[inline(always)]
+pub unsafe fn lua_getglobal(L: *mut lua_State, var: *const c_char) -> c_int {
+    lua_getfield(L, LUA_GLOBALSINDEX, var)
+}
+
+#[inline(always)]
+pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
+    lua_tolstring(L, i, ptr::null_mut())
+}
+
+//
+// Debug API
+//
+
+// Maximum size for the description of the source of a function in debug information.
+const LUA_IDSIZE: usize = 256;
+
+/// Type for functions to be called on debug events.
+pub type lua_Hook = unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug);
+
+pub type lua_Coverage = unsafe extern "C" fn(
+    context: *mut c_void,
+    function: *const c_char,
+    linedefined: c_int,
+    depth: c_int,
+    hits: *const c_int,
+    size: usize,
+);
+
+extern "C" {
+    pub fn lua_stackdepth(L: *mut lua_State) -> c_int;
+    pub fn lua_getinfo(
+        L: *mut lua_State,
+        level: c_int,
+        what: *const c_char,
+        ar: *mut lua_Debug,
+    ) -> c_int;
+    pub fn lua_getargument(L: *mut lua_State, level: c_int, n: c_int) -> c_int;
+    pub fn lua_getlocal(L: *mut lua_State, level: c_int, n: c_int) -> *const c_char;
+    pub fn lua_setlocal(L: *mut lua_State, level: c_int, n: c_int) -> *const c_char;
+    pub fn lua_getupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
+    pub fn lua_setupvalue(L: *mut lua_State, funcindex: c_int, n: c_int) -> *const c_char;
+
+    pub fn lua_singlestep(L: *mut lua_State, enabled: c_int);
+    pub fn lua_breakpoint(L: *mut lua_State, funcindex: c_int, line: c_int, enabled: c_int);
+
+    pub fn lua_getcoverage(
+        L: *mut lua_State,
+        funcindex: c_int,
+        context: *mut c_void,
+        callback: lua_Coverage,
+    );
+
+    pub fn lua_debugtrace(L: *mut lua_State) -> *const c_char;
+}
+
+#[repr(C)]
+pub struct lua_Debug {
+    pub name: *const c_char,
+    pub what: *const c_char,
+    pub source: *const c_char,
+    pub linedefined: c_int,
+    pub currentline: c_int,
+    pub nupvals: u8,
+    pub nparams: u8,
+    pub isvararg: c_char,
+    pub short_src: [c_char; LUA_IDSIZE],
+    pub userdata: *mut c_void,
+}
+
+//
+// Callbacks that can be used to reconfigure behavior of the VM dynamically.
+// These are shared between all coroutines.
+//
+
+#[repr(C)]
+pub struct lua_Callbacks {
+    /// arbitrary userdata pointer that is never overwritten by Luau
+    pub userdata: *mut c_void,
+
+    /// gets called at safepoints (loop back edges, call/ret, gc) if set
+    pub interrupt: Option<unsafe extern "C" fn(L: *mut lua_State, gc: c_int)>,
+    /// gets called when an unprotected error is raised (if longjmp is used)
+    pub panic: Option<unsafe extern "C" fn(L: *mut lua_State, errcode: c_int)>,
+
+    /// gets called when L is created (LP == parent) or destroyed (LP == NULL)
+    pub userthread: Option<unsafe extern "C" fn(LP: *mut lua_State, L: *mut lua_State)>,
+    /// gets called when a string is created; returned atom can be retrieved via tostringatom
+    pub useratom: Option<unsafe extern "C" fn(s: *const c_char, l: usize) -> i16>,
+
+    /// gets called when BREAK instruction is encountered
+    pub debugbreak: Option<unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
+    /// gets called after each instruction in single step mode
+    pub debugstep: Option<unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
+    /// gets called when thread execution is interrupted by break in another thread
+    pub debuginterrupt: Option<unsafe extern "C" fn(L: *mut lua_State, ar: *mut lua_Debug)>,
+    /// gets called when protected call results in an error
+    pub debugprotectederror: Option<unsafe extern "C" fn(L: *mut lua_State)>,
+}
+
+extern "C" {
+    pub fn lua_callbacks(L: *mut lua_State) -> *mut lua_Callbacks;
+}
@@ -0,0 +1,39 @@
+//! Contains definitions from `luacode.h`.
+
+use std::os::raw::{c_char, c_int, c_void};
+use std::slice;
+
+#[repr(C)]
+pub struct lua_CompileOptions {
+    pub optimizationLevel: c_int,
+    pub debugLevel: c_int,
+    pub coverageLevel: c_int,
+    pub vectorLib: *const c_char,
+    pub vectorCtor: *const c_char,
+    pub mutableGlobals: *mut *const c_char,
+}
+
+extern "C" {
+    #[link_name = "luau_compile"]
+    pub fn luau_compile_(
+        source: *const c_char,
+        size: usize,
+        options: *mut lua_CompileOptions,
+        outsize: *mut usize,
+    ) -> *mut c_char;
+
+    fn free(p: *mut c_void);
+}
+
+pub unsafe fn luau_compile(source: &[u8], mut options: lua_CompileOptions) -> Vec<u8> {
+    let mut outsize = 0;
+    let data_ptr = luau_compile_(
+        source.as_ptr() as *const c_char,
+        source.len(),
+        &mut options,
+        &mut outsize,
+    );
+    let data = slice::from_raw_parts(data_ptr as *mut u8, outsize).to_vec();
+    free(data_ptr as *mut c_void);
+    data
+}
@@ -0,0 +1,33 @@
+//! Contains definitions from `lualib.h`.
+
+use std::os::raw::c_int;
+
+use super::lua::lua_State;
+
+pub const LUA_COLIBNAME: &str = "coroutine";
+pub const LUA_TABLIBNAME: &str = "table";
+pub const LUA_OSLIBNAME: &str = "os";
+pub const LUA_STRLIBNAME: &str = "string";
+pub const LUA_BITLIBNAME: &str = "bit32";
+pub const LUA_UTF8LIBNAME: &str = "utf8";
+pub const LUA_MATHLIBNAME: &str = "math";
+pub const LUA_DBLIBNAME: &str = "debug";
+
+extern "C" {
+    pub fn luaopen_base(L: *mut lua_State) -> c_int;
+    pub fn luaopen_coroutine(L: *mut lua_State) -> c_int;
+    pub fn luaopen_table(L: *mut lua_State) -> c_int;
+    pub fn luaopen_os(L: *mut lua_State) -> c_int;
+    pub fn luaopen_string(L: *mut lua_State) -> c_int;
+    pub fn luaopen_bit32(L: *mut lua_State) -> c_int;
+    pub fn luaopen_utf8(L: *mut lua_State) -> c_int;
+    pub fn luaopen_math(L: *mut lua_State) -> c_int;
+    pub fn luaopen_debug(L: *mut lua_State) -> c_int;
+
+    // open all builtin libraries
+    pub fn luaL_openlibs(L: *mut lua_State);
+
+    // sandbox libraries and globals
+    pub fn luaL_sandbox(L: *mut lua_State);
+    pub fn luaL_sandboxthread(L: *mut lua_State);
+}
@@ -0,0 +1,13 @@
+//! Low level bindings to Luau.
+
+pub use compat::*;
+pub use lauxlib::*;
+pub use lua::*;
+pub use luacode::*;
+pub use lualib::*;
+
+pub mod compat;
+pub mod lauxlib;
+pub mod lua;
+pub mod luacode;
+pub mod lualib;
@@ -1,262 +1,42 @@
-// The MIT License (MIT)
-//
-// Copyright (c) 2019-2021 A. Orlenko
-// Copyright (c) 2014 J.C. Moyer
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-//! Low level bindings to Lua.
+//! Low level bindings to Lua 5.4/5.3/5.2/5.1 including LuaJIT.

 #![allow(non_camel_case_types, non_snake_case, dead_code)]

 use std::os::raw::c_int;

-// This is more or less in the order it appears in the Lua manual, with the
-// exception of constants, which appear scattered throughout the manual text.
-
-// C API types
-pub use self::lua::{
-    lua_Alloc, lua_CFunction, lua_Debug, lua_Hook, lua_Integer, lua_Number, lua_Reader, lua_State,
-    lua_Unsigned, lua_Writer,
-};
-
 #[cfg(feature = "lua54")]
-pub use self::lua::lua_WarnFunction;
+pub use lua54::*;

-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use self::lua::{lua_KContext, lua_KFunction};
-
-#[cfg(any(feature = "lua51", feature = "luajit"))]
-pub use self::lua::{lua_getfenv, lua_setfenv};
-
-// C API functions
-pub use self::lua::{
-    lua_absindex,
-    lua_arith,
-    lua_atpanic,
-    lua_call,
-    lua_checkstack,
-    lua_close,
-    lua_compare,
-    lua_concat,
-    lua_copy,
-    lua_createtable,
-    lua_dump,
-    lua_error,
-    lua_gc,
-    lua_getallocf,
-    lua_getextraspace,
-    lua_getfield,
-    lua_getglobal,
-    lua_gethook,
-    lua_gethookcount,
-    lua_gethookmask,
-    lua_geti,
-    lua_getinfo,
-    lua_getlocal,
-    lua_getmetatable,
-    lua_getstack,
-    lua_gettable,
-    lua_gettop,
-    lua_getupvalue,
-    lua_getuservalue,
-    lua_insert,
-    lua_isboolean,
-    lua_iscfunction,
-    lua_isfunction,
-    lua_isinteger,
-    lua_islightuserdata,
-    lua_isnil,
-    lua_isnone,
-    lua_isnoneornil,
-    lua_isnumber,
-    lua_isstring,
-    lua_istable,
-    lua_isthread,
-    lua_isuserdata,
-    lua_len,
-    lua_load,
-    lua_newstate,
-    lua_newtable,
-    lua_newthread,
-    lua_newuserdata,
-    lua_next,
-    lua_pcall,
-    lua_pop,
-    lua_pushboolean,
-    lua_pushcclosure,
-    lua_pushcfunction,
-    lua_pushfstring,
-    lua_pushglobaltable,
-    lua_pushinteger,
-    lua_pushlightuserdata,
-    lua_pushliteral,
-    lua_pushlstring,
-    lua_pushnil,
-    lua_pushnumber,
-    lua_pushstring,
-    lua_pushthread,
-    lua_pushvalue,
-    // omitted: lua_pushvfstring
-    lua_rawequal,
-    lua_rawget,
-    lua_rawgeti,
-    lua_rawgetp,
-    lua_rawlen,
-    lua_rawset,
-    lua_rawseti,
-    lua_rawsetp,
-    lua_register,
-    lua_remove,
-    lua_replace,
-    lua_resume,
-    lua_rotate,
-    lua_setallocf,
-    lua_setfield,
-    lua_setglobal,
-    lua_sethook,
-    lua_seti,
-    lua_setlocal,
-    lua_setmetatable,
-    lua_settable,
-    lua_settop,
-    lua_setupvalue,
-    lua_setuservalue,
-    lua_status,
-    lua_stringtonumber,
-    lua_toboolean,
-    lua_tocfunction,
-    lua_tointeger,
-    lua_tointegerx,
-    lua_tolstring,
-    lua_tonumber,
-    lua_tonumberx,
-    lua_topointer,
-    lua_tostring,
-    lua_tothread,
-    lua_touserdata,
-    lua_type,
-    lua_typename,
-    lua_upvalueindex,
-    lua_xmove,
-    lua_yield,
-};
-
-#[cfg(feature = "lua54")]
-pub use self::lua::{
-    lua_getiuservalue, lua_newuserdatauv, lua_setcstacklimit, lua_setiuservalue, lua_setwarnf,
-    lua_toclose, lua_warning,
-};
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use self::lua::{lua_isyieldable, lua_version};
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub use self::lua::{lua_callk, lua_pcallk, lua_upvalueid, lua_upvaluejoin, lua_yieldk};
-
-#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
-pub use self::lua::lua_resetthread;
-
-// auxiliary library types
-pub use self::lauxlib::luaL_Reg;
-
-// auxiliary library functions
-pub use self::lauxlib::{
-    luaL_argcheck, luaL_argerror, luaL_callmeta, luaL_checkany, luaL_checkint, luaL_checkinteger,
-    luaL_checklong, luaL_checklstring, luaL_checknumber, luaL_checkoption, luaL_checkstack,
-    luaL_checkstring, luaL_checktype, luaL_checkudata, luaL_checkversion, luaL_dofile,
-    luaL_dostring, luaL_error, luaL_getmetafield, luaL_getmetatable, luaL_getsubtable, luaL_gsub,
-    luaL_len, luaL_loadbuffer, luaL_loadbufferx, luaL_loadfile, luaL_loadstring, luaL_newlib,
-    luaL_newlibtable, luaL_newmetatable, luaL_newstate, luaL_optint, luaL_optinteger, luaL_optlong,
-    luaL_optlstring, luaL_optnumber, luaL_optstring, luaL_ref, luaL_requiref, luaL_setfuncs,
-    luaL_setmetatable, luaL_testudata, luaL_tolstring, luaL_traceback, luaL_typename, luaL_unref,
-    luaL_where,
-};
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub use self::lauxlib::{luaL_execresult, luaL_fileresult, luaL_loadfilex};
-
-// lualib.h functions
-pub use self::lualib::{
-    luaL_openlibs, luaopen_base, luaopen_debug, luaopen_io, luaopen_math, luaopen_os,
-    luaopen_package, luaopen_string, luaopen_table,
-};
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use self::lualib::{luaopen_coroutine, luaopen_utf8};
+#[cfg(feature = "lua53")]
+pub use lua53::*;

 #[cfg(feature = "lua52")]
-pub use self::lualib::{luaopen_bit32, luaopen_coroutine};
-
-#[cfg(feature = "luajit")]
-pub use self::lualib::{luaopen_bit, luaopen_ffi, luaopen_jit};
-
-// constants from lua.h
-pub use self::lua::{
-    LUA_ERRERR, LUA_ERRMEM, LUA_ERRRUN, LUA_ERRSYNTAX, LUA_GCCOLLECT, LUA_GCCOUNT, LUA_GCCOUNTB,
-    LUA_GCRESTART, LUA_GCSETPAUSE, LUA_GCSETSTEPMUL, LUA_GCSTEP, LUA_GCSTOP, LUA_HOOKCALL,
-    LUA_HOOKCOUNT, LUA_HOOKLINE, LUA_HOOKRET, LUA_HOOKTAILCALL, LUA_MASKCALL, LUA_MASKCOUNT,
-    LUA_MASKLINE, LUA_MASKRET, LUA_MINSTACK, LUA_MULTRET, LUA_OK, LUA_OPADD, LUA_OPDIV, LUA_OPEQ,
-    LUA_OPLE, LUA_OPLT, LUA_OPMOD, LUA_OPMUL, LUA_OPPOW, LUA_OPSUB, LUA_OPUNM, LUA_REGISTRYINDEX,
-    LUA_SIGNATURE, LUA_TBOOLEAN, LUA_TFUNCTION, LUA_TLIGHTUSERDATA, LUA_TNIL, LUA_TNONE,
-    LUA_TNUMBER, LUA_TRACEBACK_STACK, LUA_TSTRING, LUA_TTABLE, LUA_TTHREAD, LUA_TUSERDATA,
-    LUA_YIELD,
-};
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use self::lua::{
-    LUA_OPBAND, LUA_OPBNOT, LUA_OPBOR, LUA_OPBXOR, LUA_OPIDIV, LUA_OPSHL, LUA_OPSHR,
-};
-
-#[cfg(feature = "lua54")]
-pub use self::lua::{LUA_GCGEN, LUA_GCINC};
-
-#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-pub use self::lua::{LUA_GCISRUNNING, LUA_RIDX_GLOBALS, LUA_RIDX_MAINTHREAD};
-
-#[cfg(any(feature = "lua53", feature = "lua52"))]
-pub use self::lua::LUA_ERRGCMM;
+pub use lua52::*;

 #[cfg(any(feature = "lua51", feature = "luajit"))]
-pub use self::lua::{LUA_ENVIRONINDEX, LUA_GLOBALSINDEX};
+pub use lua51::*;

-// constants from lauxlib.h
-pub use self::lauxlib::{LUA_ERRFILE, LUA_NOREF, LUA_REFNIL};
+#[cfg(feature = "luau")]
+pub use luau::*;

-// constants from lualib.h
-pub use self::lualib::{
-    LUA_COLIBNAME, LUA_DBLIBNAME, LUA_IOLIBNAME, LUA_LOADLIBNAME, LUA_MATHLIBNAME, LUA_OSLIBNAME,
-    LUA_STRLIBNAME, LUA_TABLIBNAME,
-};
-
-#[cfg(any(feature = "lua54", feature = "lua53"))]
-pub use self::lualib::LUA_UTF8LIBNAME;
-
-#[cfg(any(feature = "lua52", feature = "luajit"))]
-pub use self::lualib::LUA_BITLIBNAME;
-
-#[cfg(feature = "luajit")]
-pub use self::lualib::{LUA_FFILIBNAME, LUA_JITLIBNAME};
-
-// Not actually defined in lua.h / luaconf.h
+#[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
 pub const LUA_MAX_UPVALUES: c_int = 255;

+#[cfg(any(feature = "lua51", all(feature = "luajit", not(feature = "vendored"))))]
+pub const LUA_MAX_UPVALUES: c_int = 60;
+
+#[cfg(all(feature = "luajit", feature = "vendored"))]
+pub const LUA_MAX_UPVALUES: c_int = 120;
+
+#[cfg(feature = "luau")]
+pub const LUA_MAX_UPVALUES: c_int = 200;
+
+// I believe `luaL_traceback` < 5.4 requires this much free stack to not error.
+// 5.4 uses `luaL_Buffer`
+pub const LUA_TRACEBACK_STACK: c_int = 11;
+
+// The minimum alignment guaranteed by the architecture. This value is used to
+// add fast paths for low alignment values.
 // Copied from https://github.com/rust-lang/rust/blob/master/library/std/src/sys/common/alloc.rs
 #[cfg(all(any(
    target_arch = "x86",
@@ -268,7 +48,8 @@ pub const LUA_MAX_UPVALUES: c_int = 255;
    target_arch = "asmjs",
    target_arch = "wasm32",
    target_arch = "hexagon",
-    target_arch = "riscv32"
+    all(target_arch = "riscv32", not(target_os = "espidf")),
+    all(target_arch = "xtensa", not(target_os = "espidf")),
 )))]
 pub const SYS_MIN_ALIGN: usize = 8;
 #[cfg(all(any(
@@ -277,12 +58,20 @@ pub const SYS_MIN_ALIGN: usize = 8;
    target_arch = "mips64",
    target_arch = "s390x",
    target_arch = "sparc64",
-    target_arch = "riscv64"
+    target_arch = "riscv64",
+    target_arch = "wasm64",
 )))]
 pub const SYS_MIN_ALIGN: usize = 16;
+// The allocator on the esp-idf platform guarentees 4 byte alignment.
+#[cfg(all(any(
+    all(target_arch = "riscv32", target_os = "espidf"),
+    all(target_arch = "xtensa", target_os = "espidf"),
+)))]
+pub const SYS_MIN_ALIGN: usize = 4;

 // Hack to avoid stripping a few unused Lua symbols that could be imported
 // by C modules in unsafe mode
+#[cfg(not(feature = "luau"))]
 pub(crate) fn keep_lua_symbols() {
    let mut symbols: Vec<*const extern "C" fn()> = Vec::new();
    symbols.push(lua_atpanic as _);
@@ -290,26 +79,23 @@ pub(crate) fn keep_lua_symbols() {
    symbols.push(lua_tocfunction as _);
    symbols.push(luaL_loadstring as _);
    symbols.push(luaL_openlibs as _);
-    if cfg!(any(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52"
-    ))) {
+    if cfg!(any(feature = "lua54", feature = "lua53", feature = "lua52")) {
        symbols.push(lua_getglobal as _);
        symbols.push(lua_setglobal as _);
    }
 }

-#[allow(unused_imports, dead_code, non_camel_case_types)]
-#[allow(clippy::unreadable_literal)]
-mod glue {
-    include!(concat!(env!("OUT_DIR"), "/glue.rs"));
-}
+#[cfg(feature = "lua54")]
+pub mod lua54;

-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-mod compat53;
+#[cfg(feature = "lua53")]
+pub mod lua53;

-mod lauxlib;
-mod lua;
-mod luaconf;
-mod lualib;
+#[cfg(feature = "lua52")]
+pub mod lua52;
+
+#[cfg(any(feature = "lua51", feature = "luajit"))]
+pub mod lua51;
+
+#[cfg(feature = "luau")]
+pub mod luau;
@@ -1,12 +1,11 @@
-use std::os::raw::{c_int, c_void};
+use std::os::raw::c_int;
 use std::ptr;
-use std::slice;

 use crate::error::{Error, Result};
 use crate::ffi;
 use crate::types::LuaRef;
-use crate::util::{assert_stack, check_stack, error_traceback, pop_error, protect_lua, StackGuard};
-use crate::value::{FromLuaMulti, MultiValue, ToLuaMulti};
+use crate::util::{assert_stack, check_stack, error_traceback, pop_error, StackGuard};
+use crate::value::{FromLuaMulti, ToLuaMulti};

 #[cfg(feature = "async")]
 use {futures_core::future::LocalBoxFuture, futures_util::future};
@@ -59,7 +58,7 @@ impl<'lua> Function<'lua> {
    pub fn call<A: ToLuaMulti<'lua>, R: FromLuaMulti<'lua>>(&self, args: A) -> Result<R> {
        let lua = self.0.lua;

-        let args = args.to_lua_multi(lua)?;
+        let mut args = args.to_lua_multi(lua)?;
        let nargs = args.len() as c_int;

        let results = unsafe {
@@ -69,7 +68,7 @@ impl<'lua> Function<'lua> {
            ffi::lua_pushcfunction(lua.state, error_traceback);
            let stack_start = ffi::lua_gettop(lua.state);
            lua.push_ref(&self.0);
-            for arg in args {
+            for arg in args.drain_all() {
                lua.push_value(arg)?;
            }
            let ret = ffi::lua_pcall(lua.state, nargs, ffi::LUA_MULTRET, stack_start);
@@ -77,7 +76,7 @@ impl<'lua> Function<'lua> {
                return Err(pop_error(lua.state, ret));
            }
            let nresults = ffi::lua_gettop(lua.state) - stack_start;
-            let mut results = MultiValue::new();
+            let mut results = args; // Reuse MultiValue container
            assert_stack(lua.state, 2);
            for _ in 0..nresults {
                results.push_front(lua.pop_value());
@@ -116,7 +115,7 @@ impl<'lua> Function<'lua> {
    /// # }
    /// ```
    ///
-    /// [`AsyncThread`]: struct.AsyncThread.html
+    /// [`AsyncThread`]: crate::AsyncThread
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
    pub fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
@@ -126,8 +125,12 @@ impl<'lua> Function<'lua> {
        R: FromLuaMulti<'lua> + 'fut,
    {
        let lua = self.0.lua;
-        match lua.create_thread(self.clone()) {
-            Ok(t) => Box::pin(t.into_async(args)),
+        match lua.create_recycled_thread(self.clone()) {
+            Ok(t) => {
+                let mut t = t.into_async(args);
+                t.set_recyclable(true);
+                Box::pin(t)
+            }
            Err(e) => Box::pin(future::err(e)),
        }
    }
@@ -198,8 +201,8 @@ impl<'lua> Function<'lua> {
            for arg in args {
                lua.push_value(arg)?;
            }
-            protect_lua(lua.state, nargs + 2, 1, |state| {
-                ffi::lua_pushcclosure(state, bind_call_impl, nargs + 2);
+            protect_lua!(lua.state, nargs + 2, 1, fn(state) {
+                ffi::lua_pushcclosure(state, bind_call_impl, ffi::lua_gettop(state));
            })?;

            Ok(Function(lua.pop_ref()))
@@ -210,7 +213,12 @@ impl<'lua> Function<'lua> {
    ///
    /// If `strip` is true, the binary representation may not include all debug information
    /// about the function, to save space.
+    #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
    pub fn dump(&self, strip: bool) -> Vec<u8> {
+        use std::os::raw::c_void;
+        use std::slice;
+
        unsafe extern "C" fn writer(
            _state: *mut ffi::lua_State,
            buf: *const c_void,
@@ -1,55 +1,112 @@
+use std::cell::UnsafeCell;
 use std::ffi::CStr;
-use std::marker::PhantomData;
+#[cfg(not(feature = "luau"))]
+use std::ops::{BitOr, BitOrAssign};
 use std::os::raw::{c_char, c_int};

-use crate::ffi::{self, lua_Debug, lua_State};
+use crate::ffi::{self, lua_Debug};
 use crate::lua::Lua;
-use crate::util::callback_error;

 /// Contains information about currently executing Lua code.
 ///
 /// The `Debug` structure is provided as a parameter to the hook function set with
 /// [`Lua::set_hook`]. You may call the methods on this structure to retrieve information about the
 /// Lua code executing at the time that the hook function was called. Further information can be
-/// found in the [Lua 5.3 documentation][lua_doc].
+/// found in the Lua [documentation][lua_doc].
 ///
-/// [lua_doc]: https://www.lua.org/manual/5.3/manual.html#lua_Debug
-/// [`Lua::set_hook`]: struct.Lua.html#method.set_hook
-#[derive(Clone)]
-pub struct Debug<'a> {
-    ar: *mut lua_Debug,
-    state: *mut lua_State,
-    _phantom: PhantomData<&'a ()>,
+/// [lua_doc]: https://www.lua.org/manual/5.4/manual.html#lua_Debug
+/// [`Lua::set_hook`]: crate::Lua::set_hook
+pub struct Debug<'lua> {
+    lua: &'lua Lua,
+    ar: ActivationRecord,
+    #[cfg(feature = "luau")]
+    level: c_int,
 }

-impl<'a> Debug<'a> {
-    /// Corresponds to the `n` what mask.
-    pub fn names(&self) -> DebugNames<'a> {
+impl<'lua> Debug<'lua> {
+    #[cfg(not(feature = "luau"))]
+    pub(crate) fn new(lua: &'lua Lua, ar: *mut lua_Debug) -> Self {
+        Debug {
+            lua,
+            ar: ActivationRecord::Borrowed(ar),
+        }
+    }
+
+    pub(crate) fn new_owned(lua: &'lua Lua, _level: c_int, ar: lua_Debug) -> Self {
+        Debug {
+            lua,
+            ar: ActivationRecord::Owned(UnsafeCell::new(ar)),
+            #[cfg(feature = "luau")]
+            level: _level,
+        }
+    }
+
+    /// Returns the specific event that triggered the hook.
+    ///
+    /// For [Lua 5.1] `DebugEvent::TailCall` is used for return events to indicate a return
+    /// from a function that did a tail call.
+    ///
+    /// [Lua 5.1]: https://www.lua.org/manual/5.1/manual.html#pdf-LUA_HOOKTAILRET
+    #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
+    pub fn event(&self) -> DebugEvent {
        unsafe {
+            match (*self.ar.get()).event {
+                ffi::LUA_HOOKCALL => DebugEvent::Call,
+                ffi::LUA_HOOKRET => DebugEvent::Ret,
+                ffi::LUA_HOOKTAILCALL => DebugEvent::TailCall,
+                ffi::LUA_HOOKLINE => DebugEvent::Line,
+                ffi::LUA_HOOKCOUNT => DebugEvent::Count,
+                event => DebugEvent::Unknown(event),
+            }
+        }
+    }
+
+    /// Corresponds to the `n` what mask.
+    pub fn names(&self) -> DebugNames<'lua> {
+        unsafe {
+            #[cfg(not(feature = "luau"))]
            mlua_assert!(
-                ffi::lua_getinfo(self.state, cstr!("n"), self.ar) != 0,
+                ffi::lua_getinfo(self.lua.state, cstr!("n"), self.ar.get()) != 0,
                "lua_getinfo failed with `n`"
            );
+            #[cfg(feature = "luau")]
+            mlua_assert!(
+                ffi::lua_getinfo(self.lua.state, self.level, cstr!("n"), self.ar.get()) != 0,
+                "lua_getinfo failed with `n`"
+            );
+
            DebugNames {
-                name: ptr_to_str((*self.ar).name),
-                name_what: ptr_to_str((*self.ar).namewhat),
+                name: ptr_to_str((*self.ar.get()).name),
+                #[cfg(not(feature = "luau"))]
+                name_what: ptr_to_str((*self.ar.get()).namewhat),
+                #[cfg(feature = "luau")]
+                name_what: None,
            }
        }
    }

    /// Corresponds to the `S` what mask.
-    pub fn source(&self) -> DebugSource<'a> {
+    pub fn source(&self) -> DebugSource<'lua> {
        unsafe {
+            #[cfg(not(feature = "luau"))]
            mlua_assert!(
-                ffi::lua_getinfo(self.state, cstr!("S"), self.ar) != 0,
+                ffi::lua_getinfo(self.lua.state, cstr!("S"), self.ar.get()) != 0,
                "lua_getinfo failed with `S`"
            );
+            #[cfg(feature = "luau")]
+            mlua_assert!(
+                ffi::lua_getinfo(self.lua.state, self.level, cstr!("s"), self.ar.get()) != 0,
+                "lua_getinfo failed with `s`"
+            );
+
            DebugSource {
-                source: ptr_to_str((*self.ar).source),
-                short_src: ptr_to_str((*self.ar).short_src.as_ptr()),
-                line_defined: (*self.ar).linedefined as i32,
-                last_line_defined: (*self.ar).lastlinedefined as i32,
-                what: ptr_to_str((*self.ar).what),
+                source: ptr_to_str((*self.ar.get()).source),
+                short_src: ptr_to_str((*self.ar.get()).short_src.as_ptr()),
+                line_defined: (*self.ar.get()).linedefined as i32,
+                #[cfg(not(feature = "luau"))]
+                last_line_defined: (*self.ar.get()).lastlinedefined as i32,
+                what: ptr_to_str((*self.ar.get()).what),
            }
        }
    }
@@ -57,44 +114,96 @@ impl<'a> Debug<'a> {
    /// Corresponds to the `l` what mask. Returns the current line.
    pub fn curr_line(&self) -> i32 {
        unsafe {
+            #[cfg(not(feature = "luau"))]
            mlua_assert!(
-                ffi::lua_getinfo(self.state, cstr!("l"), self.ar) != 0,
+                ffi::lua_getinfo(self.lua.state, cstr!("l"), self.ar.get()) != 0,
                "lua_getinfo failed with `l`"
            );
-            (*self.ar).currentline as i32
+            #[cfg(feature = "luau")]
+            mlua_assert!(
+                ffi::lua_getinfo(self.lua.state, self.level, cstr!("l"), self.ar.get()) != 0,
+                "lua_getinfo failed with `l`"
+            );
+
+            (*self.ar.get()).currentline as i32
        }
    }

    /// Corresponds to the `t` what mask. Returns true if the hook is in a function tail call, false
    /// otherwise.
+    #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
    pub fn is_tail_call(&self) -> bool {
        unsafe {
            mlua_assert!(
-                ffi::lua_getinfo(self.state, cstr!("t"), self.ar) != 0,
+                ffi::lua_getinfo(self.lua.state, cstr!("t"), self.ar.get()) != 0,
                "lua_getinfo failed with `t`"
            );
-            (*self.ar).currentline != 0
+            (*self.ar.get()).currentline != 0
        }
    }

    /// Corresponds to the `u` what mask.
    pub fn stack(&self) -> DebugStack {
        unsafe {
+            #[cfg(not(feature = "luau"))]
            mlua_assert!(
-                ffi::lua_getinfo(self.state, cstr!("u"), self.ar) != 0,
+                ffi::lua_getinfo(self.lua.state, cstr!("u"), self.ar.get()) != 0,
                "lua_getinfo failed with `u`"
            );
-            DebugStack {
-                num_ups: (*self.ar).nups as i32,
+            #[cfg(feature = "luau")]
+            mlua_assert!(
+                ffi::lua_getinfo(self.lua.state, self.level, cstr!("a"), self.ar.get()) != 0,
+                "lua_getinfo failed with `a`"
+            );
+
+            #[cfg(not(feature = "luau"))]
+            let stack = DebugStack {
+                num_ups: (*self.ar.get()).nups as i32,
                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                num_params: (*self.ar).nparams as i32,
+                num_params: (*self.ar.get()).nparams as i32,
                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                is_vararg: (*self.ar).isvararg != 0,
-            }
+                is_vararg: (*self.ar.get()).isvararg != 0,
+            };
+            #[cfg(feature = "luau")]
+            let stack = DebugStack {
+                num_ups: (*self.ar.get()).nupvals as i32,
+                num_params: (*self.ar.get()).nparams as i32,
+                is_vararg: (*self.ar.get()).isvararg != 0,
+            };
+            stack
        }
    }
 }

+enum ActivationRecord {
+    #[cfg(not(feature = "luau"))]
+    Borrowed(*mut lua_Debug),
+    Owned(UnsafeCell<lua_Debug>),
+}
+
+impl ActivationRecord {
+    #[inline]
+    fn get(&self) -> *mut lua_Debug {
+        match self {
+            #[cfg(not(feature = "luau"))]
+            ActivationRecord::Borrowed(x) => *x,
+            ActivationRecord::Owned(x) => x.get(),
+        }
+    }
+}
+
+/// Represents a specific event that triggered the hook.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DebugEvent {
+    Call,
+    Ret,
+    TailCall,
+    Line,
+    Count,
+    Unknown(c_int),
+}
+
 #[derive(Clone, Debug)]
 pub struct DebugNames<'a> {
    pub name: Option<&'a [u8]>,
@@ -106,6 +215,7 @@ pub struct DebugSource<'a> {
    pub source: Option<&'a [u8]>,
    pub short_src: Option<&'a [u8]>,
    pub line_defined: i32,
+    #[cfg(not(feature = "luau"))]
    pub last_line_defined: i32,
    pub what: Option<&'a [u8]>,
 }
@@ -113,15 +223,27 @@ pub struct DebugSource<'a> {
 #[derive(Copy, Clone, Debug)]
 pub struct DebugStack {
    pub num_ups: i32,
-    /// Requires `feature = "lua54/lua53/lua52"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", doc))]
+    /// Requires `feature = "lua54/lua53/lua52/luau"`
+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luau"
+    ))]
    pub num_params: i32,
-    /// Requires `feature = "lua54/lua53/lua52"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", doc))]
+    /// Requires `feature = "lua54/lua53/lua52/luau"`
+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luau"
+    ))]
    pub is_vararg: bool,
 }

 /// Determines when a hook function will be called by Lua.
+#[cfg(not(feature = "luau"))]
+#[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
 #[derive(Clone, Copy, Debug, Default)]
 pub struct HookTriggers {
    /// Before a function call.
@@ -139,7 +261,48 @@ pub struct HookTriggers {
    pub every_nth_instruction: Option<u32>,
 }

+#[cfg(not(feature = "luau"))]
 impl HookTriggers {
+    /// Returns a new instance of `HookTriggers` with [`on_calls`] trigger set.
+    ///
+    /// [`on_calls`]: #structfield.on_calls
+    pub fn on_calls() -> Self {
+        HookTriggers {
+            on_calls: true,
+            ..Default::default()
+        }
+    }
+
+    /// Returns a new instance of `HookTriggers` with [`on_returns`] trigger set.
+    ///
+    /// [`on_returns`]: #structfield.on_returns
+    pub fn on_returns() -> Self {
+        HookTriggers {
+            on_returns: true,
+            ..Default::default()
+        }
+    }
+
+    /// Returns a new instance of `HookTriggers` with [`every_line`] trigger set.
+    ///
+    /// [`every_line`]: #structfield.every_line
+    pub fn every_line() -> Self {
+        HookTriggers {
+            every_line: true,
+            ..Default::default()
+        }
+    }
+
+    /// Returns a new instance of `HookTriggers` with [`every_nth_instruction`] trigger set.
+    ///
+    /// [`every_nth_instruction`]: #structfield.every_nth_instruction
+    pub fn every_nth_instruction(n: u32) -> Self {
+        HookTriggers {
+            every_nth_instruction: Some(n),
+            ..Default::default()
+        }
+    }
+
    // Compute the mask to pass to `lua_sethook`.
    pub(crate) fn mask(&self) -> c_int {
        let mut mask: c_int = 0;
@@ -165,25 +328,26 @@ impl HookTriggers {
    }
 }

-pub(crate) unsafe extern "C" fn hook_proc(state: *mut lua_State, ar: *mut lua_Debug) {
-    callback_error(state, |_| {
-        let debug = Debug {
-            ar,
-            state,
-            _phantom: PhantomData,
-        };
+#[cfg(not(feature = "luau"))]
+impl BitOr for HookTriggers {
+    type Output = Self;

-        let lua = mlua_expect!(Lua::make_from_ptr(state), "cannot make Lua instance");
-        let hook_cb = mlua_expect!(lua.hook_callback(), "no hook callback set in hook_proc");
+    fn bitor(mut self, rhs: Self) -> Self::Output {
+        self.on_calls |= rhs.on_calls;
+        self.on_returns |= rhs.on_returns;
+        self.every_line |= rhs.every_line;
+        if self.every_nth_instruction.is_none() && rhs.every_nth_instruction.is_some() {
+            self.every_nth_instruction = rhs.every_nth_instruction;
+        }
+        self
+    }
+}

-        #[allow(clippy::match_wild_err_arm)]
-        match hook_cb.try_borrow_mut() {
-            Ok(mut b) => (&mut *b)(&lua, debug),
-            Err(_) => mlua_panic!("Lua should not allow hooks to be called within another hook"),
-        }?;
-
-        Ok(())
-    })
+#[cfg(not(feature = "luau"))]
+impl BitOrAssign for HookTriggers {
+    fn bitor_assign(&mut self, rhs: Self) {
+        *self = *self | rhs;
+    }
 }

 unsafe fn ptr_to_str<'a>(input: *const c_char) -> Option<&'a [u8]> {
@@ -50,29 +50,29 @@
 //! to [`Function`]s and [`UserData`].
 //!
 //! [Lua programming language]: https://www.lua.org/
-//! [`Lua`]: struct.Lua.html
-//! [executing]: struct.Chunk.html#method.exec
-//! [evaluating]: struct.Chunk.html#method.eval
-//! [globals]: struct.Lua.html#method.globals
-//! [`ToLua`]: trait.ToLua.html
-//! [`FromLua`]: trait.FromLua.html
-//! [`ToLuaMulti`]: trait.ToLuaMulti.html
-//! [`FromLuaMulti`]: trait.FromLuaMulti.html
-//! [`Function`]: struct.Function.html
-//! [`UserData`]: trait.UserData.html
-//! [`UserDataFields`]: trait.UserDataFields.html
-//! [`UserDataMethods`]: trait.UserDataMethods.html
-//! [`LuaSerdeExt`]: serde/trait.LuaSerdeExt.html
-//! [`Value`]: enum.Value.html
-//! [`create_async_function`]: struct.Lua.html#method.create_async_function
-//! [`call_async`]: struct.Function.html#method.call_async
-//! [`AsyncThread`]: struct.AsyncThread.html
-//! [`Future`]: ../futures_core/future/trait.Future.html
+//! [`Lua`]: crate::Lua
+//! [executing]: crate::Chunk::exec
+//! [evaluating]: crate::Chunk::eval
+//! [globals]: crate::Lua::globals
+//! [`ToLua`]: crate::ToLua
+//! [`FromLua`]: crate::FromLua
+//! [`ToLuaMulti`]: crate::ToLuaMulti
+//! [`FromLuaMulti`]: crate::FromLuaMulti
+//! [`Function`]: crate::Function
+//! [`UserData`]: crate::UserData
+//! [`UserDataFields`]: crate::UserDataFields
+//! [`UserDataMethods`]: crate::UserDataMethods
+//! [`LuaSerdeExt`]: crate::LuaSerdeExt
+//! [`Value`]: crate::Value
+//! [`create_async_function`]: crate::Lua::create_async_function
+//! [`call_async`]: crate::Function::call_async
+//! [`AsyncThread`]: crate::AsyncThread
+//! [`Future`]: std::future::Future
 //! [`serde::Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html
 //! [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html

 // mlua types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/mlua/0.6.2")]
+#![doc(html_root_url = "https://docs.rs/mlua/0.8.0-beta.2")]
 // Deny warnings inside doc tests / examples. When this isn't present, rustdoc doesn't show *any*
 // warnings at all.
 #![doc(test(attr(deny(warnings))))]
@@ -81,6 +81,7 @@
 #[macro_use]
 mod macros;

+mod chunk;
 mod conversion;
 mod error;
 mod ffi;
@@ -95,15 +96,19 @@ mod table;
 mod thread;
 mod types;
 mod userdata;
+mod userdata_impl;
 mod util;
 mod value;

+pub mod prelude;
+
 pub use crate::{ffi::lua_CFunction, ffi::lua_State};

+pub use crate::chunk::{AsChunk, Chunk, ChunkMode};
 pub use crate::error::{Error, ExternalError, ExternalResult, Result};
 pub use crate::function::Function;
-pub use crate::hook::{Debug, DebugNames, DebugSource, DebugStack, HookTriggers};
-pub use crate::lua::{AsChunk, Chunk, ChunkMode, GCMode, Lua, LuaOptions};
+pub use crate::hook::{Debug, DebugEvent, DebugNames, DebugSource, DebugStack};
+pub use crate::lua::{GCMode, Lua, LuaOptions};
 pub use crate::multi::Variadic;
 pub use crate::scope::Scope;
 pub use crate::stdlib::StdLib;
@@ -116,14 +121,22 @@ pub use crate::userdata::{
 };
 pub use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti, Value};

+#[cfg(not(feature = "luau"))]
+pub use crate::hook::HookTriggers;
+
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+pub use crate::chunk::Compiler;
+
 #[cfg(feature = "async")]
 pub use crate::thread::AsyncThread;

 #[cfg(feature = "serialize")]
 #[doc(inline)]
-pub use crate::serde::{ser::Options as SerializeOptions, LuaSerdeExt};
+pub use crate::serde::{
+    de::Options as DeserializeOptions, ser::Options as SerializeOptions, LuaSerdeExt,
+};

-pub mod prelude;
 #[cfg(feature = "serialize")]
 #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
 pub mod serde;
@@ -182,13 +195,30 @@ extern crate mlua_derive;
 ///
 /// Everything else should work.
 ///
-/// [`AsChunk`]: trait.AsChunk.html
-/// [`UserData`]: trait.UserData.html
-/// [`ToLua`]: trait.ToLua.html
+/// [`AsChunk`]: crate::AsChunk
+/// [`UserData`]: crate::UserData
+/// [`ToLua`]: crate::ToLua
 #[cfg(any(feature = "macros"))]
 #[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
 pub use mlua_derive::chunk;

-#[cfg(any(feature = "module"))]
+/// Registers Lua module entrypoint.
+///
+/// You can register multiple entrypoints as required.
+///
+/// ```
+/// use mlua::{Lua, Result, Table};
+///
+/// #[mlua::lua_module]
+/// fn my_module(lua: &Lua) -> Result<Table> {
+///     let exports = lua.create_table()?;
+///     exports.set("hello", "world")?;
+///     Ok(exports)
+/// }
+/// ```
+///
+/// Internally in the code above the compiler defines C function `luaopen_my_module`.
+///
+#[cfg(any(feature = "module", docsrs))]
 #[cfg_attr(docsrs, doc(cfg(feature = "module")))]
 pub use mlua_derive::lua_module;
@@ -17,19 +17,19 @@ macro_rules! cstr {

 macro_rules! mlua_panic {
    ($msg:expr) => {
-        panic!(bug_msg!($msg));
+        panic!(bug_msg!($msg))
    };

    ($msg:expr,) => {
-        mlua_panic!($msg);
+        mlua_panic!($msg)
    };

    ($msg:expr, $($arg:expr),+) => {
-        panic!(bug_msg!($msg), $($arg),+);
+        panic!(bug_msg!($msg), $($arg),+)
    };

    ($msg:expr, $($arg:expr),+,) => {
-        mlua_panic!($msg, $($arg),+);
+        mlua_panic!($msg, $($arg),+)
    };
 }

@@ -94,3 +94,18 @@ macro_rules! require_module_feature {
        compile_error!("Feature `module` must be enabled in the `mlua` crate");
    };
 }
+
+macro_rules! protect_lua {
+    ($state:expr, $nargs:expr, $nresults:expr, $f:expr) => {
+        crate::util::protect_lua_closure($state, $nargs, $nresults, $f)
+    };
+
+    ($state:expr, $nargs:expr, $nresults:expr, fn($state_inner:ident) $code:expr) => {{
+        unsafe extern "C" fn do_call($state_inner: *mut ffi::lua_State) -> ::std::os::raw::c_int {
+            $code;
+            $nresults
+        }
+
+        crate::util::protect_lua_call($state, $nargs, do_call)
+    }};
+}
@@ -12,8 +12,7 @@ use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti};
 /// on success, or in the case of an error, returning `nil` and an error message.
 impl<'lua, T: ToLua<'lua>, E: ToLua<'lua>> ToLuaMulti<'lua> for StdResult<T, E> {
    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut result = MultiValue::new();
-
+        let mut result = MultiValue::new_or_cached(lua);
        match self {
            Ok(v) => result.push_front(v.to_lua(lua)?),
            Err(e) => {
@@ -21,14 +20,13 @@ impl<'lua, T: ToLua<'lua>, E: ToLua<'lua>> ToLuaMulti<'lua> for StdResult<T, E>
                result.push_front(Nil);
            }
        }
-
        Ok(result)
    }
 }

 impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for T {
    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut v = MultiValue::new();
+        let mut v = MultiValue::new_or_cached(lua);
        v.push_front(self.to_lua(lua)?);
        Ok(v)
    }
@@ -36,7 +34,9 @@ impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for T {

 impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for T {
    fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
-        T::from_lua(values.pop_front().unwrap_or(Nil), lua)
+        let res = T::from_lua(values.pop_front().unwrap_or(Nil), lua);
+        lua.cache_multivalue(values);
+        res
    }
 }

@@ -76,8 +76,8 @@ impl<'lua> FromLuaMulti<'lua> for MultiValue<'lua> {
 /// # }
 /// ```
 ///
-/// [`FromLua`]: trait.FromLua.html
-/// [`MultiValue`]: struct.MultiValue.html
+/// [`FromLua`]: crate::FromLua
+/// [`MultiValue`]: crate::MultiValue
 #[derive(Debug, Clone)]
 pub struct Variadic<T>(Vec<T>);

@@ -125,30 +125,35 @@ impl<T> DerefMut for Variadic<T> {

 impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for Variadic<T> {
    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        self.0.into_iter().map(|e| e.to_lua(lua)).collect()
+        let mut values = MultiValue::new_or_cached(lua);
+        values.refill(self.0.into_iter().map(|e| e.to_lua(lua)))?;
+        Ok(values)
    }
 }

 impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for Variadic<T> {
-    fn from_lua_multi(values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
-        values
-            .into_iter()
+    fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
+        let res = values
+            .drain_all()
            .map(|e| T::from_lua(e, lua))
            .collect::<Result<Vec<T>>>()
-            .map(Variadic)
+            .map(Variadic);
+        lua.cache_multivalue(values);
+        res
    }
 }

 macro_rules! impl_tuple {
    () => (
        impl<'lua> ToLuaMulti<'lua> for () {
-            fn to_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
-                Ok(MultiValue::new())
+            fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+                Ok(MultiValue::new_or_cached(lua))
            }
        }

        impl<'lua> FromLuaMulti<'lua> for () {
-            fn from_lua_multi(_: MultiValue<'lua>, _: &'lua Lua) -> Result<Self> {
+            fn from_lua_multi(values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
+                lua.cache_multivalue(values);
                Ok(())
            }
        }
@@ -1,21 +1,27 @@
 //! Re-exports most types with an extra `Lua*` prefix to prevent name clashes.

+#[doc(no_inline)]
 pub use crate::{
    AnyUserData as LuaAnyUserData, Chunk as LuaChunk, Error as LuaError,
    ExternalError as LuaExternalError, ExternalResult as LuaExternalResult, FromLua, FromLuaMulti,
    Function as LuaFunction, GCMode as LuaGCMode, Integer as LuaInteger,
    LightUserData as LuaLightUserData, Lua, LuaOptions, MetaMethod as LuaMetaMethod,
    MultiValue as LuaMultiValue, Nil as LuaNil, Number as LuaNumber, RegistryKey as LuaRegistryKey,
-    Result as LuaResult, String as LuaString, Table as LuaTable, TableExt as LuaTableExt,
-    TablePairs as LuaTablePairs, TableSequence as LuaTableSequence, Thread as LuaThread,
-    ThreadStatus as LuaThreadStatus, ToLua, ToLuaMulti, UserData as LuaUserData,
-    UserDataFields as LuaUserDataFields, UserDataMetatable as LuaUserDataMetatable,
-    UserDataMethods as LuaUserDataMethods, Value as LuaValue,
+    Result as LuaResult, StdLib as LuaStdLib, String as LuaString, Table as LuaTable,
+    TableExt as LuaTableExt, TablePairs as LuaTablePairs, TableSequence as LuaTableSequence,
+    Thread as LuaThread, ThreadStatus as LuaThreadStatus, ToLua, ToLuaMulti,
+    UserData as LuaUserData, UserDataFields as LuaUserDataFields,
+    UserDataMetatable as LuaUserDataMetatable, UserDataMethods as LuaUserDataMethods,
+    Value as LuaValue,
 };

 #[cfg(feature = "async")]
+#[doc(no_inline)]
 pub use crate::AsyncThread as LuaAsyncThread;

 #[cfg(feature = "serialize")]
-#[doc(inline)]
-pub use crate::{LuaSerdeExt, SerializeOptions as LuaSerializeOptions};
+#[doc(no_inline)]
+pub use crate::{
+    DeserializeOptions as LuaDeserializeOptions, LuaSerdeExt,
+    SerializeOptions as LuaSerializeOptions,
+};
@@ -3,7 +3,6 @@ use std::cell::{Cell, RefCell};
 use std::marker::PhantomData;
 use std::mem;
 use std::os::raw::{c_int, c_void};
-use std::ptr;
 use std::rc::Rc;

 #[cfg(feature = "serialize")]
@@ -18,11 +17,14 @@ use crate::userdata::{
    AnyUserData, MetaMethod, UserData, UserDataCell, UserDataFields, UserDataMethods,
 };
 use crate::util::{
-    assert_stack, check_stack, get_userdata, init_userdata_metatable, protect_lua, push_table,
-    rawset_field, take_userdata, StackGuard,
+    assert_stack, check_stack, get_userdata, init_userdata_metatable, push_table, rawset_field,
+    take_userdata, StackGuard,
 };
 use crate::value::{FromLua, FromLuaMulti, MultiValue, ToLua, ToLuaMulti, Value};

+#[cfg(feature = "lua54")]
+use crate::userdata::USER_VALUE_MAXSLOT;
+
 #[cfg(feature = "async")]
 use {
    crate::types::{AsyncCallback, AsyncCallbackUpvalue, AsyncPollUpvalue},
@@ -35,7 +37,7 @@ use {
 ///
 /// See [`Lua::scope`] for more details.
 ///
-/// [`Lua::scope`]: struct.Lua.html#method.scope
+/// [`Lua::scope`]: crate::Lua.html::scope
 pub struct Scope<'lua, 'scope> {
    lua: &'lua Lua,
    destructors: RefCell<Vec<(LuaRef<'lua>, DestructorCallback<'lua>)>>,
@@ -58,8 +60,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
    /// This is a version of [`Lua::create_function`] that creates a callback which expires on
    /// scope drop. See [`Lua::scope`] for more details.
    ///
-    /// [`Lua::create_function`]: struct.Lua.html#method.create_function
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
+    /// [`Lua::create_function`]: crate::Lua::create_function
+    /// [`Lua::scope`]: crate::Lua::scope
    pub fn create_function<'callback, A, R, F>(&'callback self, func: F) -> Result<Function<'lua>>
    where
        A: FromLuaMulti<'callback>,
@@ -87,8 +89,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
    /// This is a version of [`Lua::create_function_mut`] that creates a callback which expires
    /// on scope drop. See [`Lua::scope`] and [`Scope::create_function`] for more details.
    ///
-    /// [`Lua::create_function_mut`]: struct.Lua.html#method.create_function_mut
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
+    /// [`Lua::create_function_mut`]: crate::Lua::create_function_mut
+    /// [`Lua::scope`]: crate::Lua::scope
    /// [`Scope::create_function`]: #method.create_function
    pub fn create_function_mut<'callback, A, R, F>(
        &'callback self,
@@ -101,7 +103,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
    {
        let func = RefCell::new(func);
        self.create_function(move |lua, args| {
-            (&mut *func
+            (*func
                .try_borrow_mut()
                .map_err(|_| Error::RecursiveMutCallback)?)(lua, args)
        })
@@ -114,9 +116,9 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
    ///
    /// Requires `feature = "async"`
    ///
-    /// [`Lua::create_async_function`]: struct.Lua.html#method.create_async_function
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
-    /// [`Lua::async_scope`]: struct.Lua.html#method.async_scope
+    /// [`Lua::create_async_function`]: crate::Lua::create_async_function
+    /// [`Lua::scope`]: crate::Lua::scope
+    /// [`Lua::async_scope`]: crate::Lua::async_scope
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
    pub fn create_async_function<'callback, A, R, F, FR>(
@@ -147,8 +149,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
    /// UserData be 'static).
    /// See [`Lua::scope`] for more details.
    ///
-    /// [`Lua::create_userdata`]: struct.Lua.html#method.create_userdata
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
+    /// [`Lua::create_userdata`]: crate::Lua::create_userdata
+    /// [`Lua::scope`]: crate::Lua::scope
    pub fn create_userdata<T>(&self, data: T) -> Result<AnyUserData<'lua>>
    where
        T: 'static + UserData,
@@ -165,8 +167,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
    ///
    /// Requires `feature = "serialize"`
    ///
-    /// [`Lua::create_ser_userdata`]: struct.Lua.html#method.create_ser_userdata
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
+    /// [`Lua::create_ser_userdata`]: crate::Lua::create_ser_userdata
+    /// [`Lua::scope`]: crate::Lua::scope
    #[cfg(feature = "serialize")]
    #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
    pub fn create_ser_userdata<T>(&self, data: T) -> Result<AnyUserData<'lua>>
@@ -192,16 +194,27 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                let _sg = StackGuard::new(state);
                assert_stack(state, 2);

-                ud.lua.push_ref(&ud);
+                // Check that userdata is not destructed (via `take()` call)
+                if ud.lua.push_userdata_ref(&ud).is_err() {
+                    return vec![];
+                }

-                // We know the destructor has not run yet because we hold a reference to the userdata.
-
-                // Clear uservalue
-                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                ffi::lua_pushnil(state);
+                // Clear associated user values
+                #[cfg(feature = "lua54")]
+                for i in 1..=USER_VALUE_MAXSLOT {
+                    ffi::lua_pushnil(state);
+                    ffi::lua_setiuservalue(state, -2, i as c_int);
+                }
+                #[cfg(any(feature = "lua53", feature = "lua52", feature = "luau"))]
+                {
+                    ffi::lua_pushnil(state);
+                    ffi::lua_setuservalue(state, -2);
+                }
                #[cfg(any(feature = "lua51", feature = "luajit"))]
-                ud.lua.push_ref(&newtable.0);
-                ffi::lua_setuservalue(state, -2);
+                {
+                    ud.lua.push_ref(&newtable.0);
+                    ffi::lua_setuservalue(state, -2);
+                }

                vec![Box::new(take_userdata::<UserDataCell<T>>(state))]
            });
@@ -233,9 +246,9 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
    /// creating the userdata metatable each time a new userdata is created.
    ///
    /// [`Scope::create_userdata`]: #method.create_userdata
-    /// [`Lua::create_userdata`]: struct.Lua.html#method.create_userdata
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
-    /// [`UserDataMethods`]: trait.UserDataMethods.html
+    /// [`Lua::create_userdata`]: crate::Lua::create_userdata
+    /// [`Lua::scope`]:crate::Lua::scope
+    /// [`UserDataMethods`]: crate::UserDataMethods
    pub fn create_nonstatic_userdata<T>(&self, data: T) -> Result<AnyUserData<'lua>>
    where
        T: 'scope + UserData,
@@ -250,7 +263,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
        fn wrap_method<'scope, 'lua, 'callback: 'scope, T: 'scope>(
            scope: &Scope<'lua, 'scope>,
            data: Rc<RefCell<T>>,
-            data_ptr: *mut c_void,
+            ud_ptr: *const c_void,
            method: NonStaticMethod<'callback, T>,
        ) -> Result<Function<'lua>> {
            // On methods that actually receive the userdata, we fake a type check on the passed in
@@ -264,9 +277,9 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                if let Some(Value::UserData(ud)) = value {
                    unsafe {
                        let _sg = StackGuard::new(lua.state);
-                        check_stack(lua.state, 3)?;
-                        lua.push_userdata_ref(&ud.0, false)?;
-                        if get_userdata(lua.state, -1) == data_ptr {
+                        check_stack(lua.state, 2)?;
+                        lua.push_userdata_ref(&ud.0)?;
+                        if get_userdata(lua.state, -1) as *const _ == ud_ptr {
                            return Ok(());
                        }
                    }
@@ -293,7 +306,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                        let mut data = data
                            .try_borrow_mut()
                            .map_err(|_| Error::UserDataBorrowMutError)?;
-                        (&mut *method)(lua, &mut *data, args)
+                        (*method)(lua, &mut *data, args)
                    });
                    unsafe { scope.create_callback(f) }
                }
@@ -301,7 +314,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                NonStaticMethod::FunctionMut(function) => {
                    let function = RefCell::new(function);
                    let f = Box::new(move |lua, args| {
-                        (&mut *function
+                        (*function
                            .try_borrow_mut()
                            .map_err(|_| Error::RecursiveMutCallback)?)(
                            lua, args
@@ -322,16 +335,37 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
            let _sg = StackGuard::new(lua.state);
            check_stack(lua.state, 13)?;

-            let data_ptr = protect_lua(lua.state, 0, 1, |state| {
-                ffi::lua_newuserdata(state, mem::size_of::<UserDataCell<Rc<RefCell<T>>>>())
+            #[cfg(not(feature = "luau"))]
+            #[allow(clippy::let_and_return)]
+            let ud_ptr = protect_lua!(lua.state, 0, 1, |state| {
+                let ud =
+                    ffi::lua_newuserdata(state, mem::size_of::<UserDataCell<Rc<RefCell<T>>>>());
+
+                // Set empty environment for Lua 5.1
+                #[cfg(any(feature = "lua51", feature = "luajit"))]
+                {
+                    ffi::lua_newtable(state);
+                    ffi::lua_setuservalue(state, -2);
+                }
+
+                ud
            })?;
+            #[cfg(feature = "luau")]
+            let ud_ptr = {
+                crate::util::push_userdata::<UserDataCell<Rc<RefCell<T>>>>(
+                    lua.state,
+                    UserDataCell::new(data.clone()),
+                )?;
+                ffi::lua_touserdata(lua.state, -1)
+            };
+
            // Prepare metatable, add meta methods first and then meta fields
            let meta_methods_nrec = ud_methods.meta_methods.len() + ud_fields.meta_fields.len() + 1;
            push_table(lua.state, 0, meta_methods_nrec as c_int)?;

            for (k, m) in ud_methods.meta_methods {
                let data = data.clone();
-                lua.push_value(Value::Function(wrap_method(self, data, data_ptr, m)?))?;
+                lua.push_value(Value::Function(wrap_method(self, data, ud_ptr, m)?))?;
                rawset_field(lua.state, -2, k.validate()?.name())?;
            }
            for (k, f) in ud_fields.meta_fields {
@@ -346,7 +380,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                push_table(lua.state, 0, field_getters_nrec as c_int)?;
                for (k, m) in ud_fields.field_getters {
                    let data = data.clone();
-                    lua.push_value(Value::Function(wrap_method(self, data, data_ptr, m)?))?;
+                    lua.push_value(Value::Function(wrap_method(self, data, ud_ptr, m)?))?;
                    rawset_field(lua.state, -2, &k)?;
                }
                field_getters_index = Some(ffi::lua_absindex(lua.state, -1));
@@ -358,7 +392,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                push_table(lua.state, 0, field_setters_nrec as c_int)?;
                for (k, m) in ud_fields.field_setters {
                    let data = data.clone();
-                    lua.push_value(Value::Function(wrap_method(self, data, data_ptr, m)?))?;
+                    lua.push_value(Value::Function(wrap_method(self, data, ud_ptr, m)?))?;
                    rawset_field(lua.state, -2, &k)?;
                }
                field_setters_index = Some(ffi::lua_absindex(lua.state, -1));
@@ -371,7 +405,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                push_table(lua.state, 0, methods_nrec as c_int)?;
                for (k, m) in ud_methods.methods {
                    let data = data.clone();
-                    lua.push_value(Value::Function(wrap_method(self, data, data_ptr, m)?))?;
+                    lua.push_value(Value::Function(wrap_method(self, data, ud_ptr, m)?))?;
                    rawset_field(lua.state, -2, &k)?;
                }
                methods_index = Some(ffi::lua_absindex(lua.state, -1));
@@ -390,12 +424,13 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                + methods_index.map(|_| 1).unwrap_or(0);
            ffi::lua_pop(lua.state, count);

-            let mt_id = ffi::lua_topointer(lua.state, -1);
+            let mt_ptr = ffi::lua_topointer(lua.state, -1);
            // Write userdata just before attaching metatable with `__gc` metamethod
-            ptr::write(data_ptr as _, UserDataCell::new(data));
+            #[cfg(not(feature = "luau"))]
+            std::ptr::write(ud_ptr as _, UserDataCell::new(data));
            ffi::lua_setmetatable(lua.state, -2);
            let ud = AnyUserData(lua.pop_ref());
-            lua.register_userdata_metatable(mt_id as isize);
+            lua.register_userdata_metatable(mt_ptr, None);

            #[cfg(any(feature = "lua51", feature = "luajit"))]
            let newtable = lua.create_table()?;
@@ -404,22 +439,33 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
                let _sg = StackGuard::new(state);
                assert_stack(state, 2);

-                ud.lua.push_ref(&ud);
-
-                // We know the destructor has not run yet because we hold a reference to the userdata.
+                // Check that userdata is valid (very likely)
+                if ud.lua.push_userdata_ref(&ud).is_err() {
+                    return vec![];
+                }

                // Deregister metatable
                ffi::lua_getmetatable(state, -1);
-                let mt_id = ffi::lua_topointer(state, -1);
+                let mt_ptr = ffi::lua_topointer(state, -1);
                ffi::lua_pop(state, 1);
-                ud.lua.deregister_userdata_metatable(mt_id as isize);
+                ud.lua.deregister_userdata_metatable(mt_ptr);

-                // Clear uservalue
-                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                ffi::lua_pushnil(state);
+                // Clear associated user values
+                #[cfg(feature = "lua54")]
+                for i in 1..=USER_VALUE_MAXSLOT {
+                    ffi::lua_pushnil(state);
+                    ffi::lua_setiuservalue(state, -2, i as c_int);
+                }
+                #[cfg(any(feature = "lua53", feature = "lua52", feature = "luau"))]
+                {
+                    ffi::lua_pushnil(state);
+                    ffi::lua_setuservalue(state, -2);
+                }
                #[cfg(any(feature = "lua51", feature = "luajit"))]
-                ud.lua.push_ref(&newtable.0);
-                ffi::lua_setuservalue(state, -2);
+                {
+                    ud.lua.push_ref(&newtable.0);
+                    ffi::lua_setuservalue(state, -2);
+                }

                // A hack to drop non-static `T`
                unsafe fn seal<T>(t: T) -> Box<dyn FnOnce() + 'static> {
@@ -496,7 +542,7 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
            // First, get the environment table
            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
            ffi::lua_getupvalue(state, -1, 1);
-            #[cfg(any(feature = "lua51", feature = "luajit"))]
+            #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
            ffi::lua_getfenv(state, -1);

            // Second, get the `get_poll()` closure using the corresponding key
@@ -691,6 +737,21 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
        ));
    }

+    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
+    fn add_async_meta_method<S, A, R, M, MR>(&mut self, _meta: S, _method: M)
+    where
+        T: Clone,
+        S: Into<MetaMethod>,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
+        MR: 'lua + Future<Output = Result<R>>,
+    {
+        // The panic should never happen as async non-static code wouldn't compile
+        // Non-static lifetime must be bounded to 'lua lifetime
+        mlua_panic!("asynchronous meta methods are not supported for non-static userdata")
+    }
+
    fn add_meta_function<S, A, R, F>(&mut self, meta: S, function: F)
    where
        S: Into<MetaMethod>,
@@ -720,6 +781,20 @@ impl<'lua, T: UserData> UserDataMethods<'lua, T> for NonStaticUserDataMethods<'l
            })),
        ));
    }
+
+    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
+    fn add_async_meta_function<S, A, R, F, FR>(&mut self, _meta: S, _function: F)
+    where
+        S: Into<MetaMethod>,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
+        FR: 'lua + Future<Output = Result<R>>,
+    {
+        // The panic should never happen as async non-static code wouldn't compile
+        // Non-static lifetime must be bounded to 'lua lifetime
+        mlua_panic!("asynchronous meta functions are not supported for non-static userdata")
+    }
 }

 struct NonStaticUserDataFields<'lua, T: UserData> {
@@ -1,19 +1,108 @@
+use std::cell::RefCell;
+use std::convert::TryInto;
+use std::os::raw::c_void;
+use std::rc::Rc;
 use std::string::String as StdString;

+use rustc_hash::FxHashSet;
 use serde::de::{self, IntoDeserializer};

 use crate::error::{Error, Result};
-use crate::table::{TablePairs, TableSequence};
+use crate::ffi;
+use crate::table::{Table, TablePairs, TableSequence};
 use crate::value::Value;

 /// A struct for deserializing Lua values into Rust values.
 #[derive(Debug)]
-pub struct Deserializer<'lua>(Value<'lua>);
+pub struct Deserializer<'lua> {
+    value: Value<'lua>,
+    options: Options,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
+}
+
+/// A struct with options to change default deserializer behavior.
+#[derive(Debug, Clone, Copy)]
+#[non_exhaustive]
+pub struct Options {
+    /// If true, an attempt to serialize types such as [`Thread`], [`UserData`], [`LightUserData`]
+    /// and [`Error`] will cause an error.
+    /// Otherwise these types skipped when iterating or serialized as unit type.
+    ///
+    /// Default: **true**
+    ///
+    /// [`Thread`]: crate::Thread
+    /// [`UserData`]: crate::UserData
+    /// [`LightUserData`]: crate::LightUserData
+    /// [`Error`]: crate::Error
+    pub deny_unsupported_types: bool,
+
+    /// If true, an attempt to serialize a recursive table (table that refers to itself)
+    /// will cause an error.
+    /// Otherwise subsequent attempts to serialize the same table will be ignored.
+    ///
+    /// Default: **true**
+    pub deny_recursive_tables: bool,
+}
+
+impl Default for Options {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Options {
+    /// Returns a new instance of `Options` with default parameters.
+    pub const fn new() -> Self {
+        Options {
+            deny_unsupported_types: true,
+            deny_recursive_tables: true,
+        }
+    }
+
+    /// Sets [`deny_unsupported_types`] option.
+    ///
+    /// [`deny_unsupported_types`]: #structfield.deny_unsupported_types
+    #[must_use]
+    pub const fn deny_unsupported_types(mut self, enabled: bool) -> Self {
+        self.deny_unsupported_types = enabled;
+        self
+    }
+
+    /// Sets [`deny_recursive_tables`] option.
+    ///
+    /// [`deny_recursive_tables`]: #structfield.deny_recursive_tables
+    #[must_use]
+    pub fn deny_recursive_tables(mut self, enabled: bool) -> Self {
+        self.deny_recursive_tables = enabled;
+        self
+    }
+}

 impl<'lua> Deserializer<'lua> {
    /// Creates a new Lua Deserializer for the `Value`.
    pub fn new(value: Value<'lua>) -> Self {
-        Deserializer(value)
+        Self::new_with_options(value, Options::default())
+    }
+
+    /// Creates a new Lua Deserializer for the `Value` with custom options.
+    pub fn new_with_options(value: Value<'lua>, options: Options) -> Self {
+        Deserializer {
+            value,
+            options,
+            visited: Rc::new(RefCell::new(FxHashSet::default())),
+        }
+    }
+
+    fn from_parts(
+        value: Value<'lua>,
+        options: Options,
+        visited: Rc<RefCell<FxHashSet<*const c_void>>>,
+    ) -> Self {
+        Deserializer {
+            value,
+            options,
+            visited,
+        }
    }
 }

@@ -25,13 +114,17 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
    where
        V: de::Visitor<'de>,
    {
-        match self.0 {
+        match self.value {
            Value::Nil => visitor.visit_unit(),
            Value::Boolean(b) => visitor.visit_bool(b),
            #[allow(clippy::useless_conversion)]
-            Value::Integer(i) => visitor.visit_i64(i.into()),
+            Value::Integer(i) => {
+                visitor.visit_i64(i.try_into().expect("cannot convert lua_Integer to i64"))
+            }
            #[allow(clippy::useless_conversion)]
            Value::Number(n) => visitor.visit_f64(n.into()),
+            #[cfg(feature = "luau")]
+            Value::Vector(_, _, _) => self.deserialize_seq(visitor),
            Value::String(s) => match s.to_str() {
                Ok(s) => visitor.visit_str(s),
                Err(_) => visitor.visit_bytes(s.as_bytes()),
@@ -43,7 +136,16 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
            | Value::Thread(_)
            | Value::UserData(_)
            | Value::LightUserData(_)
-            | Value::Error(_) => Err(de::Error::custom("invalid value type")),
+            | Value::Error(_) => {
+                if self.options.deny_unsupported_types {
+                    Err(de::Error::custom(format!(
+                        "unsupported value type `{}`",
+                        self.value.type_name()
+                    )))
+                } else {
+                    visitor.visit_unit()
+                }
+            }
        }
    }

@@ -52,7 +154,7 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
    where
        V: de::Visitor<'de>,
    {
-        match self.0 {
+        match self.value {
            Value::Nil => visitor.visit_none(),
            Value::LightUserData(ud) if ud.0.is_null() => visitor.visit_none(),
            _ => visitor.visit_some(self),
@@ -69,9 +171,11 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
    where
        V: de::Visitor<'de>,
    {
-        let (variant, value) = match self.0 {
-            Value::Table(value) => {
-                let mut iter = value.pairs::<StdString, Value>();
+        let (variant, value, _guard) = match self.value {
+            Value::Table(table) => {
+                let _guard = RecursionGuard::new(&table, &self.visited);
+
+                let mut iter = table.pairs::<StdString, Value>();
                let (variant, value) = match iter.next() {
                    Some(v) => v?,
                    None => {
@@ -88,13 +192,22 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                        &"map with a single key",
                    ));
                }
-                (variant, Some(value))
+                if check_value_if_skip(&value, self.options, &self.visited)? {
+                    return Err(de::Error::custom("bad enum value"));
+                }
+
+                (variant, Some(value), Some(_guard))
            }
-            Value::String(variant) => (variant.to_str()?.to_owned(), None),
+            Value::String(variant) => (variant.to_str()?.to_owned(), None, None),
            _ => return Err(de::Error::custom("bad enum value")),
        };

-        visitor.visit_enum(EnumDeserializer { variant, value })
+        visitor.visit_enum(EnumDeserializer {
+            variant,
+            value,
+            options: self.options,
+            visited: self.visited,
+        })
    }

    #[inline]
@@ -102,12 +215,28 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
    where
        V: de::Visitor<'de>,
    {
-        match self.0 {
+        match self.value {
+            #[cfg(feature = "luau")]
+            Value::Vector(x, y, z) => {
+                let mut deserializer = VecDeserializer {
+                    vec: [x, y, z],
+                    next: 0,
+                    options: self.options,
+                    visited: self.visited,
+                };
+                visitor.visit_seq(&mut deserializer)
+            }
            Value::Table(t) => {
+                let _guard = RecursionGuard::new(&t, &self.visited);
+
                let len = t.raw_len() as usize;
-                let mut deserializer = SeqDeserializer(t.raw_sequence_values());
+                let mut deserializer = SeqDeserializer {
+                    seq: t.raw_sequence_values(),
+                    options: self.options,
+                    visited: self.visited,
+                };
                let seq = visitor.visit_seq(&mut deserializer)?;
-                if deserializer.0.count() == 0 {
+                if deserializer.seq.count() == 0 {
                    Ok(seq)
                } else {
                    Err(de::Error::invalid_length(
@@ -116,7 +245,10 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                    ))
                }
            }
-            _ => Err(de::Error::custom("invalid value type")),
+            value => Err(de::Error::invalid_type(
+                de::Unexpected::Other(value.type_name()),
+                &"table",
+            )),
        }
    }

@@ -146,9 +278,17 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
    where
        V: de::Visitor<'de>,
    {
-        match self.0 {
+        match self.value {
            Value::Table(t) => {
-                let mut deserializer = MapDeserializer::new(t.pairs());
+                let _guard = RecursionGuard::new(&t, &self.visited);
+
+                let mut deserializer = MapDeserializer {
+                    pairs: t.pairs(),
+                    value: None,
+                    options: self.options,
+                    visited: self.visited,
+                    processed: 0,
+                };
                let map = visitor.visit_map(&mut deserializer)?;
                let count = deserializer.pairs.count();
                if count == 0 {
@@ -160,7 +300,10 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                    ))
                }
            }
-            _ => Err(de::Error::custom("invalid value type")),
+            value => Err(de::Error::invalid_type(
+                de::Unexpected::Other(value.type_name()),
+                &"table",
+            )),
        }
    }

@@ -178,13 +321,17 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
    }

    serde::forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string bytes
        byte_buf unit unit_struct newtype_struct
        identifier ignored_any
    }
 }

-struct SeqDeserializer<'lua>(TableSequence<'lua, Value<'lua>>);
+struct SeqDeserializer<'lua> {
+    seq: TableSequence<'lua, Value<'lua>>,
+    options: Options,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
+}

 impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {
    type Error = Error;
@@ -193,36 +340,71 @@ impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {
    where
        T: de::DeserializeSeed<'de>,
    {
-        match self.0.next() {
-            Some(value) => seed.deserialize(Deserializer(value?)).map(Some),
-            None => Ok(None),
+        loop {
+            match self.seq.next() {
+                Some(value) => {
+                    let value = value?;
+                    if check_value_if_skip(&value, self.options, &self.visited)? {
+                        continue;
+                    }
+                    let visited = Rc::clone(&self.visited);
+                    let deserializer = Deserializer::from_parts(value, self.options, visited);
+                    return seed.deserialize(deserializer).map(Some);
+                }
+                None => return Ok(None),
+            }
        }
    }

    fn size_hint(&self) -> Option<usize> {
-        match self.0.size_hint() {
+        match self.seq.size_hint() {
            (lower, Some(upper)) if lower == upper => Some(upper),
            _ => None,
        }
    }
 }

+#[cfg(feature = "luau")]
+struct VecDeserializer {
+    vec: [f32; 3],
+    next: usize,
+    options: Options,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
+}
+
+#[cfg(feature = "luau")]
+impl<'de> de::SeqAccess<'de> for VecDeserializer {
+    type Error = Error;
+
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        match self.vec.get(self.next) {
+            Some(&n) => {
+                self.next += 1;
+                let visited = Rc::clone(&self.visited);
+                let deserializer =
+                    Deserializer::from_parts(Value::Number(n as _), self.options, visited);
+                seed.deserialize(deserializer).map(Some)
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn size_hint(&self) -> Option<usize> {
+        Some(3)
+    }
+}
+
 struct MapDeserializer<'lua> {
    pairs: TablePairs<'lua, Value<'lua>, Value<'lua>>,
    value: Option<Value<'lua>>,
+    options: Options,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
    processed: usize,
 }

-impl<'lua> MapDeserializer<'lua> {
-    fn new(pairs: TablePairs<'lua, Value<'lua>, Value<'lua>>) -> Self {
-        MapDeserializer {
-            pairs,
-            value: None,
-            processed: 0,
-        }
-    }
-}
-
 impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
    type Error = Error;

@@ -230,15 +412,23 @@ impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
    where
        T: de::DeserializeSeed<'de>,
    {
-        match self.pairs.next() {
-            Some(item) => {
-                let (key, value) = item?;
-                self.processed += 1;
-                self.value = Some(value);
-                let key_de = Deserializer(key);
-                seed.deserialize(key_de).map(Some)
+        loop {
+            match self.pairs.next() {
+                Some(item) => {
+                    let (key, value) = item?;
+                    if check_value_if_skip(&key, self.options, &self.visited)?
+                        || check_value_if_skip(&value, self.options, &self.visited)?
+                    {
+                        continue;
+                    }
+                    self.processed += 1;
+                    self.value = Some(value);
+                    let visited = Rc::clone(&self.visited);
+                    let key_de = Deserializer::from_parts(key, self.options, visited);
+                    return seed.deserialize(key_de).map(Some);
+                }
+                None => return Ok(None),
            }
-            None => Ok(None),
        }
    }

@@ -247,7 +437,10 @@ impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
        T: de::DeserializeSeed<'de>,
    {
        match self.value.take() {
-            Some(value) => seed.deserialize(Deserializer(value)),
+            Some(value) => {
+                let visited = Rc::clone(&self.visited);
+                seed.deserialize(Deserializer::from_parts(value, self.options, visited))
+            }
            None => Err(de::Error::custom("value is missing")),
        }
    }
@@ -263,6 +456,8 @@ impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
 struct EnumDeserializer<'lua> {
    variant: StdString,
    value: Option<Value<'lua>>,
+    options: Options,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }

 impl<'lua, 'de> de::EnumAccess<'de> for EnumDeserializer<'lua> {
@@ -274,13 +469,19 @@ impl<'lua, 'de> de::EnumAccess<'de> for EnumDeserializer<'lua> {
        T: de::DeserializeSeed<'de>,
    {
        let variant = self.variant.into_deserializer();
-        let variant_access = VariantDeserializer { value: self.value };
+        let variant_access = VariantDeserializer {
+            value: self.value,
+            options: self.options,
+            visited: self.visited,
+        };
        seed.deserialize(variant).map(|v| (v, variant_access))
    }
 }

 struct VariantDeserializer<'lua> {
    value: Option<Value<'lua>>,
+    options: Options,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }

 impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
@@ -301,7 +502,9 @@ impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
        T: de::DeserializeSeed<'de>,
    {
        match self.value {
-            Some(value) => seed.deserialize(Deserializer(value)),
+            Some(value) => {
+                seed.deserialize(Deserializer::from_parts(value, self.options, self.visited))
+            }
            None => Err(de::Error::invalid_type(
                de::Unexpected::UnitVariant,
                &"newtype variant",
@@ -314,7 +517,10 @@ impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
        V: de::Visitor<'de>,
    {
        match self.value {
-            Some(value) => serde::Deserializer::deserialize_seq(Deserializer(value), visitor),
+            Some(value) => serde::Deserializer::deserialize_seq(
+                Deserializer::from_parts(value, self.options, self.visited),
+                visitor,
+            ),
            None => Err(de::Error::invalid_type(
                de::Unexpected::UnitVariant,
                &"tuple variant",
@@ -327,7 +533,10 @@ impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
        V: de::Visitor<'de>,
    {
        match self.value {
-            Some(value) => serde::Deserializer::deserialize_map(Deserializer(value), visitor),
+            Some(value) => serde::Deserializer::deserialize_map(
+                Deserializer::from_parts(value, self.options, self.visited),
+                visitor,
+            ),
            None => Err(de::Error::invalid_type(
                de::Unexpected::UnitVariant,
                &"struct variant",
@@ -335,3 +544,60 @@ impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
        }
    }
 }
+
+// Adds `ptr` to the `visited` map and removes on drop
+// Used to track recursive tables but allow to traverse same tables multiple times
+struct RecursionGuard {
+    ptr: *const c_void,
+    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
+}
+
+impl RecursionGuard {
+    #[inline]
+    fn new(table: &Table, visited: &Rc<RefCell<FxHashSet<*const c_void>>>) -> Self {
+        let visited = Rc::clone(visited);
+        let lua = table.0.lua;
+        let ptr =
+            unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, table.0.index)) };
+        visited.borrow_mut().insert(ptr);
+        RecursionGuard { ptr, visited }
+    }
+}
+
+impl Drop for RecursionGuard {
+    fn drop(&mut self) {
+        self.visited.borrow_mut().remove(&self.ptr);
+    }
+}
+
+// Checks `options` and decides should we emit an error or skip next element
+fn check_value_if_skip(
+    value: &Value,
+    options: Options,
+    visited: &RefCell<FxHashSet<*const c_void>>,
+) -> Result<bool> {
+    match value {
+        Value::Table(table) => {
+            let lua = table.0.lua;
+            let ptr =
+                unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, table.0.index)) };
+            if visited.borrow().contains(&ptr) {
+                if options.deny_recursive_tables {
+                    return Err(de::Error::custom("recursive table detected"));
+                }
+                return Ok(true); // skip
+            }
+        }
+        Value::Function(_)
+        | Value::Thread(_)
+        | Value::UserData(_)
+        | Value::LightUserData(_)
+        | Value::Error(_)
+            if !options.deny_unsupported_types =>
+        {
+            return Ok(true); // skip
+        }
+        _ => {}
+    }
+    Ok(false) // do not skip
+}
@@ -10,10 +10,11 @@ use crate::ffi;
 use crate::lua::Lua;
 use crate::table::Table;
 use crate::types::LightUserData;
-use crate::util::{assert_stack, check_stack, protect_lua, StackGuard};
+use crate::util::{assert_stack, check_stack, StackGuard};
 use crate::value::Value;

 /// Trait for serializing/deserializing Lua values using Serde.
+#[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
 pub trait LuaSerdeExt<'lua> {
    /// A special value (lightuserdata) to encode/decode optional (none) values.
    ///
@@ -69,11 +70,11 @@ pub trait LuaSerdeExt<'lua> {
    /// ```
    fn array_metatable(&'lua self) -> Table<'lua>;

-    /// Converts `T` into a `Value` instance.
+    /// Converts `T` into a [`Value`] instance.
    ///
    /// Requires `feature = "serialize"`
    ///
-    /// [`Value`]: enum.Value.html
+    /// [`Value`]: crate::Value
    ///
    /// # Example
    ///
@@ -102,11 +103,11 @@ pub trait LuaSerdeExt<'lua> {
    /// ```
    fn to_value<T: Serialize + ?Sized>(&'lua self, t: &T) -> Result<Value<'lua>>;

-    /// Converts `T` into a `Value` instance with options.
+    /// Converts `T` into a [`Value`] instance with options.
    ///
    /// Requires `feature = "serialize"`
    ///
-    /// [`Value`]: enum.Value.html
+    /// [`Value`]: crate::Value
    ///
    /// # Example
    ///
@@ -129,11 +130,11 @@ pub trait LuaSerdeExt<'lua> {
    where
        T: Serialize + ?Sized;

-    /// Deserializes a `Value` into any serde deserializable object.
+    /// Deserializes a [`Value`] into any serde deserializable object.
    ///
    /// Requires `feature = "serialize"`
    ///
-    /// [`Value`]: enum.Value.html
+    /// [`Value`]: crate::Value
    ///
    /// # Example
    ///
@@ -158,6 +159,41 @@ pub trait LuaSerdeExt<'lua> {
    /// }
    /// ```
    fn from_value<T: Deserialize<'lua>>(&'lua self, value: Value<'lua>) -> Result<T>;
+
+    /// Deserializes a [`Value`] into any serde deserializable object with options.
+    ///
+    /// Requires `feature = "serialize"`
+    ///
+    /// [`Value`]: crate::Value
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use mlua::{Lua, Result, LuaSerdeExt, DeserializeOptions};
+    /// use serde::Deserialize;
+    ///
+    /// #[derive(Deserialize, Debug, PartialEq)]
+    /// struct User {
+    ///     name: String,
+    ///     age: u8,
+    /// }
+    ///
+    /// fn main() -> Result<()> {
+    ///     let lua = Lua::new();
+    ///     let val = lua.load(r#"{name = "John Smith", age = 20, f = function() end}"#).eval()?;
+    ///     let options = DeserializeOptions::new().deny_unsupported_types(false);
+    ///     let u: User = lua.from_value_with(val, options)?;
+    ///
+    ///     assert_eq!(u, User { name: "John Smith".into(), age: 20 });
+    ///
+    ///     Ok(())
+    /// }
+    /// ```
+    fn from_value_with<T: Deserialize<'lua>>(
+        &'lua self,
+        value: Value<'lua>,
+        options: de::Options,
+    ) -> Result<T>;
 }

 impl<'lua> LuaSerdeExt<'lua> for Lua {
@@ -196,12 +232,19 @@ impl<'lua> LuaSerdeExt<'lua> for Lua {
    {
        T::deserialize(de::Deserializer::new(value))
    }
+
+    fn from_value_with<T>(&'lua self, value: Value<'lua>, options: de::Options) -> Result<T>
+    where
+        T: Deserialize<'lua>,
+    {
+        T::deserialize(de::Deserializer::new_with_options(value, options))
+    }
 }

-// Uses 6 stack spaces and calls checkstack.
+// Uses 2 stack spaces and calls checkstack.
 pub(crate) unsafe fn init_metatables(state: *mut ffi::lua_State) -> Result<()> {
-    check_stack(state, 3)?;
-    protect_lua(state, 0, 0, |state| {
+    check_stack(state, 2)?;
+    protect_lua!(state, 0, 0, fn(state) {
        ffi::lua_createtable(state, 0, 1);

        ffi::lua_pushstring(state, cstr!("__metatable"));
@@ -9,7 +9,7 @@ use crate::lua::Lua;
 use crate::string::String;
 use crate::table::Table;
 use crate::types::Integer;
-use crate::util::{check_stack, protect_lua, StackGuard};
+use crate::util::{check_stack, StackGuard};
 use crate::value::{ToLua, Value};

 /// A struct for serializing Rust values into Lua values.
@@ -28,16 +28,16 @@ pub struct Options {
    ///
    /// Default: **true**
    ///
-    /// [`array_metatable`]: ../trait.LuaSerdeExt.html#tymethod.array_metatable
+    /// [`array_metatable`]: crate::LuaSerdeExt::array_metatable
    pub set_array_metatable: bool,

-    /// If true, serialize `None` (part of `Option` type) to [`null`].
+    /// If true, serialize `None` (part of the `Option` type) to [`null`].
    /// Otherwise it will be set to Lua [`Nil`].
    ///
    /// Default: **true**
    ///
-    /// [`null`]: ../trait.LuaSerdeExt.html#tymethod.null
-    /// [`Nil`]: ../../enum.Value.html#variant.Nil
+    /// [`null`]: crate::LuaSerdeExt::null
+    /// [`Nil`]: crate::Value::Nil
    pub serialize_none_to_null: bool,

    /// If true, serialize `Unit` (type of `()` in Rust) and Unit structs to [`null`].
@@ -45,31 +45,32 @@ pub struct Options {
    ///
    /// Default: **true**
    ///
-    /// [`null`]: ../trait.LuaSerdeExt.html#tymethod.null
-    /// [`Nil`]: ../../enum.Value.html#variant.Nil
+    /// [`null`]: crate::LuaSerdeExt::null
+    /// [`Nil`]: crate::Value::Nil
    pub serialize_unit_to_null: bool,
 }

 impl Default for Options {
    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl Options {
+    /// Returns a new instance of [`Options`] with default parameters.
+    pub const fn new() -> Self {
        Options {
            set_array_metatable: true,
            serialize_none_to_null: true,
            serialize_unit_to_null: true,
        }
    }
-}
-
-impl Options {
-    /// Retruns a new instance of `Options` with default parameters.
-    pub fn new() -> Self {
-        Self::default()
-    }

    /// Sets [`set_array_metatable`] option.
    ///
    /// [`set_array_metatable`]: #structfield.set_array_metatable
-    pub fn set_array_metatable(mut self, enabled: bool) -> Self {
+    #[must_use]
+    pub const fn set_array_metatable(mut self, enabled: bool) -> Self {
        self.set_array_metatable = enabled;
        self
    }
@@ -77,7 +78,8 @@ impl Options {
    /// Sets [`serialize_none_to_null`] option.
    ///
    /// [`serialize_none_to_null`]: #structfield.serialize_none_to_null
-    pub fn serialize_none_to_null(mut self, enabled: bool) -> Self {
+    #[must_use]
+    pub const fn serialize_none_to_null(mut self, enabled: bool) -> Self {
        self.serialize_none_to_null = enabled;
        self
    }
@@ -85,7 +87,8 @@ impl Options {
    /// Sets [`serialize_unit_to_null`] option.
    ///
    /// [`serialize_unit_to_null`]: #structfield.serialize_unit_to_null
-    pub fn serialize_unit_to_null(mut self, enabled: bool) -> Self {
+    #[must_use]
+    pub const fn serialize_unit_to_null(mut self, enabled: bool) -> Self {
        self.serialize_unit_to_null = enabled;
        self
    }
@@ -139,6 +142,8 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
    lua_serialize_number!(serialize_u32, u32);
    lua_serialize_number!(serialize_i64, i64);
    lua_serialize_number!(serialize_u64, u64);
+    lua_serialize_number!(serialize_i128, i128);
+    lua_serialize_number!(serialize_u128, u128);

    lua_serialize_number!(serialize_f32, f32);
    lua_serialize_number!(serialize_f64, f64);
@@ -318,12 +323,12 @@ impl<'lua> ser::SerializeSeq for SerializeVec<'lua> {
        let value = lua.to_value_with(value, self.options)?;
        unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 5)?;
+            check_stack(lua.state, 4)?;

            lua.push_ref(&self.table.0);
            lua.push_value(value)?;
-            let len = ffi::lua_rawlen(lua.state, -2) as Integer;
-            protect_lua(lua.state, 2, 0, |state| {
+            protect_lua!(lua.state, 2, 0, fn(state) {
+                let len = ffi::lua_rawlen(state, -2) as Integer;
                ffi::lua_rawseti(state, -2, len + 1);
            })
        }
@@ -6,32 +6,41 @@ use std::u32;
 pub struct StdLib(u32);

 impl StdLib {
-    /// [`coroutine`](https://www.lua.org/manual/5.3/manual.html#6.2) library
+    /// [`coroutine`](https://www.lua.org/manual/5.4/manual.html#6.2) library
    ///
-    /// Requires `feature = "lua54/lua53/lua52"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", doc))]
+    /// Requires `feature = "lua54/lua53/lua52/luau"`
+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luau"
+    ))]
    pub const COROUTINE: StdLib = StdLib(1);
-    /// [`table`](https://www.lua.org/manual/5.3/manual.html#6.6) library
+    /// [`table`](https://www.lua.org/manual/5.4/manual.html#6.6) library
    pub const TABLE: StdLib = StdLib(1 << 1);
-    /// [`io`](https://www.lua.org/manual/5.3/manual.html#6.8) library
+    /// [`io`](https://www.lua.org/manual/5.4/manual.html#6.8) library
+    #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
    pub const IO: StdLib = StdLib(1 << 2);
-    /// [`os`](https://www.lua.org/manual/5.3/manual.html#6.9) library
+    /// [`os`](https://www.lua.org/manual/5.4/manual.html#6.9) library
    pub const OS: StdLib = StdLib(1 << 3);
-    /// [`string`](https://www.lua.org/manual/5.3/manual.html#6.4) library
+    /// [`string`](https://www.lua.org/manual/5.4/manual.html#6.4) library
    pub const STRING: StdLib = StdLib(1 << 4);
-    /// [`utf8`](https://www.lua.org/manual/5.3/manual.html#6.5) library
+    /// [`utf8`](https://www.lua.org/manual/5.4/manual.html#6.5) library
    ///
-    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    /// Requires `feature = "lua54/lua53/luau"`
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))]
    pub const UTF8: StdLib = StdLib(1 << 5);
    /// [`bit`](https://www.lua.org/manual/5.2/manual.html#6.7) library
    ///
-    /// Requires `feature = "lua52/luajit"`
-    #[cfg(any(feature = "lua52", feature = "luajit", doc))]
+    /// Requires `feature = "lua52/luajit/luau"`
+    #[cfg(any(feature = "lua52", feature = "luajit", feature = "luau", doc))]
    pub const BIT: StdLib = StdLib(1 << 6);
-    /// [`math`](https://www.lua.org/manual/5.3/manual.html#6.7) library
+    /// [`math`](https://www.lua.org/manual/5.4/manual.html#6.7) library
    pub const MATH: StdLib = StdLib(1 << 7);
-    /// [`package`](https://www.lua.org/manual/5.3/manual.html#6.3) library
+    /// [`package`](https://www.lua.org/manual/5.4/manual.html#6.3) library
+    #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
    pub const PACKAGE: StdLib = StdLib(1 << 8);
    /// [`jit`](http://luajit.org/ext_jit.html) library
    ///
@@ -44,7 +53,7 @@ impl StdLib {
    /// Requires `feature = "luajit"`
    #[cfg(any(feature = "luajit", doc))]
    pub const FFI: StdLib = StdLib(1 << 30);
-    /// (**unsafe**) [`debug`](https://www.lua.org/manual/5.3/manual.html#6.10) library
+    /// (**unsafe**) [`debug`](https://www.lua.org/manual/5.4/manual.html#6.10) library
    pub const DEBUG: StdLib = StdLib(1 << 31);

    /// No libraries
@@ -2,15 +2,16 @@ use std::marker::PhantomData;

 #[cfg(feature = "serialize")]
 use {
-    serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer},
-    std::result::Result as StdResult,
+    rustc_hash::FxHashSet,
+    serde::ser::{self, Serialize, SerializeMap, SerializeSeq, Serializer},
+    std::{cell::RefCell, os::raw::c_void, result::Result as StdResult},
 };

 use crate::error::{Error, Result};
 use crate::ffi;
 use crate::function::Function;
 use crate::types::{Integer, LuaRef};
-use crate::util::{assert_stack, check_stack, protect_lua, StackGuard};
+use crate::util::{assert_stack, check_stack, StackGuard};
 use crate::value::{FromLua, FromLuaMulti, Nil, ToLua, ToLuaMulti, Value};

 #[cfg(feature = "async")]
@@ -62,12 +63,12 @@ impl<'lua> Table<'lua> {

        unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 6)?;
+            check_stack(lua.state, 5)?;

            lua.push_ref(&self.0);
            lua.push_value(key)?;
            lua.push_value(value)?;
-            protect_lua(lua.state, 3, 0, |state| ffi::lua_settable(state, -3))
+            protect_lua!(lua.state, 3, 0, fn(state) ffi::lua_settable(state, -3))
        }
    }

@@ -101,11 +102,11 @@ impl<'lua> Table<'lua> {

        let value = unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 5)?;
+            check_stack(lua.state, 4)?;

            lua.push_ref(&self.0);
            lua.push_value(key)?;
-            protect_lua(lua.state, 2, 1, |state| ffi::lua_gettable(state, -2))?;
+            protect_lua!(lua.state, 2, 1, fn(state) ffi::lua_gettable(state, -2))?;

            lua.pop_value()
        };
@@ -119,13 +120,12 @@ impl<'lua> Table<'lua> {

        unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 5)?;
+            check_stack(lua.state, 4)?;

            lua.push_ref(&self.0);
            lua.push_value(key)?;
-            protect_lua(lua.state, 2, 1, |state| {
-                ffi::lua_gettable(state, -2) != ffi::LUA_TNIL
-            })
+            protect_lua!(lua.state, 2, 1, fn(state) ffi::lua_gettable(state, -2))?;
+            Ok(ffi::lua_isnil(lua.state, -1) == 0)
        }
    }

@@ -193,12 +193,12 @@ impl<'lua> Table<'lua> {

        unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 6)?;
+            check_stack(lua.state, 5)?;

            lua.push_ref(&self.0);
            lua.push_value(key)?;
            lua.push_value(value)?;
-            protect_lua(lua.state, 3, 0, |state| ffi::lua_rawset(state, -3))
+            protect_lua!(lua.state, 3, 0, fn(state) ffi::lua_rawset(state, -3))
        }
    }

@@ -236,7 +236,7 @@ impl<'lua> Table<'lua> {

            lua.push_ref(&self.0);
            lua.push_value(value)?;
-            protect_lua(lua.state, 2, 0, |state| {
+            protect_lua!(lua.state, 2, 0, |state| {
                for i in (idx..=size).rev() {
                    // table[i+1] = table[i]
                    ffi::lua_rawgeti(state, -2, i);
@@ -268,7 +268,7 @@ impl<'lua> Table<'lua> {
                    check_stack(lua.state, 4)?;

                    lua.push_ref(&self.0);
-                    protect_lua(lua.state, 1, 0, |state| {
+                    protect_lua!(lua.state, 1, 0, |state| {
                        for i in idx..size {
                            ffi::lua_rawgeti(state, -1, i + 1);
                            ffi::lua_rawseti(state, -2, i);
@@ -294,7 +294,7 @@ impl<'lua> Table<'lua> {
            check_stack(lua.state, 4)?;

            lua.push_ref(&self.0);
-            protect_lua(lua.state, 1, 0, |state| ffi::luaL_len(state, -1))
+            protect_lua!(lua.state, 1, 0, |state| ffi::luaL_len(state, -1))
        }
    }

@@ -348,6 +348,28 @@ impl<'lua> Table<'lua> {
        }
    }

+    /// Sets `readonly` attribute on the table.
+    ///
+    /// Requires `feature = "luau"`
+    #[cfg(feature = "luau")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn set_readonly(&self, enabled: bool) {
+        let lua = self.0.lua;
+        unsafe {
+            lua.ref_thread_exec(|refthr| ffi::lua_setreadonly(refthr, self.0.index, enabled as _));
+        }
+    }
+
+    /// Returns `readonly` attribute of the table.
+    ///
+    /// Requires `feature = "luau"`
+    #[cfg(feature = "luau")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn is_readonly(&self) -> bool {
+        let lua = self.0.lua;
+        unsafe { lua.ref_thread_exec(|refthr| ffi::lua_getreadonly(refthr, self.0.index) != 0) }
+    }
+
    /// Consume this table and return an iterator over the pairs of the table.
    ///
    /// This works like the Lua `pairs` function, but does not invoke the `__pairs` metamethod.
@@ -379,8 +401,8 @@ impl<'lua> Table<'lua> {
    /// # }
    /// ```
    ///
-    /// [`Result`]: type.Result.html
-    /// [Lua manual]: http://www.lua.org/manual/5.3/manual.html#pdf-next
+    /// [`Result`]: crate::Result
+    /// [Lua manual]: http://www.lua.org/manual/5.4/manual.html#pdf-next
    pub fn pairs<K: FromLua<'lua>, V: FromLua<'lua>>(self) -> TablePairs<'lua, K, V> {
        TablePairs {
            table: self.0,
@@ -428,8 +450,8 @@ impl<'lua> Table<'lua> {
    /// ```
    ///
    /// [`pairs`]: #method.pairs
-    /// [`Result`]: type.Result.html
-    /// [Lua manual]: http://www.lua.org/manual/5.3/manual.html#pdf-next
+    /// [`Result`]: crate::Result
+    /// [Lua manual]: http://www.lua.org/manual/5.4/manual.html#pdf-next
    pub fn sequence_values<V: FromLua<'lua>>(self) -> TableSequence<'lua, V> {
        TableSequence {
            table: self.0,
@@ -455,7 +477,7 @@ impl<'lua> Table<'lua> {
        }
    }

-    #[cfg(any(feature = "async", feature = "serialize"))]
+    #[cfg(any(feature = "serialize"))]
    pub(crate) fn raw_sequence_values_by_len<V: FromLua<'lua>>(
        self,
        len: Option<Integer>,
@@ -502,6 +524,25 @@ impl<'lua> AsRef<Table<'lua>> for Table<'lua> {

 /// An extension trait for `Table`s that provides a variety of convenient functionality.
 pub trait TableExt<'lua> {
+    /// Calls the table as function assuming it has `__call` metamethod.
+    ///
+    /// The metamethod is called with the table as its first argument, followed by the passed arguments.
+    fn call<A, R>(&self, args: A) -> Result<R>
+    where
+        A: ToLuaMulti<'lua>,
+        R: FromLuaMulti<'lua>;
+
+    /// Asynchronously calls the table as function assuming it has `__call` metamethod.
+    ///
+    /// The metamethod is called with the table as its first argument, followed by the passed arguments.
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    where
+        'lua: 'fut,
+        A: ToLuaMulti<'lua>,
+        R: FromLuaMulti<'lua> + 'fut;
+
    /// Gets the function associated to `key` from the table and executes it,
    /// passing the table itself along with `args` as function arguments.
    ///
@@ -564,6 +605,25 @@ pub trait TableExt<'lua> {
 }

 impl<'lua> TableExt<'lua> for Table<'lua> {
+    fn call<A, R>(&self, args: A) -> Result<R>
+    where
+        A: ToLuaMulti<'lua>,
+        R: FromLuaMulti<'lua>,
+    {
+        // Convert table to a function and call via pcall that respects the `__call` metamethod.
+        Function(self.0.clone()).call(args)
+    }
+
+    #[cfg(feature = "async")]
+    fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
+    where
+        'lua: 'fut,
+        A: ToLuaMulti<'lua>,
+        R: FromLuaMulti<'lua> + 'fut,
+    {
+        Function(self.0.clone()).call_async(args)
+    }
+
    fn call_method<K, A, R>(&self, key: K, args: A) -> Result<R>
    where
        K: ToLua<'lua>,
@@ -623,22 +683,42 @@ impl<'lua> Serialize for Table<'lua> {
    where
        S: Serializer,
    {
-        let len = self.raw_len() as usize;
-        if len > 0 || self.is_array() {
-            let mut seq = serializer.serialize_seq(Some(len))?;
-            for v in self.clone().raw_sequence_values_by_len::<Value>(None) {
-                let v = v.map_err(serde::ser::Error::custom)?;
-                seq.serialize_element(&v)?;
-            }
-            return seq.end();
+        thread_local! {
+            static VISITED: RefCell<FxHashSet<*const c_void>> = RefCell::new(FxHashSet::default());
        }

-        let mut map = serializer.serialize_map(None)?;
-        for kv in self.clone().pairs::<Value, Value>() {
-            let (k, v) = kv.map_err(serde::ser::Error::custom)?;
-            map.serialize_entry(&k, &v)?;
-        }
-        map.end()
+        let lua = self.0.lua;
+        let ptr = unsafe { lua.ref_thread_exec(|refthr| ffi::lua_topointer(refthr, self.0.index)) };
+        let res = VISITED.with(|visited| {
+            {
+                let mut visited = visited.borrow_mut();
+                if visited.contains(&ptr) {
+                    return Err(ser::Error::custom("recursive table detected"));
+                }
+                visited.insert(ptr);
+            }
+
+            let len = self.raw_len() as usize;
+            if len > 0 || self.is_array() {
+                let mut seq = serializer.serialize_seq(Some(len))?;
+                for v in self.clone().raw_sequence_values_by_len::<Value>(None) {
+                    let v = v.map_err(serde::ser::Error::custom)?;
+                    seq.serialize_element(&v)?;
+                }
+                return seq.end();
+            }
+
+            let mut map = serializer.serialize_map(None)?;
+            for kv in self.clone().pairs::<Value, Value>() {
+                let (k, v) = kv.map_err(serde::ser::Error::custom)?;
+                map.serialize_entry(&k, &v)?;
+            }
+            map.end()
+        });
+        VISITED.with(|visited| {
+            visited.borrow_mut().remove(&ptr);
+        });
+        res
    }
 }

@@ -646,7 +726,7 @@ impl<'lua> Serialize for Table<'lua> {
 ///
 /// This struct is created by the [`Table::pairs`] method.
 ///
-/// [`Table::pairs`]: struct.Table.html#method.pairs
+/// [`Table::pairs`]: crate::Table::pairs
 pub struct TablePairs<'lua, K, V> {
    table: LuaRef<'lua>,
    key: Option<Value<'lua>>,
@@ -671,7 +751,7 @@ where
                lua.push_ref(&self.table);
                lua.push_value(prev_key)?;

-                let next = protect_lua(lua.state, 2, ffi::LUA_MULTRET, |state| {
+                let next = protect_lua!(lua.state, 2, ffi::LUA_MULTRET, |state| {
                    ffi::lua_next(state, -2)
                })?;
                if next != 0 {
@@ -705,7 +785,7 @@ where
 ///
 /// This struct is created by the [`Table::sequence_values`] method.
 ///
-/// [`Table::sequence_values`]: struct.Table.html#method.sequence_values
+/// [`Table::sequence_values`]: crate::Table::sequence_values
 pub struct TableSequence<'lua, V> {
    table: LuaRef<'lua>,
    index: Option<Integer>,
@@ -732,7 +812,7 @@ where
                let res = if self.raw {
                    ffi::lua_rawgeti(lua.state, -1, index)
                } else {
-                    protect_lua(lua.state, 1, 1, |state| ffi::lua_geti(state, -1, index))?
+                    protect_lua!(lua.state, 1, 1, |state| ffi::lua_geti(state, -1, index))?
                };
                match res {
                    ffi::LUA_TNIL if index > self.len.unwrap_or(0) => Ok(None),
@@ -4,24 +4,26 @@ use std::os::raw::c_int;
 use crate::error::{Error, Result};
 use crate::ffi;
 use crate::types::LuaRef;
-use crate::util::{assert_stack, check_stack, error_traceback, pop_error, protect_lua, StackGuard};
-use crate::value::{FromLuaMulti, MultiValue, ToLuaMulti};
+use crate::util::{check_stack, error_traceback, pop_error, StackGuard};
+use crate::value::{FromLuaMulti, ToLuaMulti};

-#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored"), doc))]
+#[cfg(any(
+    feature = "lua54",
+    all(feature = "luajit", feature = "vendored"),
+    feature = "luau",
+))]
 use crate::function::Function;

 #[cfg(feature = "async")]
 use {
    crate::{
-        lua::{ASYNC_POLL_PENDING, WAKER_REGISTRY_KEY},
-        util::get_gc_userdata,
-        value::Value,
+        lua::{Lua, ASYNC_POLL_PENDING},
+        value::{MultiValue, Value},
    },
    futures_core::{future::Future, stream::Stream},
    std::{
        cell::RefCell,
        marker::PhantomData,
-        mem,
        os::raw::c_void,
        pin::Pin,
        task::{Context, Poll, Waker},
@@ -35,7 +37,7 @@ pub enum ThreadStatus {
    ///
    /// If a thread is in this state, it can be resumed by calling [`Thread::resume`].
    ///
-    /// [`Thread::resume`]: struct.Thread.html#method.resume
+    /// [`Thread::resume`]: crate::Thread::resume
    Resumable,
    /// Either the thread has finished executing, or the thread is currently running.
    Unresumable,
@@ -51,8 +53,8 @@ pub struct Thread<'lua>(pub(crate) LuaRef<'lua>);
 ///
 /// Requires `feature = "async"`
 ///
-/// [`Future`]: ../futures_core/future/trait.Future.html
-/// [`Stream`]: ../futures_core/stream/trait.Stream.html
+/// [`Future`]: futures_core::future::Future
+/// [`Stream`]: futures_core::stream::Stream
 #[cfg(feature = "async")]
 #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
 #[derive(Debug)]
@@ -60,6 +62,7 @@ pub struct AsyncThread<'lua, R> {
    thread: Thread<'lua>,
    args0: RefCell<Option<Result<MultiValue<'lua>>>>,
    ret: PhantomData<R>,
+    recycle: bool,
 }

 impl<'lua> Thread<'lua> {
@@ -110,15 +113,14 @@ impl<'lua> Thread<'lua> {
        R: FromLuaMulti<'lua>,
    {
        let lua = self.0.lua;
-        let args = args.to_lua_multi(lua)?;
+        let mut args = args.to_lua_multi(lua)?;
        let nargs = args.len() as c_int;
        let results = unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, cmp::min(nargs + 1, 3))?;
+            check_stack(lua.state, cmp::max(nargs + 1, 3))?;

-            lua.push_ref(&self.0);
-            let thread_state = ffi::lua_tothread(lua.state, -1);
-            ffi::lua_pop(lua.state, 1);
+            let thread_state =
+                lua.ref_thread_exec(|ref_thread| ffi::lua_tothread(ref_thread, self.0.index));

            let status = ffi::lua_status(thread_state);
            if status != ffi::LUA_YIELD && ffi::lua_gettop(thread_state) == 0 {
@@ -126,7 +128,7 @@ impl<'lua> Thread<'lua> {
            }

            check_stack(thread_state, nargs)?;
-            for arg in args {
+            for arg in args.drain_all() {
                lua.push_value(arg)?;
            }
            ffi::lua_xmove(lua.state, thread_state, nargs);
@@ -135,11 +137,11 @@ impl<'lua> Thread<'lua> {

            let ret = ffi::lua_resume(thread_state, lua.state, nargs, &mut nresults as *mut c_int);
            if ret != ffi::LUA_OK && ret != ffi::LUA_YIELD {
-                protect_lua(lua.state, 0, 0, |_| error_traceback(thread_state))?;
+                protect_lua!(lua.state, 0, 0, |_| error_traceback(thread_state))?;
                return Err(pop_error(thread_state, ret));
            }

-            let mut results = MultiValue::new();
+            let mut results = args; // Reuse MultiValue container
            check_stack(lua.state, nresults + 2)?; // 2 is extra for `lua.pop_value()` below
            ffi::lua_xmove(thread_state, lua.state, nresults);

@@ -155,12 +157,8 @@ impl<'lua> Thread<'lua> {
    pub fn status(&self) -> ThreadStatus {
        let lua = self.0.lua;
        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 1);
-
-            lua.push_ref(&self.0);
-            let thread_state = ffi::lua_tothread(lua.state, -1);
-            ffi::lua_pop(lua.state, 1);
+            let thread_state =
+                lua.ref_thread_exec(|ref_thread| ffi::lua_tothread(ref_thread, self.0.index));

            let status = ffi::lua_status(thread_state);
            if status != ffi::LUA_OK && status != ffi::LUA_YIELD {
@@ -179,16 +177,20 @@ impl<'lua> Thread<'lua> {
    /// Returns a error in case of either the original error that stopped the thread or errors
    /// in closing methods.
    ///
-    /// In [LuaJIT]: resets to the initial state of a newly created Lua thread.
+    /// In [LuaJIT] and Luau: resets to the initial state of a newly created Lua thread.
    /// Lua threads in arbitrary states (like yielded or errored) can be reset properly.
    ///
    /// Sets a Lua function for the thread afterwards.
    ///
-    /// Requires `feature = "lua54"` OR `feature = "luajit,vendored"`
+    /// Requires `feature = "lua54"` OR `feature = "luajit,vendored"` OR `feature = "luau"`
    ///
    /// [Lua 5.4]: https://www.lua.org/manual/5.4/manual.html#lua_resetthread
    /// [LuaJIT]: https://github.com/openresty/luajit2#lua_resetthread
-    #[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored"), doc))]
+    #[cfg(any(
+        feature = "lua54",
+        all(feature = "luajit", feature = "vendored"),
+        feature = "luau",
+    ))]
    pub fn reset(&self, func: Function<'lua>) -> Result<()> {
        let lua = self.0.lua;
        unsafe {
@@ -198,10 +200,16 @@ impl<'lua> Thread<'lua> {
            lua.push_ref(&self.0);
            let thread_state = ffi::lua_tothread(lua.state, -1);

-            let ret = ffi::lua_resetthread(lua.state, thread_state);
-            if ret != ffi::LUA_OK {
-                return Err(pop_error(thread_state, ret));
+            #[cfg(feature = "lua54")]
+            let status = ffi::lua_resetthread(thread_state);
+            #[cfg(feature = "lua54")]
+            if status != ffi::LUA_OK {
+                return Err(pop_error(thread_state, status));
            }
+            #[cfg(all(feature = "luajit", feature = "vendored"))]
+            ffi::lua_resetthread(lua.state, thread_state);
+            #[cfg(feature = "luau")]
+            ffi::lua_resetthread(thread_state);

            lua.push_ref(&func.0);
            ffi::lua_xmove(lua.state, thread_state, 1);
@@ -210,10 +218,10 @@ impl<'lua> Thread<'lua> {
        }
    }

-    /// Converts Thread to an AsyncThread which implements Future and Stream traits.
+    /// Converts Thread to an AsyncThread which implements [`Future`] and [`Stream`] traits.
    ///
    /// `args` are passed as arguments to the thread function for first call.
-    /// The object call `resume()` while polling and also allows to run rust futures
+    /// The object calls [`resume()`] while polling and also allows to run rust futures
    /// to completion using an executor.
    ///
    /// Using AsyncThread as a Stream allows to iterate through `coroutine.yield()`
@@ -222,6 +230,10 @@ impl<'lua> Thread<'lua> {
    ///
    /// Requires `feature = "async"`
    ///
+    /// [`Future`]: futures_core::future::Future
+    /// [`Stream`]: futures_core::stream::Stream
+    /// [`resume()`]: https://www.lua.org/manual/5.4/manual.html#lua_resume
+    ///
    /// # Examples
    ///
    /// ```
@@ -263,6 +275,7 @@ impl<'lua> Thread<'lua> {
            thread: self,
            args0: RefCell::new(Some(args)),
            ret: PhantomData,
+            recycle: false,
        }
    }
 }
@@ -273,6 +286,26 @@ impl<'lua> PartialEq for Thread<'lua> {
    }
 }

+#[cfg(feature = "async")]
+impl<'lua, R> AsyncThread<'lua, R> {
+    #[inline]
+    pub(crate) fn set_recyclable(&mut self, recyclable: bool) {
+        self.recycle = recyclable;
+    }
+}
+
+#[cfg(feature = "async")]
+#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
+impl<'lua, R> Drop for AsyncThread<'lua, R> {
+    fn drop(&mut self) {
+        if self.recycle {
+            unsafe {
+                self.thread.0.lua.recycle_thread(&mut self.thread);
+            }
+        }
+    }
+}
+
 #[cfg(feature = "async")]
 impl<'lua, R> Stream for AsyncThread<'lua, R>
 where
@@ -288,7 +321,7 @@ where
            _ => return Poll::Ready(None),
        };

-        let _wg = WakerGuard::new(lua.state, cx.waker().clone());
+        let _wg = WakerGuard::new(lua, cx.waker().clone());
        let ret: MultiValue = if let Some(args) = self.args0.borrow_mut().take() {
            self.thread.resume(args?)?
        } else {
@@ -319,7 +352,7 @@ where
            _ => return Poll::Ready(Err(Error::CoroutineInactive)),
        };

-        let _wg = WakerGuard::new(lua.state, cx.waker().clone());
+        let _wg = WakerGuard::new(lua, cx.waker().clone());
        let ret: MultiValue = if let Some(args) = self.args0.borrow_mut().take() {
            self.thread.resume(args?)?
        } else {
@@ -341,9 +374,10 @@ where
 }

 #[cfg(feature = "async")]
+#[inline(always)]
 fn is_poll_pending(val: &MultiValue) -> bool {
    match val.iter().enumerate().last() {
-        Some((1, Value::LightUserData(ud))) => {
+        Some((0, Value::LightUserData(ud))) => {
            ud.0 == &ASYNC_POLL_PENDING as *const u8 as *mut c_void
        }
        _ => false,
@@ -351,37 +385,27 @@ fn is_poll_pending(val: &MultiValue) -> bool {
 }

 #[cfg(feature = "async")]
-struct WakerGuard(*mut ffi::lua_State, Option<Waker>);
+struct WakerGuard<'lua> {
+    lua: &'lua Lua,
+    prev: Option<Waker>,
+}

 #[cfg(feature = "async")]
-impl WakerGuard {
-    pub fn new(state: *mut ffi::lua_State, waker: Waker) -> Result<WakerGuard> {
+impl<'lua> WakerGuard<'lua> {
+    #[inline]
+    pub fn new(lua: &Lua, waker: Waker) -> Result<WakerGuard> {
        unsafe {
-            let _sg = StackGuard::new(state);
-            check_stack(state, 3)?;
-
-            let waker_key = &WAKER_REGISTRY_KEY as *const u8 as *const c_void;
-            ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, waker_key);
-            let waker_slot = get_gc_userdata::<Option<Waker>>(state, -1).as_mut();
-            let old = mlua_expect!(waker_slot, "Waker is destroyed").replace(waker);
-
-            Ok(WakerGuard(state, old))
+            let prev = lua.set_waker(Some(waker));
+            Ok(WakerGuard { lua, prev })
        }
    }
 }

 #[cfg(feature = "async")]
-impl Drop for WakerGuard {
+impl<'lua> Drop for WakerGuard<'lua> {
    fn drop(&mut self) {
-        let state = self.0;
        unsafe {
-            let _sg = StackGuard::new(state);
-            assert_stack(state, 3);
-
-            let waker_key = &WAKER_REGISTRY_KEY as *const u8 as *const c_void;
-            ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, waker_key);
-            let waker_slot = get_gc_userdata::<Option<Waker>>(state, -1).as_mut();
-            mem::swap(mlua_expect!(waker_slot, "Waker is destroyed"), &mut self.1);
+            self.lua.set_waker(self.prev.take());
        }
    }
 }
@@ -1,14 +1,17 @@
-use std::cell::RefCell;
 use std::hash::{Hash, Hasher};
 use std::os::raw::{c_int, c_void};
 use std::sync::{Arc, Mutex};
 use std::{fmt, mem, ptr};

+#[cfg(feature = "lua54")]
+use std::ffi::CStr;
+
 #[cfg(feature = "async")]
 use futures_core::future::LocalBoxFuture;

 use crate::error::Result;
 use crate::ffi;
+#[cfg(not(feature = "luau"))]
 use crate::hook::Debug;
 use crate::lua::Lua;
 use crate::util::{assert_stack, StackGuard};
@@ -46,8 +49,17 @@ pub(crate) struct AsyncPollUpvalue<'lua> {
    pub(crate) lua: Lua,
    pub(crate) fut: LocalBoxFuture<'lua, Result<MultiValue<'lua>>>,
 }
+#[cfg(all(feature = "send", not(feature = "luau")))]
+pub(crate) type HookCallback = Arc<Mutex<dyn FnMut(&Lua, Debug) -> Result<()> + Send>>;

-pub(crate) type HookCallback = Arc<RefCell<dyn FnMut(&Lua, Debug) -> Result<()>>>;
+#[cfg(all(not(feature = "send"), not(feature = "luau")))]
+pub(crate) type HookCallback = Arc<Mutex<dyn FnMut(&Lua, Debug) -> Result<()>>>;
+
+#[cfg(all(feature = "send", feature = "lua54"))]
+pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &CStr, bool) -> Result<()> + Send>;
+
+#[cfg(all(not(feature = "send"), feature = "lua54"))]
+pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &CStr, bool) -> Result<()>>;

 #[cfg(feature = "send")]
 pub trait MaybeSend: Send {}
@@ -59,21 +71,25 @@ pub trait MaybeSend {}
 #[cfg(not(feature = "send"))]
 impl<T> MaybeSend for T {}

+pub(crate) struct DestructedUserdataMT;
+
 /// An auto generated key into the Lua registry.
 ///
 /// This is a handle to a value stored inside the Lua registry. It is not automatically
 /// garbage collected on Drop, but it can be removed with [`Lua::remove_registry_value`],
 /// and instances not manually removed can be garbage collected with [`Lua::expire_registry_values`].
 ///
-/// Be warned, If you place this into Lua via a `UserData` type or a rust callback, it is *very
+/// Be warned, If you place this into Lua via a [`UserData`] type or a rust callback, it is *very
 /// easy* to accidentally cause reference cycles that the Lua garbage collector cannot resolve.
-/// Instead of placing a `RegistryKey` into a `UserData` type, prefer instead to use
-/// [`UserData::set_user_value`] / [`UserData::get_user_value`].
+/// Instead of placing a [`RegistryKey`] into a [`UserData`] type, prefer instead to use
+/// [`AnyUserData::set_user_value`] / [`AnyUserData::get_user_value`].
 ///
-/// [`Lua::remove_registry_value`]: struct.Lua.html#method.remove_registry_value
-/// [`Lua::expire_registry_values`]: struct.Lua.html#method.expire_registry_values
-/// [`UserData::set_user_value`]: struct.UserData.html#method.set_user_value
-/// [`UserData::get_user_value`]: struct.UserData.html#method.get_user_value
+/// [`UserData`]: crate::UserData
+/// [`RegistryKey`]: crate::RegistryKey
+/// [`Lua::remove_registry_value`]: crate::Lua::remove_registry_value
+/// [`Lua::expire_registry_values`]: crate::Lua::expire_registry_values
+/// [`AnyUserData::set_user_value`]: crate::AnyUserData::set_user_value
+/// [`AnyUserData::get_user_value`]: crate::AnyUserData::get_user_value
 pub struct RegistryKey {
    pub(crate) registry_id: c_int,
    pub(crate) unref_list: Arc<Mutex<Option<Vec<c_int>>>>,
@@ -139,7 +155,9 @@ impl<'lua> Clone for LuaRef<'lua> {

 impl<'lua> Drop for LuaRef<'lua> {
    fn drop(&mut self) {
-        self.lua.drop_ref(self)
+        if self.index > 0 {
+            self.lua.drop_ref(self);
+        }
    }
 }

@@ -3,6 +3,7 @@ use std::cell::{Ref, RefCell, RefMut};
 use std::fmt;
 use std::hash::{Hash, Hasher};
 use std::ops::{Deref, DerefMut};
+use std::os::raw::{c_char, c_int};
 use std::string::String as StdString;

 #[cfg(feature = "async")]
@@ -11,7 +12,6 @@ use std::future::Future;
 #[cfg(feature = "serialize")]
 use {
    serde::ser::{self, Serialize, Serializer},
-    std::os::raw::c_void,
    std::result::Result as StdResult,
 };

@@ -21,23 +21,21 @@ use crate::function::Function;
 use crate::lua::Lua;
 use crate::table::{Table, TablePairs};
 use crate::types::{Callback, LuaRef, MaybeSend};
-use crate::util::{
-    check_stack, get_destructed_userdata_metatable, get_userdata, push_string, StackGuard,
-};
+use crate::util::{check_stack, get_userdata, take_userdata, StackGuard};
 use crate::value::{FromLua, FromLuaMulti, ToLua, ToLuaMulti};

-#[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-use crate::value::Value;
-
 #[cfg(feature = "async")]
 use crate::types::AsyncCallback;

+#[cfg(feature = "lua54")]
+pub(crate) const USER_VALUE_MAXSLOT: usize = 8;
+
 /// Kinds of metamethods that can be overridden.
 ///
 /// Currently, this mechanism does not allow overriding the `__gc` metamethod, since there is
 /// generally no need to do so: [`UserData`] implementors can instead just implement `Drop`.
 ///
-/// [`UserData`]: trait.UserData.html
+/// [`UserData`]: crate::UserData
 #[derive(Debug, Clone)]
 pub enum MetaMethod {
    /// The `+` operator.
@@ -56,29 +54,29 @@ pub enum MetaMethod {
    Unm,
    /// The floor division (//) operator.
    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    IDiv,
    /// The bitwise AND (&) operator.
    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    BAnd,
    /// The bitwise OR (|) operator.
    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    BOr,
    /// The bitwise XOR (binary ~) operator.
    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    BXor,
    /// The bitwise NOT (unary ~) operator.
    /// Requires `feature = "lua54/lua53"`
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    BNot,
    /// The bitwise left shift (<<) operator.
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    Shl,
    /// The bitwise right shift (>>) operator.
-    #[cfg(any(feature = "lua54", feature = "lua53", doc))]
+    #[cfg(any(feature = "lua54", feature = "lua53"))]
    Shr,
    /// The string concatenation operator `..`.
    Concat,
@@ -105,7 +103,12 @@ pub enum MetaMethod {
    /// This is not an operator, but it will be called by the built-in `pairs` function.
    ///
    /// Requires `feature = "lua54/lua53/lua52"`
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", doc))]
+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luajit52",
+    ))]
    Pairs,
    /// The `__ipairs` metamethod.
    ///
@@ -114,7 +117,7 @@ pub enum MetaMethod {
    /// Requires `feature = "lua52"`
    ///
    /// [`ipairs`]: https://www.lua.org/manual/5.2/manual.html#pdf-ipairs
-    #[cfg(any(feature = "lua52", doc))]
+    #[cfg(any(feature = "lua52", feature = "luajit52", doc))]
    IPairs,
    /// The `__close` metamethod.
    ///
@@ -126,7 +129,7 @@ pub enum MetaMethod {
    /// Requires `feature = "lua54"`
    ///
    /// [lua_doc]: https://www.lua.org/manual/5.4/manual.html#3.3.8
-    #[cfg(any(feature = "lua54", doc))]
+    #[cfg(any(feature = "lua54"))]
    Close,
    /// A custom metamethod.
    ///
@@ -191,9 +194,14 @@ impl MetaMethod {
            MetaMethod::Call => "__call",
            MetaMethod::ToString => "__tostring",

-            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            #[cfg(any(
+                feature = "lua54",
+                feature = "lua53",
+                feature = "lua52",
+                feature = "luajit52"
+            ))]
            MetaMethod::Pairs => "__pairs",
-            #[cfg(feature = "lua52")]
+            #[cfg(any(feature = "lua52", feature = "luajit52"))]
            MetaMethod::IPairs => "__ipairs",

            #[cfg(feature = "lua54")]
@@ -253,9 +261,14 @@ impl From<StdString> for MetaMethod {
            "__call" => MetaMethod::Call,
            "__tostring" => MetaMethod::ToString,

-            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            #[cfg(any(
+                feature = "lua54",
+                feature = "lua53",
+                feature = "lua52",
+                feature = "luajit52"
+            ))]
            "__pairs" => MetaMethod::Pairs,
-            #[cfg(feature = "lua52")]
+            #[cfg(any(feature = "lua52", feature = "luajit52"))]
            "__ipairs" => MetaMethod::IPairs,

            #[cfg(feature = "lua54")]
@@ -274,7 +287,7 @@ impl From<&str> for MetaMethod {

 /// Method registry for [`UserData`] implementors.
 ///
-/// [`UserData`]: trait.UserData.html
+/// [`UserData`]: crate::UserData
 pub trait UserDataMethods<'lua, T: UserData> {
    /// Add a regular method which accepts a `&T` as the first parameter.
    ///
@@ -328,7 +341,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
    ///
    /// Prefer to use [`add_method`] or [`add_method_mut`] as they are easier to use.
    ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
    /// [`add_method`]: #method.add_method
    /// [`add_method_mut`]: #method.add_method_mut
    fn add_function<S, A, R, F>(&mut self, name: &S, function: F)
@@ -398,6 +411,25 @@ pub trait UserDataMethods<'lua, T: UserData> {
        R: ToLuaMulti<'lua>,
        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>;

+    /// Add an async metamethod which accepts a `T` as the first parameter and returns Future.
+    /// The passed `T` is cloned from the original value.
+    ///
+    /// This is an async version of [`add_meta_method`].
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// [`add_meta_method`]: #method.add_meta_method
+    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    fn add_async_meta_method<S, A, R, M, MR>(&mut self, name: S, method: M)
+    where
+        T: Clone,
+        S: Into<MetaMethod>,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
+        MR: 'lua + Future<Output = Result<R>>;
+
    /// Add a metamethod which accepts generic arguments.
    ///
    /// Metamethods for binary operators can be triggered if either the left or right argument to
@@ -422,6 +454,23 @@ pub trait UserDataMethods<'lua, T: UserData> {
        R: ToLuaMulti<'lua>,
        F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>;

+    /// Add a metamethod which accepts generic arguments and returns Future.
+    ///
+    /// This is an async version of [`add_meta_function`].
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// [`add_meta_function`]: #method.add_meta_function
+    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    fn add_async_meta_function<S, A, R, F, FR>(&mut self, name: S, function: F)
+    where
+        S: Into<MetaMethod>,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
+        FR: 'lua + Future<Output = Result<R>>;
+
    //
    // Below are internal methods used in generated code
    //
@@ -435,11 +484,20 @@ pub trait UserDataMethods<'lua, T: UserData> {

    #[doc(hidden)]
    fn add_meta_callback(&mut self, _meta: MetaMethod, _callback: Callback<'lua, 'static>) {}
+
+    #[doc(hidden)]
+    #[cfg(feature = "async")]
+    fn add_async_meta_callback(
+        &mut self,
+        _meta: MetaMethod,
+        _callback: AsyncCallback<'lua, 'static>,
+    ) {
+    }
 }

 /// Field registry for [`UserData`] implementors.
 ///
-/// [`UserData`]: trait.UserData.html
+/// [`UserData`]: crate::UserData
 pub trait UserDataFields<'lua, T: UserData> {
    /// Add a regular field getter as a method which accepts a `&T` as the parameter.
    ///
@@ -472,7 +530,7 @@ pub trait UserDataFields<'lua, T: UserData> {
    ///
    /// Prefer to use [`add_field_method_get`] as it is easier to use.
    ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
    /// [`add_field_method_get`]: #method.add_field_method_get
    fn add_field_function_get<S, R, F>(&mut self, name: &S, function: F)
    where
@@ -485,7 +543,7 @@ pub trait UserDataFields<'lua, T: UserData> {
    ///
    /// Prefer to use [`add_field_method_set`] as it is easier to use.
    ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
    /// [`add_field_method_set`]: #method.add_field_method_set
    fn add_field_function_set<S, A, F>(&mut self, name: &S, function: F)
    where
@@ -520,8 +578,10 @@ pub trait UserDataFields<'lua, T: UserData> {

 /// Trait for custom userdata types.
 ///
-/// By implementing this trait, a struct becomes eligible for use inside Lua code. Implementations
-/// of [`ToLua`] and [`FromLua`] are automatically provided.
+/// By implementing this trait, a struct becomes eligible for use inside Lua code.
+/// Implementation of [`ToLua`] is automatically provided, [`FromLua`] is implemented
+/// only for `T: UserData + Clone`.
+///
 ///
 /// # Examples
 ///
@@ -579,10 +639,10 @@ pub trait UserDataFields<'lua, T: UserData> {
 /// # }
 /// ```
 ///
-/// [`ToLua`]: trait.ToLua.html
-/// [`FromLua`]: trait.FromLua.html
-/// [`UserDataFields`]: trait.UserDataFields.html
-/// [`UserDataMethods`]: trait.UserDataMethods.html
+/// [`ToLua`]: crate::ToLua
+/// [`FromLua`]: crate::FromLua
+/// [`UserDataFields`]: crate::UserDataFields
+/// [`UserDataMethods`]: crate::UserDataMethods
 pub trait UserData: Sized {
    /// Adds custom fields specific to this userdata.
    fn add_fields<'lua, F: UserDataFields<'lua, Self>>(_fields: &mut F) {}
@@ -595,11 +655,13 @@ pub trait UserData: Sized {
 pub(crate) struct UserDataCell<T>(RefCell<UserDataWrapped<T>>);

 impl<T> UserDataCell<T> {
+    #[inline]
    pub(crate) fn new(data: T) -> Self {
        UserDataCell(RefCell::new(UserDataWrapped::new(data)))
    }

    #[cfg(feature = "serialize")]
+    #[inline]
    pub(crate) fn new_ser(data: T) -> Self
    where
        T: 'static + Serialize,
@@ -608,7 +670,8 @@ impl<T> UserDataCell<T> {
    }

    // Immutably borrows the wrapped value.
-    fn try_borrow(&self) -> Result<Ref<T>> {
+    #[inline]
+    pub(crate) fn try_borrow(&self) -> Result<Ref<T>> {
        self.0
            .try_borrow()
            .map(|r| Ref::map(r, |r| r.deref()))
@@ -616,40 +679,48 @@ impl<T> UserDataCell<T> {
    }

    // Mutably borrows the wrapped value.
-    fn try_borrow_mut(&self) -> Result<RefMut<T>> {
+    #[inline]
+    pub(crate) fn try_borrow_mut(&self) -> Result<RefMut<T>> {
        self.0
            .try_borrow_mut()
            .map(|r| RefMut::map(r, |r| r.deref_mut()))
            .map_err(|_| Error::UserDataBorrowMutError)
    }
+
+    // Consumes this `UserDataCell`, returning the wrapped value.
+    #[inline]
+    fn into_inner(self) -> T {
+        self.0.into_inner().into_inner()
+    }
 }

 pub(crate) enum UserDataWrapped<T> {
-    Default(T),
+    Default(Box<T>),
    #[cfg(feature = "serialize")]
-    Serializable(*mut T, *const dyn erased_serde::Serialize),
+    Serializable(Box<dyn erased_serde::Serialize>),
 }

 impl<T> UserDataWrapped<T> {
+    #[inline]
    fn new(data: T) -> Self {
-        UserDataWrapped::Default(data)
+        UserDataWrapped::Default(Box::new(data))
    }

    #[cfg(feature = "serialize")]
+    #[inline]
    fn new_ser(data: T) -> Self
    where
        T: 'static + Serialize,
    {
-        let data_raw = Box::into_raw(Box::new(data));
-        UserDataWrapped::Serializable(data_raw, data_raw)
+        UserDataWrapped::Serializable(Box::new(data))
    }
-}

-#[cfg(feature = "serialize")]
-impl<T> Drop for UserDataWrapped<T> {
-    fn drop(&mut self) {
-        if let UserDataWrapped::Serializable(data, _) = *self {
-            drop(unsafe { Box::from_raw(data) });
+    #[inline]
+    fn into_inner(self) -> T {
+        match self {
+            Self::Default(data) => *data,
+            #[cfg(feature = "serialize")]
+            Self::Serializable(data) => unsafe { *Box::from_raw(Box::into_raw(data) as *mut T) },
        }
    }
 }
@@ -657,21 +728,27 @@ impl<T> Drop for UserDataWrapped<T> {
 impl<T> Deref for UserDataWrapped<T> {
    type Target = T;

+    #[inline]
    fn deref(&self) -> &Self::Target {
        match self {
            Self::Default(data) => data,
            #[cfg(feature = "serialize")]
-            Self::Serializable(data, _) => unsafe { &**data },
+            Self::Serializable(data) => unsafe {
+                &*(data.as_ref() as *const _ as *const Self::Target)
+            },
        }
    }
 }

 impl<T> DerefMut for UserDataWrapped<T> {
+    #[inline]
    fn deref_mut(&mut self) -> &mut Self::Target {
        match self {
            Self::Default(data) => data,
            #[cfg(feature = "serialize")]
-            Self::Serializable(data, _) => unsafe { &mut **data },
+            Self::Serializable(data) => unsafe {
+                &mut *(data.as_mut() as *mut _ as *mut Self::Target)
+            },
        }
    }
 }
@@ -702,9 +779,9 @@ impl Serialize for UserDataSerializeError {
 /// This API should only be used when necessary. Implementing [`UserData`] already allows defining
 /// methods which check the type and acquire a borrow behind the scenes.
 ///
-/// [`UserData`]: trait.UserData.html
-/// [`is`]: #method.is
-/// [`borrow`]: #method.borrow
+/// [`UserData`]: crate::UserData
+/// [`is`]: crate::AnyUserData::is
+/// [`borrow`]: crate::AnyUserData::borrow
 #[derive(Clone, Debug)]
 pub struct AnyUserData<'lua>(pub(crate) LuaRef<'lua>);

@@ -724,6 +801,7 @@ impl<'lua> AnyUserData<'lua> {
    ///
    /// Returns a `UserDataBorrowError` if the userdata is already mutably borrowed. Returns a
    /// `UserDataTypeMismatch` if the userdata is not of type `T`.
+    #[inline]
    pub fn borrow<T: 'static + UserData>(&self) -> Result<Ref<T>> {
        self.inspect(|cell| cell.try_borrow())
    }
@@ -734,61 +812,244 @@ impl<'lua> AnyUserData<'lua> {
    ///
    /// Returns a `UserDataBorrowMutError` if the userdata cannot be mutably borrowed.
    /// Returns a `UserDataTypeMismatch` if the userdata is not of type `T`.
+    #[inline]
    pub fn borrow_mut<T: 'static + UserData>(&self) -> Result<RefMut<T>> {
        self.inspect(|cell| cell.try_borrow_mut())
    }

+    /// Takes out the value of `UserData` and sets the special "destructed" metatable that prevents
+    /// any further operations with this userdata.
+    ///
+    /// All associated user values will be also cleared.
+    pub fn take<T: 'static + UserData>(&self) -> Result<T> {
+        let lua = self.0.lua;
+        unsafe {
+            let _sg = StackGuard::new(lua.state);
+            check_stack(lua.state, 3)?;
+
+            let type_id = lua.push_userdata_ref(&self.0)?;
+            match type_id {
+                Some(type_id) if type_id == TypeId::of::<T>() => {
+                    // Try to borrow userdata exclusively
+                    let _ = (*get_userdata::<UserDataCell<T>>(lua.state, -1)).try_borrow_mut()?;
+
+                    // Clear associated user values
+                    #[cfg(feature = "lua54")]
+                    for i in 1..=USER_VALUE_MAXSLOT {
+                        ffi::lua_pushnil(lua.state);
+                        ffi::lua_setiuservalue(lua.state, -2, i as c_int);
+                    }
+                    #[cfg(any(feature = "lua53", feature = "lua52", feature = "luau"))]
+                    {
+                        ffi::lua_pushnil(lua.state);
+                        ffi::lua_setuservalue(lua.state, -2);
+                    }
+                    #[cfg(any(feature = "lua51", feature = "luajit"))]
+                    protect_lua!(lua.state, 1, 1, fn(state) {
+                        ffi::lua_newtable(state);
+                        ffi::lua_setuservalue(state, -2);
+                    })?;
+
+                    Ok(take_userdata::<UserDataCell<T>>(lua.state).into_inner())
+                }
+                _ => Err(Error::UserDataTypeMismatch),
+            }
+        }
+    }
+
    /// Sets an associated value to this `AnyUserData`.
    ///
    /// The value may be any Lua value whatsoever, and can be retrieved with [`get_user_value`].
-    /// As Lua < 5.3 allows to store only tables, the value will be stored in a table at index 1.
+    ///
+    /// This is the same as calling [`set_nth_user_value`] with `n` set to 1.
    ///
    /// [`get_user_value`]: #method.get_user_value
+    /// [`set_nth_user_value`]: #method.set_nth_user_value
+    #[inline]
    pub fn set_user_value<V: ToLua<'lua>>(&self, v: V) -> Result<()> {
+        self.set_nth_user_value(1, v)
+    }
+
+    /// Returns an associated value set by [`set_user_value`].
+    ///
+    /// This is the same as calling [`get_nth_user_value`] with `n` set to 1.
+    ///
+    /// [`set_user_value`]: #method.set_user_value
+    /// [`get_nth_user_value`]: #method.get_nth_user_value
+    #[inline]
+    pub fn get_user_value<V: FromLua<'lua>>(&self) -> Result<V> {
+        self.get_nth_user_value(1)
+    }
+
+    /// Sets an associated `n`th value to this `AnyUserData`.
+    ///
+    /// The value may be any Lua value whatsoever, and can be retrieved with [`get_nth_user_value`].
+    /// `n` starts from 1 and can be up to 65535.
+    ///
+    /// This is supported for all Lua versions.
+    /// In Lua 5.4 first 7 elements are stored in a most efficient way.
+    /// For other Lua versions this functionality is provided using a wrapping table.
+    ///
+    /// [`get_nth_user_value`]: #method.get_nth_user_value
+    pub fn set_nth_user_value<V: ToLua<'lua>>(&self, n: usize, v: V) -> Result<()> {
+        if n < 1 || n > u16::MAX as usize {
+            return Err(Error::RuntimeError(
+                "user value index out of bounds".to_string(),
+            ));
+        }
+
        let lua = self.0.lua;
-        #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-        let v = {
-            // Lua <= 5.2 allows to store only a table. Then we will wrap the value.
-            let t = lua.create_table_with_capacity(1, 0)?;
-            t.raw_set(1, v)?;
-            Value::Table(t)
-        };
-        #[cfg(any(feature = "lua54", feature = "lua53"))]
-        let v = v.to_lua(lua)?;
        unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 3)?;
+            check_stack(lua.state, 5)?;

-            lua.push_userdata_ref(&self.0, false)?;
-            lua.push_value(v)?;
-            ffi::lua_setuservalue(lua.state, -2);
+            lua.push_userdata_ref(&self.0)?;
+            lua.push_value(v.to_lua(lua)?)?;
+
+            #[cfg(feature = "lua54")]
+            if n < USER_VALUE_MAXSLOT {
+                ffi::lua_setiuservalue(lua.state, -2, n as c_int);
+                return Ok(());
+            }
+
+            // Multiple (extra) user values are emulated by storing them in a table
+            protect_lua!(lua.state, 2, 0, |state| {
+                if getuservalue_table(lua.state, -2) != ffi::LUA_TTABLE {
+                    // Create a new table to use as uservalue
+                    ffi::lua_pop(lua.state, 1);
+                    ffi::lua_newtable(state);
+                    ffi::lua_pushvalue(state, -1);
+
+                    #[cfg(feature = "lua54")]
+                    ffi::lua_setiuservalue(lua.state, -4, USER_VALUE_MAXSLOT as c_int);
+                    #[cfg(not(feature = "lua54"))]
+                    ffi::lua_setuservalue(lua.state, -4);
+                }
+                ffi::lua_pushvalue(state, -2);
+                #[cfg(feature = "lua54")]
+                ffi::lua_rawseti(state, -2, (n - USER_VALUE_MAXSLOT + 1) as ffi::lua_Integer);
+                #[cfg(not(feature = "lua54"))]
+                ffi::lua_rawseti(state, -2, n as ffi::lua_Integer);
+            })?;

            Ok(())
        }
    }

-    /// Returns an associated value set by [`set_user_value`].
+    /// Returns an associated `n`th value set by [`set_nth_user_value`].
    ///
-    /// For Lua < 5.3 the value will be automatically extracted from the table wrapper from index 1.
+    /// `n` starts from 1 and can be up to 65535.
    ///
-    /// [`set_user_value`]: #method.set_user_value
-    pub fn get_user_value<V: FromLua<'lua>>(&self) -> Result<V> {
-        let lua = self.0.lua;
-        let res = unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 3)?;
+    /// This is supported for all Lua versions.
+    /// In Lua 5.4 first 7 elements are stored in a most efficient way.
+    /// For other Lua versions this functionality is provided using a wrapping table.
+    ///
+    /// [`set_nth_user_value`]: #method.set_nth_user_value
+    pub fn get_nth_user_value<V: FromLua<'lua>>(&self, n: usize) -> Result<V> {
+        if n < 1 || n > u16::MAX as usize {
+            return Err(Error::RuntimeError(
+                "user value index out of bounds".to_string(),
+            ));
+        }

-            lua.push_userdata_ref(&self.0, false)?;
-            ffi::lua_getuservalue(lua.state, -1);
-            lua.pop_value()
-        };
-        #[cfg(any(feature = "lua52", feature = "lua51", feature = "luajit"))]
-        return match <Option<Table>>::from_lua(res, lua)? {
-            Some(t) => t.get(1),
-            None => V::from_lua(Value::Nil, lua),
-        };
-        #[cfg(any(feature = "lua54", feature = "lua53"))]
-        V::from_lua(res, lua)
+        let lua = self.0.lua;
+        unsafe {
+            let _sg = StackGuard::new(lua.state);
+            check_stack(lua.state, 4)?;
+
+            lua.push_userdata_ref(&self.0)?;
+
+            #[cfg(feature = "lua54")]
+            if n < USER_VALUE_MAXSLOT {
+                ffi::lua_getiuservalue(lua.state, -1, n as c_int);
+                return V::from_lua(lua.pop_value(), lua);
+            }
+
+            // Multiple (extra) user values are emulated by storing them in a table
+            protect_lua!(lua.state, 1, 1, |state| {
+                if getuservalue_table(lua.state, -1) != ffi::LUA_TTABLE {
+                    ffi::lua_pushnil(lua.state);
+                    return;
+                }
+                #[cfg(feature = "lua54")]
+                ffi::lua_rawgeti(state, -1, (n - USER_VALUE_MAXSLOT + 1) as ffi::lua_Integer);
+                #[cfg(not(feature = "lua54"))]
+                ffi::lua_rawgeti(state, -1, n as ffi::lua_Integer);
+            })?;
+
+            V::from_lua(lua.pop_value(), lua)
+        }
+    }
+
+    /// Sets an associated value to this `AnyUserData` by name.
+    ///
+    /// The value can be retrieved with [`get_named_user_value`].
+    ///
+    /// [`get_named_user_value`]: #method.get_named_user_value
+    pub fn set_named_user_value<S, V>(&self, name: &S, v: V) -> Result<()>
+    where
+        S: AsRef<[u8]> + ?Sized,
+        V: ToLua<'lua>,
+    {
+        let lua = self.0.lua;
+        unsafe {
+            let _sg = StackGuard::new(lua.state);
+            check_stack(lua.state, 5)?;
+
+            lua.push_userdata_ref(&self.0)?;
+            lua.push_value(v.to_lua(lua)?)?;
+
+            // Multiple (extra) user values are emulated by storing them in a table
+            let name = name.as_ref();
+            protect_lua!(lua.state, 2, 0, |state| {
+                if getuservalue_table(lua.state, -2) != ffi::LUA_TTABLE {
+                    // Create a new table to use as uservalue
+                    ffi::lua_pop(lua.state, 1);
+                    ffi::lua_newtable(state);
+                    ffi::lua_pushvalue(state, -1);
+
+                    #[cfg(feature = "lua54")]
+                    ffi::lua_setiuservalue(lua.state, -4, USER_VALUE_MAXSLOT as c_int);
+                    #[cfg(not(feature = "lua54"))]
+                    ffi::lua_setuservalue(lua.state, -4);
+                }
+                ffi::lua_pushlstring(state, name.as_ptr() as *const c_char, name.len());
+                ffi::lua_pushvalue(state, -3);
+                ffi::lua_rawset(state, -3);
+            })?;
+
+            Ok(())
+        }
+    }
+
+    /// Returns an associated value by name set by [`set_named_user_value`].
+    ///
+    /// [`set_named_user_value`]: #method.set_named_user_value
+    pub fn get_named_user_value<S, V>(&self, name: &S) -> Result<V>
+    where
+        S: AsRef<[u8]> + ?Sized,
+        V: FromLua<'lua>,
+    {
+        let lua = self.0.lua;
+        unsafe {
+            let _sg = StackGuard::new(lua.state);
+            check_stack(lua.state, 4)?;
+
+            lua.push_userdata_ref(&self.0)?;
+
+            // Multiple (extra) user values are emulated by storing them in a table
+            let name = name.as_ref();
+            protect_lua!(lua.state, 1, 1, |state| {
+                if getuservalue_table(lua.state, -1) != ffi::LUA_TTABLE {
+                    ffi::lua_pushnil(lua.state);
+                    return;
+                }
+                ffi::lua_pushlstring(state, name.as_ptr() as *const c_char, name.len());
+                ffi::lua_rawget(state, -2);
+            })?;
+
+            V::from_lua(lua.pop_value(), lua)
+        }
    }

    /// Returns a metatable of this `UserData`.
@@ -798,7 +1059,7 @@ impl<'lua> AnyUserData<'lua> {
    ///
    /// For `T: UserData + 'static` returned metatable is shared among all instances of type `T`.
    ///
-    /// [`UserDataMetatable`]: struct.UserDataMetatable.html
+    /// [`UserDataMetatable`]: crate::UserDataMetatable
    pub fn get_metatable(&self) -> Result<UserDataMetatable<'lua>> {
        self.get_raw_metatable().map(UserDataMetatable)
    }
@@ -809,7 +1070,7 @@ impl<'lua> AnyUserData<'lua> {
            let _sg = StackGuard::new(lua.state);
            check_stack(lua.state, 3)?;

-            lua.push_userdata_ref(&self.0, false)?;
+            lua.push_userdata_ref(&self.0)?;
            ffi::lua_getmetatable(lua.state, -1); // Checked that non-empty on the previous call
            Ok(Table(lua.pop_ref()))
        }
@@ -836,25 +1097,6 @@ impl<'lua> AnyUserData<'lua> {
        Ok(false)
    }

-    pub(crate) fn type_id(&self) -> Result<TypeId> {
-        let lua = self.0.lua;
-        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 5)?;
-
-            // Push userdata with metatable
-            lua.push_userdata_ref(&self.0, true)?;
-
-            // Get the special `__mlua_type_id`
-            push_string(lua.state, "__mlua_type_id")?;
-            if ffi::lua_rawget(lua.state, -2) != ffi::LUA_TUSERDATA {
-                return Err(Error::UserDataTypeMismatch);
-            }
-
-            Ok(*(ffi::lua_touserdata(lua.state, -1) as *const TypeId))
-        }
-    }
-
    fn inspect<'a, T, R, F>(&'a self, func: F) -> Result<R>
    where
        T: 'static + UserData,
@@ -863,25 +1105,14 @@ impl<'lua> AnyUserData<'lua> {
        let lua = self.0.lua;
        unsafe {
            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 3)?;
+            check_stack(lua.state, 2)?;

-            lua.push_ref(&self.0);
-            if ffi::lua_getmetatable(lua.state, -1) == 0 {
-                return Err(Error::UserDataTypeMismatch);
-            }
-            lua.push_userdata_metatable::<T>()?;
-
-            if ffi::lua_rawequal(lua.state, -1, -2) == 0 {
-                // Maybe UserData destructed?
-                ffi::lua_pop(lua.state, 1);
-                get_destructed_userdata_metatable(lua.state);
-                if ffi::lua_rawequal(lua.state, -1, -2) == 1 {
-                    Err(Error::UserDataDestructed)
-                } else {
-                    Err(Error::UserDataTypeMismatch)
+            let type_id = lua.push_userdata_ref(&self.0)?;
+            match type_id {
+                Some(type_id) if type_id == TypeId::of::<T>() => {
+                    func(&*get_userdata::<UserDataCell<T>>(lua.state, -1))
                }
-            } else {
-                func(&*get_userdata::<UserDataCell<T>>(lua.state, -3))
+                _ => Err(Error::UserDataTypeMismatch),
            }
        }
    }
@@ -900,6 +1131,13 @@ impl<'lua> AsRef<AnyUserData<'lua>> for AnyUserData<'lua> {
    }
 }

+unsafe fn getuservalue_table(state: *mut ffi::lua_State, idx: c_int) -> c_int {
+    #[cfg(feature = "lua54")]
+    return ffi::lua_getiuservalue(state, idx, USER_VALUE_MAXSLOT as c_int);
+    #[cfg(not(feature = "lua54"))]
+    return ffi::lua_getuservalue(state, idx);
+}
+
 /// Handle to a `UserData` metatable.
 #[derive(Clone, Debug)]
 pub struct UserDataMetatable<'lua>(pub(crate) Table<'lua>);
@@ -937,7 +1175,7 @@ impl<'lua> UserDataMetatable<'lua> {
    ///
    /// The pairs are wrapped in a [`Result`], since they are lazily converted to `V` type.
    ///
-    /// [`Result`]: type.Result.html
+    /// [`Result`]: crate::Result
    pub fn pairs<V: FromLua<'lua>>(self) -> UserDataMetatablePairs<'lua, V> {
        UserDataMetatablePairs(self.0.pairs())
    }
@@ -949,8 +1187,8 @@ impl<'lua> UserDataMetatable<'lua> {
 ///
 /// This struct is created by the [`UserDataMetatable::pairs`] method.
 ///
-/// [`UserData`]: trait.UserData.html
-/// [`UserDataMetatable::pairs`]: struct.UserDataMetatable.html#method.pairs
+/// [`UserData`]: crate::UserData
+/// [`UserDataMetatable::pairs`]: crate::UserDataMetatable::method.pairs
 pub struct UserDataMetatablePairs<'lua, V>(TablePairs<'lua, StdString, V>);

 impl<'lua, V> Iterator for UserDataMetatablePairs<'lua, V>
@@ -980,21 +1218,19 @@ impl<'lua> Serialize for AnyUserData<'lua> {
    where
        S: Serializer,
    {
-        unsafe {
-            let lua = self.0.lua;
+        let lua = self.0.lua;
+        let data = unsafe {
            let _sg = StackGuard::new(lua.state);
            check_stack(lua.state, 3).map_err(ser::Error::custom)?;

-            lua.push_userdata_ref(&self.0, false)
-                .map_err(ser::Error::custom)?;
-            let ud = &*get_userdata::<UserDataCell<c_void>>(lua.state, -1);
-            let data =
-                ud.0.try_borrow()
-                    .map_err(|_| ser::Error::custom(Error::UserDataBorrowError))?;
-            match *data {
-                UserDataWrapped::Default(_) => UserDataSerializeError.serialize(serializer),
-                UserDataWrapped::Serializable(_, ser) => (&*ser).serialize(serializer),
-            }
+            lua.push_userdata_ref(&self.0).map_err(ser::Error::custom)?;
+            let ud = &*get_userdata::<UserDataCell<()>>(lua.state, -1);
+            ud.0.try_borrow()
+                .map_err(|_| ser::Error::custom(Error::UserDataBorrowError))?
+        };
+        match &*data {
+            UserDataWrapped::Default(_) => UserDataSerializeError.serialize(serializer),
+            UserDataWrapped::Serializable(ser) => ser.serialize(serializer),
        }
    }
 }
@@ -0,0 +1,583 @@
+use std::any::TypeId;
+use std::cell::{Ref, RefCell, RefMut};
+use std::marker::PhantomData;
+use std::sync::{Arc, Mutex, RwLock};
+
+use crate::error::{Error, Result};
+use crate::ffi;
+use crate::lua::Lua;
+use crate::types::{Callback, MaybeSend};
+use crate::userdata::{
+    AnyUserData, MetaMethod, UserData, UserDataCell, UserDataFields, UserDataMethods,
+};
+use crate::util::{check_stack, get_userdata, StackGuard};
+use crate::value::{FromLua, FromLuaMulti, ToLua, ToLuaMulti, Value};
+
+#[cfg(not(feature = "send"))]
+use std::rc::Rc;
+
+#[cfg(feature = "async")]
+use {
+    crate::types::AsyncCallback,
+    futures_core::future::Future,
+    futures_util::future::{self, TryFutureExt},
+};
+
+pub(crate) struct StaticUserDataMethods<'lua, T: 'static + UserData> {
+    pub(crate) methods: Vec<(Vec<u8>, Callback<'lua, 'static>)>,
+    #[cfg(feature = "async")]
+    pub(crate) async_methods: Vec<(Vec<u8>, AsyncCallback<'lua, 'static>)>,
+    pub(crate) meta_methods: Vec<(MetaMethod, Callback<'lua, 'static>)>,
+    #[cfg(feature = "async")]
+    pub(crate) async_meta_methods: Vec<(MetaMethod, AsyncCallback<'lua, 'static>)>,
+    _type: PhantomData<T>,
+}
+
+impl<'lua, T: 'static + UserData> Default for StaticUserDataMethods<'lua, T> {
+    fn default() -> StaticUserDataMethods<'lua, T> {
+        StaticUserDataMethods {
+            methods: Vec::new(),
+            #[cfg(feature = "async")]
+            async_methods: Vec::new(),
+            meta_methods: Vec::new(),
+            #[cfg(feature = "async")]
+            async_meta_methods: Vec::new(),
+            _type: PhantomData,
+        }
+    }
+}
+
+impl<'lua, T: 'static + UserData> UserDataMethods<'lua, T> for StaticUserDataMethods<'lua, T> {
+    fn add_method<S, A, R, M>(&mut self, name: &S, method: M)
+    where
+        S: AsRef<[u8]> + ?Sized,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,
+    {
+        self.methods
+            .push((name.as_ref().to_vec(), Self::box_method(method)));
+    }
+
+    fn add_method_mut<S, A, R, M>(&mut self, name: &S, method: M)
+    where
+        S: AsRef<[u8]> + ?Sized,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,
+    {
+        self.methods
+            .push((name.as_ref().to_vec(), Self::box_method_mut(method)));
+    }
+
+    #[cfg(feature = "async")]
+    fn add_async_method<S, A, R, M, MR>(&mut self, name: &S, method: M)
+    where
+        T: Clone,
+        S: AsRef<[u8]> + ?Sized,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
+        MR: 'lua + Future<Output = Result<R>>,
+    {
+        self.async_methods
+            .push((name.as_ref().to_vec(), Self::box_async_method(method)));
+    }
+
+    fn add_function<S, A, R, F>(&mut self, name: &S, function: F)
+    where
+        S: AsRef<[u8]> + ?Sized,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
+    {
+        self.methods
+            .push((name.as_ref().to_vec(), Self::box_function(function)));
+    }
+
+    fn add_function_mut<S, A, R, F>(&mut self, name: &S, function: F)
+    where
+        S: AsRef<[u8]> + ?Sized,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,
+    {
+        self.methods
+            .push((name.as_ref().to_vec(), Self::box_function_mut(function)));
+    }
+
+    #[cfg(feature = "async")]
+    fn add_async_function<S, A, R, F, FR>(&mut self, name: &S, function: F)
+    where
+        S: AsRef<[u8]> + ?Sized,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
+        FR: 'lua + Future<Output = Result<R>>,
+    {
+        self.async_methods
+            .push((name.as_ref().to_vec(), Self::box_async_function(function)));
+    }
+
+    fn add_meta_method<S, A, R, M>(&mut self, meta: S, method: M)
+    where
+        S: Into<MetaMethod>,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,
+    {
+        self.meta_methods
+            .push((meta.into(), Self::box_method(method)));
+    }
+
+    fn add_meta_method_mut<S, A, R, M>(&mut self, meta: S, method: M)
+    where
+        S: Into<MetaMethod>,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,
+    {
+        self.meta_methods
+            .push((meta.into(), Self::box_method_mut(method)));
+    }
+
+    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
+    fn add_async_meta_method<S, A, R, M, MR>(&mut self, meta: S, method: M)
+    where
+        T: Clone,
+        S: Into<MetaMethod>,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
+        MR: 'lua + Future<Output = Result<R>>,
+    {
+        self.async_meta_methods
+            .push((meta.into(), Self::box_async_method(method)));
+    }
+
+    fn add_meta_function<S, A, R, F>(&mut self, meta: S, function: F)
+    where
+        S: Into<MetaMethod>,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
+    {
+        self.meta_methods
+            .push((meta.into(), Self::box_function(function)));
+    }
+
+    fn add_meta_function_mut<S, A, R, F>(&mut self, meta: S, function: F)
+    where
+        S: Into<MetaMethod>,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,
+    {
+        self.meta_methods
+            .push((meta.into(), Self::box_function_mut(function)));
+    }
+
+    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
+    fn add_async_meta_function<S, A, R, F, FR>(&mut self, meta: S, function: F)
+    where
+        S: Into<MetaMethod>,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
+        FR: 'lua + Future<Output = Result<R>>,
+    {
+        self.async_meta_methods
+            .push((meta.into(), Self::box_async_function(function)));
+    }
+
+    // Below are internal methods used in generated code
+
+    fn add_callback(&mut self, name: Vec<u8>, callback: Callback<'lua, 'static>) {
+        self.methods.push((name, callback));
+    }
+
+    #[cfg(feature = "async")]
+    fn add_async_callback(&mut self, name: Vec<u8>, callback: AsyncCallback<'lua, 'static>) {
+        self.async_methods.push((name, callback));
+    }
+
+    fn add_meta_callback(&mut self, meta: MetaMethod, callback: Callback<'lua, 'static>) {
+        self.meta_methods.push((meta, callback));
+    }
+
+    #[cfg(feature = "async")]
+    fn add_async_meta_callback(
+        &mut self,
+        meta: MetaMethod,
+        callback: AsyncCallback<'lua, 'static>,
+    ) {
+        self.async_meta_methods.push((meta, callback))
+    }
+}
+
+impl<'lua, T: 'static + UserData> StaticUserDataMethods<'lua, T> {
+    fn box_method<A, R, M>(method: M) -> Callback<'lua, 'static>
+    where
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        M: 'static + MaybeSend + Fn(&'lua Lua, &T, A) -> Result<R>,
+    {
+        Box::new(move |lua, mut args| {
+            if let Some(front) = args.pop_front() {
+                let userdata = AnyUserData::from_lua(front, lua)?;
+                unsafe {
+                    let _sg = StackGuard::new(lua.state);
+                    check_stack(lua.state, 2)?;
+
+                    let type_id = lua.push_userdata_ref(&userdata.0)?;
+                    match type_id {
+                        Some(id) if id == TypeId::of::<T>() => {
+                            let ud = get_userdata_ref::<T>(lua.state)?;
+                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                        }
+                        #[cfg(not(feature = "send"))]
+                        Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
+                            let ud = get_userdata_ref::<Rc<RefCell<T>>>(lua.state)?;
+                            let ud = ud.try_borrow().map_err(|_| Error::UserDataBorrowError)?;
+                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                        }
+                        Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
+                            let ud = get_userdata_ref::<Arc<Mutex<T>>>(lua.state)?;
+                            let ud = ud.try_lock().map_err(|_| Error::UserDataBorrowError)?;
+                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                        }
+                        Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
+                            let ud = get_userdata_ref::<Arc<RwLock<T>>>(lua.state)?;
+                            let ud = ud.try_read().map_err(|_| Error::UserDataBorrowError)?;
+                            method(lua, &ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                        }
+                        _ => Err(Error::UserDataTypeMismatch),
+                    }
+                }
+            } else {
+                Err(Error::FromLuaConversionError {
+                    from: "missing argument",
+                    to: "userdata",
+                    message: None,
+                })
+            }
+        })
+    }
+
+    fn box_method_mut<A, R, M>(method: M) -> Callback<'lua, 'static>
+    where
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<R>,
+    {
+        let method = RefCell::new(method);
+        Box::new(move |lua, mut args| {
+            if let Some(front) = args.pop_front() {
+                let userdata = AnyUserData::from_lua(front, lua)?;
+                let mut method = method
+                    .try_borrow_mut()
+                    .map_err(|_| Error::RecursiveMutCallback)?;
+                unsafe {
+                    let _sg = StackGuard::new(lua.state);
+                    check_stack(lua.state, 2)?;
+
+                    let type_id = lua.push_userdata_ref(&userdata.0)?;
+                    match type_id {
+                        Some(id) if id == TypeId::of::<T>() => {
+                            let mut ud = get_userdata_mut::<T>(lua.state)?;
+                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                        }
+                        #[cfg(not(feature = "send"))]
+                        Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
+                            let ud = get_userdata_mut::<Rc<RefCell<T>>>(lua.state)?;
+                            let mut ud = ud
+                                .try_borrow_mut()
+                                .map_err(|_| Error::UserDataBorrowMutError)?;
+                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                        }
+                        Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
+                            let ud = get_userdata_mut::<Arc<Mutex<T>>>(lua.state)?;
+                            let mut ud =
+                                ud.try_lock().map_err(|_| Error::UserDataBorrowMutError)?;
+                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                        }
+                        Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
+                            let ud = get_userdata_mut::<Arc<RwLock<T>>>(lua.state)?;
+                            let mut ud =
+                                ud.try_write().map_err(|_| Error::UserDataBorrowMutError)?;
+                            method(lua, &mut ud, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+                        }
+                        _ => Err(Error::UserDataTypeMismatch),
+                    }
+                }
+            } else {
+                Err(Error::FromLuaConversionError {
+                    from: "missing argument",
+                    to: "userdata",
+                    message: None,
+                })
+            }
+        })
+    }
+
+    #[cfg(feature = "async")]
+    fn box_async_method<A, R, M, MR>(method: M) -> AsyncCallback<'lua, 'static>
+    where
+        T: Clone,
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        M: 'static + MaybeSend + Fn(&'lua Lua, T, A) -> MR,
+        MR: 'lua + Future<Output = Result<R>>,
+    {
+        Box::new(move |lua, mut args| {
+            let fut_res = || {
+                if let Some(front) = args.pop_front() {
+                    let userdata = AnyUserData::from_lua(front, lua)?;
+                    unsafe {
+                        let _sg = StackGuard::new(lua.state);
+                        check_stack(lua.state, 2)?;
+
+                        let type_id = lua.push_userdata_ref(&userdata.0)?;
+                        match type_id {
+                            Some(id) if id == TypeId::of::<T>() => {
+                                let ud = get_userdata_ref::<T>(lua.state)?;
+                                Ok(method(lua, ud.clone(), A::from_lua_multi(args, lua)?))
+                            }
+                            #[cfg(not(feature = "send"))]
+                            Some(id) if id == TypeId::of::<Rc<RefCell<T>>>() => {
+                                let ud = get_userdata_ref::<Rc<RefCell<T>>>(lua.state)?;
+                                let ud = ud.try_borrow().map_err(|_| Error::UserDataBorrowError)?;
+                                Ok(method(lua, ud.clone(), A::from_lua_multi(args, lua)?))
+                            }
+                            Some(id) if id == TypeId::of::<Arc<Mutex<T>>>() => {
+                                let ud = get_userdata_ref::<Arc<Mutex<T>>>(lua.state)?;
+                                let ud = ud.try_lock().map_err(|_| Error::UserDataBorrowError)?;
+                                Ok(method(lua, ud.clone(), A::from_lua_multi(args, lua)?))
+                            }
+                            Some(id) if id == TypeId::of::<Arc<RwLock<T>>>() => {
+                                let ud = get_userdata_ref::<Arc<RwLock<T>>>(lua.state)?;
+                                let ud = ud.try_read().map_err(|_| Error::UserDataBorrowError)?;
+                                Ok(method(lua, ud.clone(), A::from_lua_multi(args, lua)?))
+                            }
+                            _ => Err(Error::UserDataTypeMismatch),
+                        }
+                    }
+                } else {
+                    Err(Error::FromLuaConversionError {
+                        from: "missing argument",
+                        to: "userdata",
+                        message: None,
+                    })
+                }
+            };
+            match fut_res() {
+                Ok(fut) => Box::pin(fut.and_then(move |ret| future::ready(ret.to_lua_multi(lua)))),
+                Err(e) => Box::pin(future::err(e)),
+            }
+        })
+    }
+
+    fn box_function<A, R, F>(function: F) -> Callback<'lua, 'static>
+    where
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> Result<R>,
+    {
+        Box::new(move |lua, args| function(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua))
+    }
+
+    fn box_function_mut<A, R, F>(function: F) -> Callback<'lua, 'static>
+    where
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        F: 'static + MaybeSend + FnMut(&'lua Lua, A) -> Result<R>,
+    {
+        let function = RefCell::new(function);
+        Box::new(move |lua, args| {
+            let function = &mut *function
+                .try_borrow_mut()
+                .map_err(|_| Error::RecursiveMutCallback)?;
+            function(lua, A::from_lua_multi(args, lua)?)?.to_lua_multi(lua)
+        })
+    }
+
+    #[cfg(feature = "async")]
+    fn box_async_function<A, R, F, FR>(function: F) -> AsyncCallback<'lua, 'static>
+    where
+        A: FromLuaMulti<'lua>,
+        R: ToLuaMulti<'lua>,
+        F: 'static + MaybeSend + Fn(&'lua Lua, A) -> FR,
+        FR: 'lua + Future<Output = Result<R>>,
+    {
+        Box::new(move |lua, args| {
+            let args = match A::from_lua_multi(args, lua) {
+                Ok(args) => args,
+                Err(e) => return Box::pin(future::err(e)),
+            };
+            Box::pin(function(lua, args).and_then(move |ret| future::ready(ret.to_lua_multi(lua))))
+        })
+    }
+}
+
+pub(crate) struct StaticUserDataFields<'lua, T: 'static + UserData> {
+    pub(crate) field_getters: Vec<(Vec<u8>, Callback<'lua, 'static>)>,
+    pub(crate) field_setters: Vec<(Vec<u8>, Callback<'lua, 'static>)>,
+    #[allow(clippy::type_complexity)]
+    pub(crate) meta_fields: Vec<(
+        MetaMethod,
+        Box<dyn Fn(&'lua Lua) -> Result<Value<'lua>> + 'static>,
+    )>,
+    _type: PhantomData<T>,
+}
+
+impl<'lua, T: 'static + UserData> Default for StaticUserDataFields<'lua, T> {
+    fn default() -> StaticUserDataFields<'lua, T> {
+        StaticUserDataFields {
+            field_getters: Vec::new(),
+            field_setters: Vec::new(),
+            meta_fields: Vec::new(),
+            _type: PhantomData,
+        }
+    }
+}
+
+impl<'lua, T: 'static + UserData> UserDataFields<'lua, T> for StaticUserDataFields<'lua, T> {
+    fn add_field_method_get<S, R, M>(&mut self, name: &S, method: M)
+    where
+        S: AsRef<[u8]> + ?Sized,
+        R: ToLua<'lua>,
+        M: 'static + MaybeSend + Fn(&'lua Lua, &T) -> Result<R>,
+    {
+        self.field_getters.push((
+            name.as_ref().to_vec(),
+            StaticUserDataMethods::box_method(move |lua, data, ()| method(lua, data)),
+        ));
+    }
+
+    fn add_field_method_set<S, A, M>(&mut self, name: &S, method: M)
+    where
+        S: AsRef<[u8]> + ?Sized,
+        A: FromLua<'lua>,
+        M: 'static + MaybeSend + FnMut(&'lua Lua, &mut T, A) -> Result<()>,
+    {
+        self.field_setters.push((
+            name.as_ref().to_vec(),
+            StaticUserDataMethods::box_method_mut(method),
+        ));
+    }
+
+    fn add_field_function_get<S, R, F>(&mut self, name: &S, function: F)
+    where
+        S: AsRef<[u8]> + ?Sized,
+        R: ToLua<'lua>,
+        F: 'static + MaybeSend + Fn(&'lua Lua, AnyUserData<'lua>) -> Result<R>,
+    {
+        self.field_getters.push((
+            name.as_ref().to_vec(),
+            StaticUserDataMethods::<T>::box_function(function),
+        ));
+    }
+
+    fn add_field_function_set<S, A, F>(&mut self, name: &S, mut function: F)
+    where
+        S: AsRef<[u8]> + ?Sized,
+        A: FromLua<'lua>,
+        F: 'static + MaybeSend + FnMut(&'lua Lua, AnyUserData<'lua>, A) -> Result<()>,
+    {
+        self.field_setters.push((
+            name.as_ref().to_vec(),
+            StaticUserDataMethods::<T>::box_function_mut(move |lua, (data, val)| {
+                function(lua, data, val)
+            }),
+        ));
+    }
+
+    fn add_meta_field_with<S, R, F>(&mut self, meta: S, f: F)
+    where
+        S: Into<MetaMethod>,
+        R: ToLua<'lua>,
+        F: 'static + MaybeSend + Fn(&'lua Lua) -> Result<R>,
+    {
+        let meta = meta.into();
+        self.meta_fields.push((
+            meta.clone(),
+            Box::new(move |lua| {
+                let value = f(lua)?.to_lua(lua)?;
+                if meta == MetaMethod::Index || meta == MetaMethod::NewIndex {
+                    match value {
+                        Value::Nil | Value::Table(_) | Value::Function(_) => {}
+                        _ => {
+                            return Err(Error::MetaMethodTypeError {
+                                method: meta.to_string(),
+                                type_name: value.type_name(),
+                                message: Some("expected nil, table or function".to_string()),
+                            })
+                        }
+                    }
+                }
+                Ok(value)
+            }),
+        ));
+    }
+
+    // Below are internal methods
+
+    fn add_field_getter(&mut self, name: Vec<u8>, callback: Callback<'lua, 'static>) {
+        self.field_getters.push((name, callback));
+    }
+
+    fn add_field_setter(&mut self, name: Vec<u8>, callback: Callback<'lua, 'static>) {
+        self.field_setters.push((name, callback));
+    }
+}
+
+#[inline]
+unsafe fn get_userdata_ref<'a, T>(state: *mut ffi::lua_State) -> Result<Ref<'a, T>> {
+    (*get_userdata::<UserDataCell<T>>(state, -1)).try_borrow()
+}
+
+#[inline]
+unsafe fn get_userdata_mut<'a, T>(state: *mut ffi::lua_State) -> Result<RefMut<'a, T>> {
+    (*get_userdata::<UserDataCell<T>>(state, -1)).try_borrow_mut()
+}
+
+macro_rules! lua_userdata_impl {
+    ($type:ty) => {
+        impl<T: 'static + UserData> UserData for $type {
+            fn add_fields<'lua, F: UserDataFields<'lua, Self>>(fields: &mut F) {
+                let mut orig_fields = StaticUserDataFields::default();
+                T::add_fields(&mut orig_fields);
+                for (name, callback) in orig_fields.field_getters {
+                    fields.add_field_getter(name, callback);
+                }
+                for (name, callback) in orig_fields.field_setters {
+                    fields.add_field_setter(name, callback);
+                }
+            }
+
+            fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+                let mut orig_methods = StaticUserDataMethods::default();
+                T::add_methods(&mut orig_methods);
+                for (name, callback) in orig_methods.methods {
+                    methods.add_callback(name, callback);
+                }
+                #[cfg(feature = "async")]
+                for (name, callback) in orig_methods.async_methods {
+                    methods.add_async_callback(name, callback);
+                }
+                for (meta, callback) in orig_methods.meta_methods {
+                    methods.add_meta_callback(meta, callback);
+                }
+                #[cfg(feature = "async")]
+                for (meta, callback) in orig_methods.async_meta_methods {
+                    methods.add_async_meta_callback(meta, callback);
+                }
+            }
+        }
+    };
+}
+
+#[cfg(not(feature = "send"))]
+lua_userdata_impl!(Rc<RefCell<T>>);
+lua_userdata_impl!(Arc<Mutex<T>>);
+lua_userdata_impl!(Arc<RwLock<T>>);
@@ -1,24 +1,28 @@
 use std::any::{Any, TypeId};
-use std::collections::HashMap;
-use std::error::Error as StdError;
+use std::ffi::CStr;
 use std::fmt::Write;
 use std::os::raw::{c_char, c_int, c_void};
 use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe};
-use std::sync::{Arc, Mutex};
+use std::sync::Arc;
 use std::{mem, ptr, slice};

 use once_cell::sync::Lazy;
+use rustc_hash::FxHashMap;

 use crate::error::{Error, Result};
 use crate::ffi;

-static METATABLE_CACHE: Lazy<Mutex<HashMap<TypeId, u8>>> = Lazy::new(|| {
-    // The capacity must(!) be greater than number of stored keys
-    Mutex::new(HashMap::with_capacity(32))
+static METATABLE_CACHE: Lazy<FxHashMap<TypeId, u8>> = Lazy::new(|| {
+    let mut map = FxHashMap::with_capacity_and_hasher(32, Default::default());
+    crate::lua::init_metatable_cache(&mut map);
+    map.insert(TypeId::of::<WrappedFailure>(), 0);
+    map.insert(TypeId::of::<String>(), 0);
+    map
 });

 // Checks that Lua has enough free stack space for future stack operations. On failure, this will
 // panic with an internal error message.
+#[inline]
 pub unsafe fn assert_stack(state: *mut ffi::lua_State, amount: c_int) {
    // TODO: This should only be triggered when there is a logic error in `mlua`. In the future,
    // when there is a way to be confident about stack safety and test it, this could be enabled
@@ -30,6 +34,7 @@ pub unsafe fn assert_stack(state: *mut ffi::lua_State, amount: c_int) {
 }

 // Checks that Lua has enough free stack space and returns `Error::StackError` on failure.
+#[inline]
 pub unsafe fn check_stack(state: *mut ffi::lua_State, amount: c_int) -> Result<()> {
    if ffi::lua_checkstack(state, amount) == 0 {
        Err(Error::StackError)
@@ -48,6 +53,7 @@ impl StackGuard {
    // Creates a StackGuard instance with record of the stack size, and on Drop will check the
    // stack size and drop any extra elements. If the stack size at the end is *smaller* than at
    // the beginning, this is considered a fatal logic error and will result in a panic.
+    #[inline]
    pub unsafe fn new(state: *mut ffi::lua_State) -> StackGuard {
        StackGuard {
            state,
@@ -57,6 +63,7 @@ impl StackGuard {
    }

    // Similar to `new`, but checks and keeps `extra` elements from top of the stack on Drop.
+    #[inline]
    pub unsafe fn new_extra(state: *mut ffi::lua_State, extra: c_int) -> StackGuard {
        StackGuard {
            state,
@@ -83,6 +90,35 @@ impl Drop for StackGuard {
    }
 }

+// Call a function that calls into the Lua API and may trigger a Lua error (longjmp) in a safe way.
+// Wraps the inner function in a call to `lua_pcall`, so the inner function only has access to a
+// limited lua stack. `nargs` is the same as the the parameter to `lua_pcall`, and `nresults` is
+// always `LUA_MULTRET`. Provided function must *not* panic, and since it will generally be lonjmping,
+// should not contain any values that implements Drop.
+// Internally uses 2 extra stack spaces, and does not call checkstack.
+pub unsafe fn protect_lua_call(
+    state: *mut ffi::lua_State,
+    nargs: c_int,
+    f: unsafe extern "C" fn(*mut ffi::lua_State) -> c_int,
+) -> Result<()> {
+    let stack_start = ffi::lua_gettop(state) - nargs;
+
+    ffi::lua_pushcfunction(state, error_traceback);
+    ffi::lua_pushcfunction(state, f);
+    if nargs > 0 {
+        ffi::lua_rotate(state, stack_start + 1, 2);
+    }
+
+    let ret = ffi::lua_pcall(state, nargs, ffi::LUA_MULTRET, stack_start + 1);
+    ffi::lua_remove(state, stack_start + 1);
+
+    if ret == ffi::LUA_OK {
+        Ok(())
+    } else {
+        Err(pop_error(state, ret))
+    }
+}
+
 // Call a function that calls into the Lua API and may trigger a Lua error (longjmp) in a safe way.
 // Wraps the inner function in a call to `lua_pcall`, so the inner function only has access to a
 // limited lua stack. `nargs` and `nresults` are similar to the parameters of `lua_pcall`, but the
@@ -90,7 +126,7 @@ impl Drop for StackGuard {
 // values are assumed to match the `nresults` param. Provided function must *not* panic, and since it
 // will generally be lonjmping, should not contain any values that implements Drop.
 // Internally uses 3 extra stack spaces, and does not call checkstack.
-pub unsafe fn protect_lua<F, R>(
+pub unsafe fn protect_lua_closure<F, R>(
    state: *mut ffi::lua_State,
    nargs: c_int,
    nresults: c_int,
@@ -210,30 +246,32 @@ pub unsafe fn pop_error(state: *mut ffi::lua_State, err_code: c_int) -> Error {
    }
 }

-// Uses 3 stack spaces
+// Uses 3 stack spaces, does not call checkstack.
+#[inline]
 pub unsafe fn push_string<S: AsRef<[u8]> + ?Sized>(
    state: *mut ffi::lua_State,
    s: &S,
 ) -> Result<()> {
    let s = s.as_ref();
-    protect_lua(state, 0, 1, |state| {
+    protect_lua!(state, 0, 1, |state| {
        ffi::lua_pushlstring(state, s.as_ptr() as *const c_char, s.len());
    })
 }

-// Uses 3 stack spaces
+// Uses 3 stack spaces, does not call checkstack.
+#[inline]
 pub unsafe fn push_table(state: *mut ffi::lua_State, narr: c_int, nrec: c_int) -> Result<()> {
-    protect_lua(state, 0, 1, |state| ffi::lua_createtable(state, narr, nrec))
+    protect_lua!(state, 0, 1, |state| ffi::lua_createtable(state, narr, nrec))
 }

-// Uses 4 stack spaces
+// Uses 4 stack spaces, does not call checkstack.
 pub unsafe fn rawset_field<S>(state: *mut ffi::lua_State, table: c_int, field: &S) -> Result<()>
 where
    S: AsRef<[u8]> + ?Sized,
 {
    let field = field.as_ref();
    ffi::lua_pushvalue(state, table);
-    protect_lua(state, 2, 0, |state| {
+    protect_lua!(state, 2, 0, |state| {
        ffi::lua_pushlstring(state, field.as_ptr() as *const c_char, field.len());
        ffi::lua_rotate(state, -3, 2);
        ffi::lua_rawset(state, -3);
@@ -241,14 +279,49 @@ where
 }

 // Internally uses 3 stack spaces, does not call checkstack.
+#[cfg(not(feature = "luau"))]
+#[inline]
 pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T) -> Result<()> {
-    let ud = protect_lua(state, 0, 1, |state| {
+    let ud = protect_lua!(state, 0, 1, |state| {
        ffi::lua_newuserdata(state, mem::size_of::<T>()) as *mut T
    })?;
    ptr::write(ud, t);
    Ok(())
 }

+// Internally uses 3 stack spaces, does not call checkstack.
+#[cfg(feature = "luau")]
+#[inline]
+pub unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T) -> Result<()> {
+    unsafe extern "C" fn destructor<T>(ud: *mut c_void) {
+        let ud = ud as *mut T;
+        if *(ud.offset(1) as *mut u8) == 0 {
+            ptr::drop_in_place(ud);
+        }
+    }
+
+    let ud = protect_lua!(state, 0, 1, |state| {
+        let size = mem::size_of::<T>() + 1;
+        ffi::lua_newuserdatadtor(state, size, destructor::<T>) as *mut T
+    })?;
+    ptr::write(ud, t);
+    *(ud.offset(1) as *mut u8) = 0; // Mark as not destructed
+
+    Ok(())
+}
+
+// Internally uses 3 stack spaces, does not call checkstack.
+#[cfg(feature = "lua54")]
+#[inline]
+pub unsafe fn push_userdata_uv<T>(state: *mut ffi::lua_State, t: T, nuvalue: c_int) -> Result<()> {
+    let ud = protect_lua!(state, 0, 1, |state| {
+        ffi::lua_newuserdatauv(state, mem::size_of::<T>(), nuvalue) as *mut T
+    })?;
+    ptr::write(ud, t);
+    Ok(())
+}
+
+#[inline]
 pub unsafe fn get_userdata<T>(state: *mut ffi::lua_State, index: c_int) -> *mut T {
    let ud = ffi::lua_touserdata(state, index) as *mut T;
    mlua_debug_assert!(!ud.is_null(), "userdata pointer is null");
@@ -266,8 +339,11 @@ pub unsafe fn take_userdata<T>(state: *mut ffi::lua_State) -> T {
    // after the first call to __gc.
    get_destructed_userdata_metatable(state);
    ffi::lua_setmetatable(state, -2);
-    let ud = get_userdata(state, -1);
+    let ud = get_userdata::<T>(state, -1);
    ffi::lua_pop(state, 1);
+    if cfg!(feature = "luau") {
+        *(ud.offset(1) as *mut u8) = 1; // Mark as destructed
+    }
    ptr::read(ud)
 }

@@ -295,6 +371,119 @@ pub unsafe fn get_gc_userdata<T: Any>(state: *mut ffi::lua_State, index: c_int)
    ud
 }

+unsafe extern "C" fn lua_error_impl(state: *mut ffi::lua_State) -> c_int {
+    ffi::lua_error(state);
+}
+
+unsafe extern "C" fn lua_isfunction_impl(state: *mut ffi::lua_State) -> c_int {
+    let t = ffi::lua_type(state, -1);
+    ffi::lua_pop(state, 1);
+    ffi::lua_pushboolean(state, (t == ffi::LUA_TFUNCTION) as c_int);
+    1
+}
+
+unsafe fn init_userdata_metatable_index(state: *mut ffi::lua_State) -> Result<()> {
+    let index_key = &USERDATA_METATABLE_INDEX as *const u8 as *const _;
+    if ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, index_key) == ffi::LUA_TFUNCTION {
+        return Ok(());
+    }
+    ffi::lua_pop(state, 1);
+
+    // Create and cache `__index` helper
+    let code = cstr!(
+        r#"
+            local error, isfunction = ...
+            return function (__index, field_getters, methods)
+                return function (self, key)
+                    if field_getters ~= nil then
+                        local field_getter = field_getters[key]
+                        if field_getter ~= nil then
+                            return field_getter(self)
+                        end
+                    end
+
+                    if methods ~= nil then
+                        local method = methods[key]
+                        if method ~= nil then
+                            return method
+                        end
+                    end
+
+                    if isfunction(__index) then
+                        return __index(self, key)
+                    elseif __index == nil then
+                        error("attempt to get an unknown field '"..key.."'")
+                    else
+                        return __index[key]
+                    end
+                end
+            end
+    "#
+    );
+    let code_len = CStr::from_ptr(code).to_bytes().len();
+    protect_lua!(state, 0, 1, |state| {
+        let ret = ffi::luaL_loadbuffer(state, code, code_len, cstr!("__mlua_index"));
+        if ret != ffi::LUA_OK {
+            ffi::lua_error(state);
+        }
+        ffi::lua_pushcfunction(state, lua_error_impl);
+        ffi::lua_pushcfunction(state, lua_isfunction_impl);
+        ffi::lua_call(state, 2, 1);
+
+        // Store in the registry
+        ffi::lua_pushvalue(state, -1);
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, index_key);
+    })
+}
+
+pub unsafe fn init_userdata_metatable_newindex(state: *mut ffi::lua_State) -> Result<()> {
+    let newindex_key = &USERDATA_METATABLE_NEWINDEX as *const u8 as *const _;
+    if ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, newindex_key) == ffi::LUA_TFUNCTION {
+        return Ok(());
+    }
+    ffi::lua_pop(state, 1);
+
+    // Create and cache `__newindex` helper
+    let code = cstr!(
+        r#"
+            local error, isfunction = ...
+            return function (__newindex, field_setters)
+                return function (self, key, value)
+                    if field_setters ~= nil then
+                        local field_setter = field_setters[key]
+                        if field_setter ~= nil then
+                            field_setter(self, value)
+                            return
+                        end
+                    end
+
+                    if isfunction(__newindex) then
+                        __newindex(self, key, value)
+                    elseif __newindex == nil then
+                        error("attempt to set an unknown field '"..key.."'")
+                    else
+                        __newindex[key] = value
+                    end
+                end
+            end
+    "#
+    );
+    let code_len = CStr::from_ptr(code).to_bytes().len();
+    protect_lua!(state, 0, 1, |state| {
+        let ret = ffi::luaL_loadbuffer(state, code, code_len, cstr!("__mlua_newindex"));
+        if ret != ffi::LUA_OK {
+            ffi::lua_error(state);
+        }
+        ffi::lua_pushcfunction(state, lua_error_impl);
+        ffi::lua_pushcfunction(state, lua_isfunction_impl);
+        ffi::lua_call(state, 2, 1);
+
+        // Store in the registry
+        ffi::lua_pushvalue(state, -1);
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, newindex_key);
+    })
+}
+
 // Populates the given table with the appropriate members to be a userdata metatable for the given type.
 // This function takes the given table at the `metatable` index, and adds an appropriate `__gc` member
 // to it for the given type and a `__metatable` entry to protect the table from script access.
@@ -310,99 +499,14 @@ pub unsafe fn init_userdata_metatable<T>(
    field_setters: Option<c_int>,
    methods: Option<c_int>,
 ) -> Result<()> {
-    // Wrapper to lookup in `field_getters` first, then `methods`, ending original `__index`.
-    // Used only if `field_getters` or `methods` set.
-    unsafe extern "C" fn meta_index_impl(state: *mut ffi::lua_State) -> c_int {
-        // stack: self, key
-        ffi::luaL_checkstack(state, 2, ptr::null());
-
-        // lookup in `field_getters` table
-        if ffi::lua_isnil(state, ffi::lua_upvalueindex(2)) == 0 {
-            ffi::lua_pushvalue(state, -1); // `key` arg
-            if ffi::lua_rawget(state, ffi::lua_upvalueindex(2)) != ffi::LUA_TNIL {
-                ffi::lua_insert(state, -3); // move function
-                ffi::lua_pop(state, 1); // remove `key`
-                ffi::lua_call(state, 1, 1);
-                return 1;
-            }
-            ffi::lua_pop(state, 1); // pop the nil value
-        }
-        // lookup in `methods` table
-        if ffi::lua_isnil(state, ffi::lua_upvalueindex(3)) == 0 {
-            ffi::lua_pushvalue(state, -1); // `key` arg
-            if ffi::lua_rawget(state, ffi::lua_upvalueindex(3)) != ffi::LUA_TNIL {
-                ffi::lua_insert(state, -3);
-                ffi::lua_pop(state, 2);
-                return 1;
-            }
-            ffi::lua_pop(state, 1); // pop the nil value
-        }
-
-        // lookup in `__index`
-        ffi::lua_pushvalue(state, ffi::lua_upvalueindex(1));
-        match ffi::lua_type(state, -1) {
-            ffi::LUA_TNIL => {
-                ffi::lua_pop(state, 1); // pop the nil value
-                let field = ffi::lua_tostring(state, -1);
-                ffi::luaL_error(state, cstr!("attempt to get an unknown field '%s'"), field);
-            }
-            ffi::LUA_TTABLE => {
-                ffi::lua_insert(state, -2);
-                ffi::lua_gettable(state, -2);
-            }
-            ffi::LUA_TFUNCTION => {
-                ffi::lua_insert(state, -3);
-                ffi::lua_call(state, 2, 1);
-            }
-            _ => unreachable!(),
-        }
-
-        1
-    }
-
-    // Similar to `meta_index_impl`, checks `field_setters` table first, then `__newindex` metamethod.
-    // Used only if `field_setters` set.
-    unsafe extern "C" fn meta_newindex_impl(state: *mut ffi::lua_State) -> c_int {
-        // stack: self, key, value
-        ffi::luaL_checkstack(state, 2, ptr::null());
-
-        // lookup in `field_setters` table
-        ffi::lua_pushvalue(state, -2); // `key` arg
-        if ffi::lua_rawget(state, ffi::lua_upvalueindex(2)) != ffi::LUA_TNIL {
-            ffi::lua_remove(state, -3); // remove `key`
-            ffi::lua_insert(state, -3); // move function
-            ffi::lua_call(state, 2, 0);
-            return 0;
-        }
-        ffi::lua_pop(state, 1); // pop the nil value
-
-        // lookup in `__newindex`
-        ffi::lua_pushvalue(state, ffi::lua_upvalueindex(1));
-        match ffi::lua_type(state, -1) {
-            ffi::LUA_TNIL => {
-                ffi::lua_pop(state, 1); // pop the nil value
-                let field = ffi::lua_tostring(state, -2);
-                ffi::luaL_error(state, cstr!("attempt to set an unknown field '%s'"), field);
-            }
-            ffi::LUA_TTABLE => {
-                ffi::lua_insert(state, -3);
-                ffi::lua_settable(state, -3);
-            }
-            ffi::LUA_TFUNCTION => {
-                ffi::lua_insert(state, -4);
-                ffi::lua_call(state, 3, 0);
-            }
-            _ => unreachable!(),
-        }
-
-        0
-    }
-
    ffi::lua_pushvalue(state, metatable);

    if field_getters.is_some() || methods.is_some() {
+        // Push `__index` generator function
+        init_userdata_metatable_index(state)?;
+
        push_string(state, "__index")?;
-        let index_type = ffi::lua_rawget(state, -2);
+        let index_type = ffi::lua_rawget(state, -3);
        match index_type {
            ffi::LUA_TNIL | ffi::LUA_TTABLE | ffi::LUA_TFUNCTION => {
                for &idx in &[field_getters, methods] {
@@ -412,9 +516,9 @@ pub unsafe fn init_userdata_metatable<T>(
                        ffi::lua_pushnil(state);
                    }
                }
-                protect_lua(state, 3, 1, |state| {
-                    ffi::lua_pushcclosure(state, meta_index_impl, 3);
-                })?;
+
+                // Generate `__index`
+                protect_lua!(state, 4, 1, fn(state) ffi::lua_call(state, 3, 1))?;
            }
            _ => mlua_panic!("improper __index type {}", index_type),
        }
@@ -423,14 +527,16 @@ pub unsafe fn init_userdata_metatable<T>(
    }

    if let Some(field_setters) = field_setters {
+        // Push `__newindex` generator function
+        init_userdata_metatable_newindex(state)?;
+
        push_string(state, "__newindex")?;
-        let newindex_type = ffi::lua_rawget(state, -2);
+        let newindex_type = ffi::lua_rawget(state, -3);
        match newindex_type {
            ffi::LUA_TNIL | ffi::LUA_TTABLE | ffi::LUA_TFUNCTION => {
                ffi::lua_pushvalue(state, field_setters);
-                protect_lua(state, 2, 1, |state| {
-                    ffi::lua_pushcclosure(state, meta_newindex_impl, 2);
-                })?;
+                // Generate `__newindex`
+                protect_lua!(state, 3, 1, fn(state) ffi::lua_call(state, 2, 1))?;
            }
            _ => mlua_panic!("improper __newindex type {}", newindex_type),
        }
@@ -438,8 +544,11 @@ pub unsafe fn init_userdata_metatable<T>(
        rawset_field(state, -2, "__newindex")?;
    }

-    ffi::lua_pushcfunction(state, userdata_destructor::<T>);
-    rawset_field(state, -2, "__gc")?;
+    #[cfg(not(feature = "luau"))]
+    {
+        ffi::lua_pushcfunction(state, userdata_destructor::<T>);
+        rawset_field(state, -2, "__gc")?;
+    }

    ffi::lua_pushboolean(state, 0);
    rawset_field(state, -2, "__metatable")?;
@@ -449,12 +558,12 @@ pub unsafe fn init_userdata_metatable<T>(
    Ok(())
 }

+#[cfg(not(feature = "luau"))]
 pub unsafe extern "C" fn userdata_destructor<T>(state: *mut ffi::lua_State) -> c_int {
-    callback_error(state, |_| {
-        check_stack(state, 1)?;
-        take_userdata::<T>(state);
-        Ok(0)
-    })
+    // It's probably NOT a good idea to catch Rust panics in finalizer
+    // Lua 5.4 ignores it, other versions generates `LUA_ERRGCMM` without calling message handler
+    take_userdata::<T>(state);
+    0
 }

 // In the context of a lua callback, this will call the given function and if the given function
@@ -484,7 +593,7 @@ where

    // We cannot shadow Rust errors with Lua ones, we pre-allocate enough memory
    // to store a wrapped error or panic *before* we proceed.
-    let ud = ffi::lua_newuserdata(state, mem::size_of::<WrappedFailure>());
+    let ud = WrappedFailure::new_userdata(state);
    ffi::lua_rotate(state, 1, 1);

    match catch_unwind(AssertUnwindSafe(|| f(nargs))) {
@@ -496,11 +605,8 @@ where
            ffi::lua_settop(state, 1);

            let wrapped_error = ud as *mut WrappedFailure;
-            ptr::write(wrapped_error, WrappedFailure::Error(err));
-            get_gc_metatable::<WrappedFailure>(state);
-            ffi::lua_setmetatable(state, -2);

-            // Convert to CallbackError and attach traceback
+            // Build `CallbackError` with traceback
            let traceback = if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
                ffi::luaL_traceback(state, state, ptr::null(), 0);
                let traceback = to_string(state, -1);
@@ -509,10 +615,13 @@ where
            } else {
                "<not enough stack space for traceback>".to_string()
            };
-            if let WrappedFailure::Error(ref mut err) = *wrapped_error {
-                let cause = Arc::new(err.clone());
-                *err = Error::CallbackError { traceback, cause };
-            }
+            let cause = Arc::new(err);
+            ptr::write(
+                wrapped_error,
+                WrappedFailure::Error(Error::CallbackError { traceback, cause }),
+            );
+            get_gc_metatable::<WrappedFailure>(state);
+            ffi::lua_setmetatable(state, -2);

            ffi::lua_error(state)
        }
@@ -536,7 +645,7 @@ pub unsafe extern "C" fn error_traceback(state: *mut ffi::lua_State) -> c_int {
    if get_gc_userdata::<WrappedFailure>(state, -1).is_null() {
        let s = ffi::luaL_tolstring(state, -1, ptr::null_mut());
        if ffi::lua_checkstack(state, ffi::LUA_TRACEBACK_STACK) != 0 {
-            ffi::luaL_traceback(state, state, s, 1);
+            ffi::luaL_traceback(state, state, s, 0);
            ffi::lua_remove(state, -2);
        }
    }
@@ -637,6 +746,8 @@ pub unsafe fn get_main_state(state: *mut ffi::lua_State) -> Option<*mut ffi::lua
            None
        }
    }
+    #[cfg(feature = "luau")]
+    Some(ffi::lua_mainthread(state))
 }

 // Initialize the internal (with __gc method) metatable for a type T.
@@ -647,21 +758,13 @@ pub unsafe fn init_gc_metatable<T: Any>(
 ) -> Result<()> {
    check_stack(state, 6)?;

-    let type_id = TypeId::of::<T>();
-    let ref_addr = {
-        let mut mt_cache = mlua_expect!(METATABLE_CACHE.lock(), "cannot lock metatable cache");
-        mlua_assert!(
-            mt_cache.capacity() - mt_cache.len() > 0,
-            "out of metatable cache capacity"
-        );
-        mt_cache.insert(type_id, 0);
-        &mt_cache[&type_id] as *const u8
-    };
-
    push_table(state, 0, 3)?;

-    ffi::lua_pushcfunction(state, userdata_destructor::<T>);
-    rawset_field(state, -2, "__gc")?;
+    #[cfg(not(feature = "luau"))]
+    {
+        ffi::lua_pushcfunction(state, userdata_destructor::<T>);
+        rawset_field(state, -2, "__gc")?;
+    }

    ffi::lua_pushboolean(state, 0);
    rawset_field(state, -2, "__metatable")?;
@@ -670,8 +773,10 @@ pub unsafe fn init_gc_metatable<T: Any>(
        f(state)?;
    }

-    protect_lua(state, 1, 0, |state| {
-        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, ref_addr as *mut c_void);
+    let type_id = TypeId::of::<T>();
+    let ref_addr = &METATABLE_CACHE[&type_id] as *const u8;
+    protect_lua!(state, 1, 0, |state| {
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, ref_addr as *const c_void);
    })?;

    Ok(())
@@ -679,10 +784,8 @@ pub unsafe fn init_gc_metatable<T: Any>(

 pub unsafe fn get_gc_metatable<T: Any>(state: *mut ffi::lua_State) {
    let type_id = TypeId::of::<T>();
-    let ref_addr = {
-        let mt_cache = mlua_expect!(METATABLE_CACHE.lock(), "cannot lock metatable cache");
-        mlua_expect!(mt_cache.get(&type_id), "gc metatable does not exist") as *const u8
-    };
+    let ref_addr =
+        mlua_expect!(METATABLE_CACHE.get(&type_id), "gc metatable does not exist") as *const u8;
    ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, ref_addr as *const c_void);
 }

@@ -708,32 +811,6 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
                    // be possible to make this consume arbitrary amounts of memory (for example, some
                    // kind of recursive error structure?)
                    let _ = write!(&mut (*err_buf), "{}", error);
-                    // Find first two sources that caused the error
-                    let mut source1 = error.source();
-                    let mut source0 = source1.and_then(|s| s.source());
-                    while let Some(source) = source0.and_then(|s| s.source()) {
-                        source1 = source0;
-                        source0 = Some(source);
-                    }
-                    match (source1, source0) {
-                        (_, Some(error0))
-                            if error0.to_string().contains("\nstack traceback:\n") =>
-                        {
-                            let _ = write!(&mut (*err_buf), "\ncaused by: {}", error0);
-                        }
-                        (Some(error1), Some(error0)) => {
-                            let _ = write!(&mut (*err_buf), "\ncaused by: {}", error0);
-                            let s = error1.to_string();
-                            if let Some(traceback) = s.splitn(2, "\nstack traceback:\n").nth(1) {
-                                let _ =
-                                    write!(&mut (*err_buf), "\nstack traceback:\n{}", traceback);
-                            }
-                        }
-                        (Some(error1), None) => {
-                            let _ = write!(&mut (*err_buf), "\ncaused by: {}", error1);
-                        }
-                        _ => {}
-                    }
                    Ok(err_buf)
                }
                Some(WrappedFailure::Panic(Some(ref panic))) => {
@@ -813,9 +890,14 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
        "__newindex",
        "__call",
        "__tostring",
-        #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+        #[cfg(any(
+            feature = "lua54",
+            feature = "lua53",
+            feature = "lua52",
+            feature = "luajit52"
+        ))]
        "__pairs",
-        #[cfg(any(feature = "lua53", feature = "lua52"))]
+        #[cfg(any(feature = "lua53", feature = "lua52", feature = "luajit52"))]
        "__ipairs",
        #[cfg(feature = "lua54")]
        "__close",
@@ -825,7 +907,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
    }
    ffi::lua_pop(state, 1);

-    protect_lua(state, 1, 0, |state| {
+    protect_lua!(state, 1, 0, fn(state) {
        let destructed_mt_key = &DESTRUCTED_USERDATA_METATABLE as *const u8 as *const c_void;
        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, destructed_mt_key);
    })?;
@@ -833,7 +915,7 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
    // Create error print buffer
    init_gc_metatable::<String>(state, None)?;
    push_gc_userdata(state, String::new())?;
-    protect_lua(state, 1, 0, |state| {
+    protect_lua!(state, 1, 0, fn(state) {
        let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
    })?;
@@ -842,10 +924,28 @@ pub unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
 }

 pub(crate) enum WrappedFailure {
+    None,
    Error(Error),
    Panic(Option<Box<dyn Any + Send + 'static>>),
 }

+impl WrappedFailure {
+    pub(crate) unsafe fn new_userdata(state: *mut ffi::lua_State) -> *mut Self {
+        let size = mem::size_of::<WrappedFailure>();
+        #[cfg(feature = "luau")]
+        let ud = {
+            unsafe extern "C" fn destructor(p: *mut c_void) {
+                ptr::drop_in_place(p as *mut WrappedFailure);
+            }
+            ffi::lua_newuserdatadtor(state, size, destructor) as *mut Self
+        };
+        #[cfg(not(feature = "luau"))]
+        let ud = ffi::lua_newuserdata(state, size) as *mut Self;
+        ptr::write(ud, WrappedFailure::None);
+        ud
+    }
+}
+
 // Converts the given lua value to a string in a reasonable format without causing a Lua error or
 // panicking.
 pub(crate) unsafe fn to_string(state: *mut ffi::lua_State, index: c_int) -> String {
@@ -865,6 +965,13 @@ pub(crate) unsafe fn to_string(state: *mut ffi::lua_State, index: c_int) -> Stri
                i.to_string()
            }
        }
+        #[cfg(feature = "luau")]
+        ffi::LUA_TVECTOR => {
+            let v = ffi::lua_tovector(state, index);
+            mlua_debug_assert!(!v.is_null(), "vector is null");
+            let (x, y, z) = (*v, *v.add(1), *v.add(2));
+            format!("vector({},{},{})", x, y, z)
+        }
        ffi::LUA_TSTRING => {
            let mut size = 0;
            // This will not trigger a 'm' error, because the reference is guaranteed to be of
@@ -887,3 +994,5 @@ pub(crate) unsafe fn get_destructed_userdata_metatable(state: *mut ffi::lua_Stat

 static DESTRUCTED_USERDATA_METATABLE: u8 = 0;
 static ERROR_PRINT_BUFFER_KEY: u8 = 0;
+static USERDATA_METATABLE_INDEX: u8 = 0;
+static USERDATA_METATABLE_NEWINDEX: u8 = 0;
@@ -4,6 +4,7 @@ use std::{slice, str, vec};
 #[cfg(feature = "serialize")]
 use {
    serde::ser::{self, Serialize, Serializer},
+    std::convert::TryInto,
    std::result::Result as StdResult,
 };

@@ -33,6 +34,10 @@ pub enum Value<'lua> {
    Integer(Integer),
    /// A floating point number.
    Number(Number),
+    /// A Luau vector.
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    Vector(f32, f32, f32),
    /// An interned string, managed by Lua.
    ///
    /// Unlike Rust strings, Lua strings may not be valid UTF-8.
@@ -49,16 +54,19 @@ pub enum Value<'lua> {
    /// `Error` is a special builtin userdata type. When received from Lua it is implicitly cloned.
    Error(Error),
 }
+
 pub use self::Value::Nil;

 impl<'lua> Value<'lua> {
-    pub fn type_name(&self) -> &'static str {
+    pub const fn type_name(&self) -> &'static str {
        match *self {
            Value::Nil => "nil",
            Value::Boolean(_) => "boolean",
            Value::LightUserData(_) => "lightuserdata",
            Value::Integer(_) => "integer",
            Value::Number(_) => "number",
+            #[cfg(feature = "luau")]
+            Value::Vector(_, _, _) => "vector",
            Value::String(_) => "string",
            Value::Table(_) => "table",
            Value::Function(_) => "function",
@@ -97,6 +105,8 @@ impl<'lua> PartialEq for Value<'lua> {
            (Value::Integer(a), Value::Number(b)) => *a as Number == *b,
            (Value::Number(a), Value::Integer(b)) => *a == *b as Number,
            (Value::Number(a), Value::Number(b)) => *a == *b,
+            #[cfg(feature = "luau")]
+            (Value::Vector(x1, y1, z1), Value::Vector(x2, y2, z2)) => (x1, y1, z1) == (x2, y2, z2),
            (Value::String(a), Value::String(b)) => a == b,
            (Value::Table(a), Value::Table(b)) => a == b,
            (Value::Function(a), Value::Function(b)) => a == b,
@@ -124,9 +134,12 @@ impl<'lua> Serialize for Value<'lua> {
            Value::Nil => serializer.serialize_unit(),
            Value::Boolean(b) => serializer.serialize_bool(*b),
            #[allow(clippy::useless_conversion)]
-            Value::Integer(i) => serializer.serialize_i64((*i).into()),
+            Value::Integer(i) => serializer
+                .serialize_i64((*i).try_into().expect("cannot convert lua_Integer to i64")),
            #[allow(clippy::useless_conversion)]
-            Value::Number(n) => serializer.serialize_f64((*n).into()),
+            Value::Number(n) => serializer.serialize_f64(*n),
+            #[cfg(feature = "luau")]
+            Value::Vector(x, y, z) => (x, y, z).serialize(serializer),
            Value::String(s) => s.serialize(serializer),
            Value::Table(t) => t.serialize(serializer),
            Value::UserData(ud) => ud.serialize(serializer),
@@ -157,18 +170,27 @@ pub struct MultiValue<'lua>(Vec<Value<'lua>>);

 impl<'lua> MultiValue<'lua> {
    /// Creates an empty `MultiValue` containing no values.
+    #[inline]
    pub fn new() -> MultiValue<'lua> {
        MultiValue(Vec::new())
    }
+
+    /// Similar to `new` but can return previously used container with allocated capacity.
+    #[inline]
+    pub(crate) fn new_or_cached(lua: &'lua Lua) -> MultiValue<'lua> {
+        lua.new_or_cached_multivalue()
+    }
 }

 impl<'lua> Default for MultiValue<'lua> {
+    #[inline]
    fn default() -> MultiValue<'lua> {
        MultiValue::new()
    }
 }

 impl<'lua> FromIterator<Value<'lua>> for MultiValue<'lua> {
+    #[inline]
    fn from_iter<I: IntoIterator<Item = Value<'lua>>>(iter: I) -> Self {
        MultiValue::from_vec(Vec::from_iter(iter))
    }
@@ -178,6 +200,7 @@ impl<'lua> IntoIterator for MultiValue<'lua> {
    type Item = Value<'lua>;
    type IntoIter = iter::Rev<vec::IntoIter<Value<'lua>>>;

+    #[inline]
    fn into_iter(self) -> Self::IntoIter {
        self.0.into_iter().rev()
    }
@@ -187,46 +210,78 @@ impl<'a, 'lua> IntoIterator for &'a MultiValue<'lua> {
    type Item = &'a Value<'lua>;
    type IntoIter = iter::Rev<slice::Iter<'a, Value<'lua>>>;

+    #[inline]
    fn into_iter(self) -> Self::IntoIter {
        (&self.0).iter().rev()
    }
 }

 impl<'lua> MultiValue<'lua> {
+    #[inline]
    pub fn from_vec(mut v: Vec<Value<'lua>>) -> MultiValue<'lua> {
        v.reverse();
        MultiValue(v)
    }

+    #[inline]
    pub fn into_vec(self) -> Vec<Value<'lua>> {
        let mut v = self.0;
        v.reverse();
        v
    }

+    #[inline]
    pub(crate) fn reserve(&mut self, size: usize) {
        self.0.reserve(size);
    }

+    #[inline]
    pub(crate) fn push_front(&mut self, value: Value<'lua>) {
        self.0.push(value);
    }

+    #[inline]
    pub(crate) fn pop_front(&mut self) -> Option<Value<'lua>> {
        self.0.pop()
    }

+    #[inline]
+    pub fn clear(&mut self) {
+        self.0.clear();
+    }
+
+    #[inline]
    pub fn len(&self) -> usize {
        self.0.len()
    }

+    #[inline]
    pub fn is_empty(&self) -> bool {
-        self.0.len() == 0
+        self.0.is_empty()
    }

+    #[inline]
    pub fn iter(&self) -> iter::Rev<slice::Iter<Value<'lua>>> {
        self.0.iter().rev()
    }
+
+    #[inline]
+    pub(crate) fn drain_all(&mut self) -> iter::Rev<vec::Drain<Value<'lua>>> {
+        self.0.drain(..).rev()
+    }
+
+    #[inline]
+    pub(crate) fn refill(
+        &mut self,
+        iter: impl IntoIterator<Item = Result<Value<'lua>>>,
+    ) -> Result<()> {
+        self.0.clear();
+        for value in iter {
+            self.0.push(value?);
+        }
+        self.0.reverse();
+        Ok(())
+    }
 }

 /// Trait for types convertible to any number of Lua values.
@@ -3,7 +3,7 @@
 use std::cell::Cell;
 use std::rc::Rc;
 use std::sync::{
-    atomic::{AtomicI64, Ordering},
+    atomic::{AtomicI64, AtomicU64, Ordering},
    Arc,
 };
 use std::time::Duration;
@@ -12,7 +12,8 @@ use futures_timer::Delay;
 use futures_util::stream::TryStreamExt;

 use mlua::{
-    Error, Function, Lua, Result, Table, TableExt, Thread, UserData, UserDataMethods, Value,
+    Error, Function, Lua, LuaOptions, Result, StdLib, Table, TableExt, Thread, UserData,
+    UserDataMethods, Value,
 };

 #[tokio::test]
@@ -227,7 +228,8 @@ async fn test_async_thread() -> Result<()> {

 #[tokio::test]
 async fn test_async_table() -> Result<()> {
-    let lua = Lua::new();
+    let options = LuaOptions::new().thread_cache_size(4);
+    let lua = Lua::new_with(StdLib::ALL_SAFE, options)?;

    let table = lua.create_table()?;
    table.set("val", 10)?;
@@ -276,7 +278,7 @@ async fn test_async_table() -> Result<()> {
 #[tokio::test]
 async fn test_async_userdata() -> Result<()> {
    #[derive(Clone)]
-    struct MyUserData(Arc<AtomicI64>);
+    struct MyUserData(Arc<AtomicU64>);

    impl UserData for MyUserData {
        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
@@ -295,13 +297,46 @@ async fn test_async_userdata() -> Result<()> {
                Delay::new(Duration::from_millis(n)).await;
                Ok(format!("elapsed:{}ms", n))
            });
+
+            #[cfg(not(any(feature = "lua51", feature = "luau")))]
+            methods.add_async_meta_method(mlua::MetaMethod::Call, |_, data, ()| async move {
+                let n = data.0.load(Ordering::Relaxed);
+                Delay::new(Duration::from_millis(n)).await;
+                Ok(format!("elapsed:{}ms", n))
+            });
+
+            #[cfg(not(any(feature = "lua51", feature = "luau")))]
+            methods.add_async_meta_method(
+                mlua::MetaMethod::Index,
+                |_, data, key: String| async move {
+                    Delay::new(Duration::from_millis(10)).await;
+                    match key.as_str() {
+                        "ms" => Ok(Some(data.0.load(Ordering::Relaxed) as f64)),
+                        "s" => Ok(Some((data.0.load(Ordering::Relaxed) as f64) / 1000.0)),
+                        _ => Ok(None),
+                    }
+                },
+            );
+
+            #[cfg(not(any(feature = "lua51", feature = "luau")))]
+            methods.add_async_meta_method(
+                mlua::MetaMethod::NewIndex,
+                |_, data, (key, value): (String, f64)| async move {
+                    Delay::new(Duration::from_millis(10)).await;
+                    match key.as_str() {
+                        "ms" => Ok(data.0.store(value as u64, Ordering::Relaxed)),
+                        "s" => Ok(data.0.store((value * 1000.0) as u64, Ordering::Relaxed)),
+                        _ => Err(Error::external(format!("key '{}' not found", key))),
+                    }
+                },
+            );
        }
    }

    let lua = Lua::new();
    let globals = lua.globals();

-    let userdata = lua.create_userdata(MyUserData(Arc::new(AtomicI64::new(11))))?;
+    let userdata = lua.create_userdata(MyUserData(Arc::new(AtomicU64::new(11))))?;
    globals.set("userdata", userdata.clone())?;

    lua.load(
@@ -315,6 +350,22 @@ async fn test_async_userdata() -> Result<()> {
    .exec_async()
    .await?;

+    #[cfg(not(any(feature = "lua51", feature = "luau")))]
+    lua.load(
+        r#"
+        userdata:set_value(15)
+        assert(userdata() == "elapsed:15ms")
+
+        userdata.ms = 2000
+        assert(userdata.s == 2)
+
+        userdata.s = 15
+        assert(userdata.ms == 15000)
+    "#,
+    )
+    .exec_async()
+    .await?;
+
    Ok(())
 }

@@ -1,13 +1,13 @@
 error[E0373]: closure may outlive the current function, but it borrows `test`, which is owned by the current function
-  --> $DIR/function_borrow.rs:9:33
+  --> tests/compile/function_borrow.rs:9:33
   |
 9  |     let _ = lua.create_function(|_, ()| -> Result<i32> {
   |                                 ^^^^^^^^^^^^^^^^^^^^^^ may outlive borrowed value `test`
 10 |         Ok(test.0)
-   |            ---- `test` is borrowed here
+   |            ------ `test` is borrowed here
   |
 note: function requires argument type to outlive `'static`
-  --> $DIR/function_borrow.rs:9:13
+  --> tests/compile/function_borrow.rs:9:13
   |
 9  |       let _ = lua.create_function(|_, ()| -> Result<i32> {
   |  _____________^
@@ -17,4 +17,4 @@ note: function requires argument type to outlive `'static`
 help: to force the closure to take ownership of `test` (and any other referenced variables), use the `move` keyword
   |
 9  |     let _ = lua.create_function(move |_, ()| -> Result<i32> {
-   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                 ++++
@@ -1,63 +1,35 @@
 error[E0277]: the type `UnsafeCell<()>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-   --> $DIR/lua_norefunwindsafe.rs:7:5
+   --> tests/compile/lua_norefunwindsafe.rs:7:5
    |
 7   |     catch_unwind(|| lua.create_table().unwrap());
    |     ^^^^^^^^^^^^ `UnsafeCell<()>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
    |
-   ::: $RUST/std/src/panic.rs
-    |
-    | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
-    |                                        ---------- required by this bound in `catch_unwind`
-    |
    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<()>`
    = note: required because it appears within the type `PhantomData<UnsafeCell<()>>`
    = note: required because it appears within the type `Lua`
    = note: required because of the requirements on the impl of `UnwindSafe` for `&Lua`
    = note: required because it appears within the type `[closure@$DIR/tests/compile/lua_norefunwindsafe.rs:7:18: 7:48]`
-
-error[E0277]: the type `UnsafeCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-   --> $DIR/lua_norefunwindsafe.rs:7:5
-    |
-7   |     catch_unwind(|| lua.create_table().unwrap());
-    |     ^^^^^^^^^^^^ `UnsafeCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-    |
-   ::: $RUST/std/src/panic.rs
+note: required by a bound in `catch_unwind`
+   --> $RUST/std/src/panic.rs
    |
    | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
-    |                                        ---------- required by this bound in `catch_unwind`
+    |                                        ^^^^^^^^^^ required by this bound in `catch_unwind`
+
+error[E0277]: the type `UnsafeCell<mlua::lua::ExtraData>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
+   --> tests/compile/lua_norefunwindsafe.rs:7:5
    |
-    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>`
-    = note: required because it appears within the type `RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>`
-    = note: required because it appears within the type `alloc::sync::ArcInner<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>`
-    = note: required because it appears within the type `PhantomData<alloc::sync::ArcInner<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>>`
-    = note: required because it appears within the type `Arc<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>`
-    = note: required because it appears within the type `Option<Arc<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>>`
-    = note: required because it appears within the type `mlua::lua::ExtraData`
-    = note: required because it appears within the type `*mut mlua::lua::ExtraData`
+7   |     catch_unwind(|| lua.create_table().unwrap());
+    |     ^^^^^^^^^^^^ `UnsafeCell<mlua::lua::ExtraData>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
+    |
+    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<mlua::lua::ExtraData>`
+    = note: required because it appears within the type `alloc::sync::ArcInner<UnsafeCell<mlua::lua::ExtraData>>`
+    = note: required because it appears within the type `PhantomData<alloc::sync::ArcInner<UnsafeCell<mlua::lua::ExtraData>>>`
+    = note: required because it appears within the type `Arc<UnsafeCell<mlua::lua::ExtraData>>`
    = note: required because it appears within the type `Lua`
    = note: required because of the requirements on the impl of `UnwindSafe` for `&Lua`
    = note: required because it appears within the type `[closure@$DIR/tests/compile/lua_norefunwindsafe.rs:7:18: 7:48]`
-
-error[E0277]: the type `UnsafeCell<isize>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-   --> $DIR/lua_norefunwindsafe.rs:7:5
-    |
-7   |     catch_unwind(|| lua.create_table().unwrap());
-    |     ^^^^^^^^^^^^ `UnsafeCell<isize>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-    |
-   ::: $RUST/std/src/panic.rs
+note: required by a bound in `catch_unwind`
+   --> $RUST/std/src/panic.rs
    |
    | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
-    |                                        ---------- required by this bound in `catch_unwind`
-    |
-    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<isize>`
-    = note: required because it appears within the type `Cell<isize>`
-    = note: required because it appears within the type `RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>`
-    = note: required because it appears within the type `alloc::sync::ArcInner<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>`
-    = note: required because it appears within the type `PhantomData<alloc::sync::ArcInner<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>>`
-    = note: required because it appears within the type `Arc<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>`
-    = note: required because it appears within the type `Option<Arc<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>>`
-    = note: required because it appears within the type `mlua::lua::ExtraData`
-    = note: required because it appears within the type `*mut mlua::lua::ExtraData`
-    = note: required because it appears within the type `Lua`
-    = note: required because of the requirements on the impl of `UnwindSafe` for `&Lua`
-    = note: required because it appears within the type `[closure@$DIR/tests/compile/lua_norefunwindsafe.rs:7:18: 7:48]`
+    |                                        ^^^^^^^^^^ required by this bound in `catch_unwind`
@@ -1,14 +1,9 @@
 error[E0277]: the type `UnsafeCell<()>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-   --> $DIR/ref_nounwindsafe.rs:8:5
+   --> tests/compile/ref_nounwindsafe.rs:8:5
    |
 8   |     catch_unwind(move || table.set("a", "b").unwrap());
    |     ^^^^^^^^^^^^ `UnsafeCell<()>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
    |
-   ::: $RUST/std/src/panic.rs
-    |
-    | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
-    |                                        ---------- required by this bound in `catch_unwind`
-    |
    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<()>`
    = note: required because it appears within the type `PhantomData<UnsafeCell<()>>`
    = note: required because it appears within the type `Lua`
@@ -16,54 +11,29 @@ error[E0277]: the type `UnsafeCell<()>` may contain interior mutability and a re
    = note: required because it appears within the type `mlua::types::LuaRef<'_>`
    = note: required because it appears within the type `LuaTable<'_>`
    = note: required because it appears within the type `[closure@$DIR/tests/compile/ref_nounwindsafe.rs:8:18: 8:54]`
-
-error[E0277]: the type `UnsafeCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-   --> $DIR/ref_nounwindsafe.rs:8:5
-    |
-8   |     catch_unwind(move || table.set("a", "b").unwrap());
-    |     ^^^^^^^^^^^^ `UnsafeCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-    |
-   ::: $RUST/std/src/panic.rs
+note: required by a bound in `catch_unwind`
+   --> $RUST/std/src/panic.rs
    |
    | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
-    |                                        ---------- required by this bound in `catch_unwind`
+    |                                        ^^^^^^^^^^ required by this bound in `catch_unwind`
+
+error[E0277]: the type `UnsafeCell<mlua::lua::ExtraData>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
+   --> tests/compile/ref_nounwindsafe.rs:8:5
    |
-    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>`
-    = note: required because it appears within the type `RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>`
-    = note: required because it appears within the type `alloc::sync::ArcInner<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>`
-    = note: required because it appears within the type `PhantomData<alloc::sync::ArcInner<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>>`
-    = note: required because it appears within the type `Arc<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>`
-    = note: required because it appears within the type `Option<Arc<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>>`
-    = note: required because it appears within the type `mlua::lua::ExtraData`
-    = note: required because it appears within the type `*mut mlua::lua::ExtraData`
+8   |     catch_unwind(move || table.set("a", "b").unwrap());
+    |     ^^^^^^^^^^^^ `UnsafeCell<mlua::lua::ExtraData>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
+    |
+    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<mlua::lua::ExtraData>`
+    = note: required because it appears within the type `alloc::sync::ArcInner<UnsafeCell<mlua::lua::ExtraData>>`
+    = note: required because it appears within the type `PhantomData<alloc::sync::ArcInner<UnsafeCell<mlua::lua::ExtraData>>>`
+    = note: required because it appears within the type `Arc<UnsafeCell<mlua::lua::ExtraData>>`
    = note: required because it appears within the type `Lua`
    = note: required because of the requirements on the impl of `UnwindSafe` for `&Lua`
    = note: required because it appears within the type `mlua::types::LuaRef<'_>`
    = note: required because it appears within the type `LuaTable<'_>`
    = note: required because it appears within the type `[closure@$DIR/tests/compile/ref_nounwindsafe.rs:8:18: 8:54]`
-
-error[E0277]: the type `UnsafeCell<isize>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-   --> $DIR/ref_nounwindsafe.rs:8:5
-    |
-8   |     catch_unwind(move || table.set("a", "b").unwrap());
-    |     ^^^^^^^^^^^^ `UnsafeCell<isize>` may contain interior mutability and a reference may not be safely transferrable across a catch_unwind boundary
-    |
-   ::: $RUST/std/src/panic.rs
+note: required by a bound in `catch_unwind`
+   --> $RUST/std/src/panic.rs
    |
    | pub fn catch_unwind<F: FnOnce() -> R + UnwindSafe, R>(f: F) -> Result<R> {
-    |                                        ---------- required by this bound in `catch_unwind`
-    |
-    = help: within `Lua`, the trait `RefUnwindSafe` is not implemented for `UnsafeCell<isize>`
-    = note: required because it appears within the type `Cell<isize>`
-    = note: required because it appears within the type `RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>`
-    = note: required because it appears within the type `alloc::sync::ArcInner<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>`
-    = note: required because it appears within the type `PhantomData<alloc::sync::ArcInner<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>>`
-    = note: required because it appears within the type `Arc<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>`
-    = note: required because it appears within the type `Option<Arc<RefCell<(dyn for<'r, 's> FnMut(&'r Lua, mlua::Debug<'s>) -> Result<(), LuaError> + 'static)>>>`
-    = note: required because it appears within the type `mlua::lua::ExtraData`
-    = note: required because it appears within the type `*mut mlua::lua::ExtraData`
-    = note: required because it appears within the type `Lua`
-    = note: required because of the requirements on the impl of `UnwindSafe` for `&Lua`
-    = note: required because it appears within the type `mlua::types::LuaRef<'_>`
-    = note: required because it appears within the type `LuaTable<'_>`
-    = note: required because it appears within the type `[closure@$DIR/tests/compile/ref_nounwindsafe.rs:8:18: 8:54]`
+    |                                        ^^^^^^^^^^ required by this bound in `catch_unwind`
@@ -1,5 +1,5 @@
 error[E0521]: borrowed data escapes outside of closure
-  --> $DIR/scope_callback_inner.rs:7:17
+  --> tests/compile/scope_callback_inner.rs:7:17
   |
 5  |       lua.scope(|scope| {
   |                  -----
@@ -16,7 +16,7 @@ error[E0521]: borrowed data escapes outside of closure
   | |______________^ `scope` escapes the closure body here

 error[E0373]: closure may outlive the current function, but it borrows `inner`, which is owned by the current function
-  --> $DIR/scope_callback_inner.rs:8:34
+  --> tests/compile/scope_callback_inner.rs:8:34
   |
 5  |     lua.scope(|scope| {
   |                ----- has type `&Scope<'_, '2>`
@@ -27,7 +27,7 @@ error[E0373]: closure may outlive the current function, but it borrows `inner`,
   |                 ----- `inner` is borrowed here
   |
 note: function requires argument type to outlive `'2`
-  --> $DIR/scope_callback_inner.rs:7:17
+  --> tests/compile/scope_callback_inner.rs:7:17
   |
 7  |           let f = scope
   |  _________________^
@@ -39,4 +39,4 @@ note: function requires argument type to outlive `'2`
 help: to force the closure to take ownership of `inner` (and any other referenced variables), use the `move` keyword
   |
 8  |             .create_function_mut(move |_, t: Table| {
-   |                                  ^^^^^^^^^^^^^^^^^^
+   |                                  ++++
@@ -1,5 +1,5 @@
 error[E0373]: closure may outlive the current function, but it borrows `test`, which is owned by the current function
-  --> $DIR/scope_invariance.rs:14:38
+  --> tests/compile/scope_invariance.rs:14:38
   |
 9  |     lua.scope(|scope| {
   |                ----- has type `&Scope<'_, '1>`
@@ -7,10 +7,10 @@ error[E0373]: closure may outlive the current function, but it borrows `test`, w
 14 |                 .create_function_mut(|_, ()| {
   |                                      ^^^^^^^ may outlive borrowed value `test`
 15 |                     test.field = 42;
-   |                     ---- `test` is borrowed here
+   |                     ---------- `test` is borrowed here
   |
 note: function requires argument type to outlive `'1`
-  --> $DIR/scope_invariance.rs:13:13
+  --> tests/compile/scope_invariance.rs:13:13
   |
 13 | /             scope
 14 | |                 .create_function_mut(|_, ()| {
@@ -22,4 +22,4 @@ note: function requires argument type to outlive `'1`
 help: to force the closure to take ownership of `test` (and any other referenced variables), use the `move` keyword
   |
 14 |                 .create_function_mut(move |_, ()| {
-   |                                      ^^^^^^^^^^^^
+   |                                      ++++
@@ -3,7 +3,7 @@ use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::ffi::{CStr, CString};

 use maplit::{btreemap, btreeset, hashmap, hashset};
-use mlua::{Lua, Result};
+use mlua::{Error, Lua, Result};

 #[test]
 fn test_conv_vec() -> Result<()> {
@@ -123,3 +123,18 @@ fn test_conv_boxed_slice() -> Result<()> {

    Ok(())
 }
+
+#[test]
+fn test_conv_array() -> Result<()> {
+    let lua = Lua::new();
+
+    let v = [1, 2, 3];
+    lua.globals().set("v", v)?;
+    let v2: [i32; 3] = lua.globals().get("v")?;
+    assert_eq!(v, v2);
+
+    let v2 = lua.globals().get::<_, [i32; 4]>("v");
+    assert!(matches!(v2, Err(Error::FromLuaConversionError { .. })));
+
+    Ok(())
+}
@@ -93,6 +93,7 @@ fn test_c_function() -> Result<()> {
    Ok(())
 }

+#[cfg(not(feature = "luau"))]
 #[test]
 fn test_dump() -> Result<()> {
    let lua = unsafe { Lua::unsafe_new() };
@@ -1,9 +1,24 @@
+#![cfg(not(feature = "luau"))]
+
 use std::cell::RefCell;
 use std::ops::Deref;
 use std::str;
 use std::sync::{Arc, Mutex};

-use mlua::{Error, HookTriggers, Lua, Result, Value};
+use mlua::{DebugEvent, Error, HookTriggers, Lua, Result, Value};
+
+#[test]
+fn test_hook_triggers_bitor() {
+    let trigger = HookTriggers::on_calls()
+        | HookTriggers::on_returns()
+        | HookTriggers::every_line()
+        | HookTriggers::every_nth_instruction(5);
+
+    assert!(trigger.on_calls);
+    assert!(trigger.on_returns);
+    assert!(trigger.every_line);
+    assert_eq!(trigger.every_nth_instruction, Some(5));
+}

 #[test]
 fn test_line_counts() -> Result<()> {
@@ -11,16 +26,11 @@ fn test_line_counts() -> Result<()> {
    let hook_output = output.clone();

    let lua = Lua::new();
-    lua.set_hook(
-        HookTriggers {
-            every_line: true,
-            ..Default::default()
-        },
-        move |_lua, debug| {
-            hook_output.lock().unwrap().push(debug.curr_line());
-            Ok(())
-        },
-    )?;
+    lua.set_hook(HookTriggers::every_line(), move |_lua, debug| {
+        assert_eq!(debug.event(), DebugEvent::Line);
+        hook_output.lock().unwrap().push(debug.curr_line());
+        Ok(())
+    })?;
    lua.load(
        r#"
            local x = 2 + 3
@@ -48,20 +58,15 @@ fn test_function_calls() -> Result<()> {
    let hook_output = output.clone();

    let lua = Lua::new();
-    lua.set_hook(
-        HookTriggers {
-            on_calls: true,
-            ..Default::default()
-        },
-        move |_lua, debug| {
-            let names = debug.names();
-            let source = debug.source();
-            let name = names.name.map(|s| str::from_utf8(s).unwrap().to_owned());
-            let what = source.what.map(|s| str::from_utf8(s).unwrap().to_owned());
-            hook_output.lock().unwrap().push((name, what));
-            Ok(())
-        },
-    )?;
+    lua.set_hook(HookTriggers::on_calls(), move |_lua, debug| {
+        assert_eq!(debug.event(), DebugEvent::Call);
+        let names = debug.names();
+        let source = debug.source();
+        let name = names.name.map(|s| str::from_utf8(s).unwrap().to_owned());
+        let what = source.what.map(|s| str::from_utf8(s).unwrap().to_owned());
+        hook_output.lock().unwrap().push((name, what));
+        Ok(())
+    })?;

    lua.load(
        r#"
@@ -97,17 +102,12 @@ fn test_function_calls() -> Result<()> {
 #[test]
 fn test_error_within_hook() -> Result<()> {
    let lua = Lua::new();
-    lua.set_hook(
-        HookTriggers {
-            every_line: true,
-            ..Default::default()
-        },
-        |_lua, _debug| {
-            Err(Error::RuntimeError(
-                "Something happened in there!".to_string(),
-            ))
-        },
-    )?;
+
+    lua.set_hook(HookTriggers::every_line(), |_lua, _debug| {
+        Err(Error::RuntimeError(
+            "Something happened in there!".to_string(),
+        ))
+    })?;

    let err = lua
        .load("x = 1")
@@ -135,11 +135,9 @@ fn test_limit_execution_instructions() -> Result<()> {
    lua.load("jit.off()").exec()?;

    lua.set_hook(
-        HookTriggers {
-            every_nth_instruction: Some(30),
-            ..Default::default()
-        },
-        move |_lua, _debug| {
+        HookTriggers::every_nth_instruction(30),
+        move |_lua, debug| {
+            assert_eq!(debug.event(), DebugEvent::Count);
            max_instructions -= 30;
            if max_instructions < 0 {
                Err(Error::RuntimeError("time's up".to_string()))
@@ -168,17 +166,11 @@ fn test_limit_execution_instructions() -> Result<()> {
 fn test_hook_removal() -> Result<()> {
    let lua = Lua::new();

-    lua.set_hook(
-        HookTriggers {
-            every_nth_instruction: Some(1),
-            ..Default::default()
-        },
-        |_lua, _debug| {
-            Err(Error::RuntimeError(
-                "this hook should've been removed by this time".to_string(),
-            ))
-        },
-    )?;
+    lua.set_hook(HookTriggers::every_nth_instruction(1), |_lua, _debug| {
+        Err(Error::RuntimeError(
+            "this hook should've been removed by this time".to_string(),
+        ))
+    })?;

    assert!(lua.load("local x = 1").exec().is_err());
    lua.remove_hook();
@@ -198,19 +190,14 @@ fn test_hook_swap_within_hook() -> Result<()> {
    });

    TL_LUA.with(|tl| {
-        tl.borrow().as_ref().unwrap().set_hook(
-            HookTriggers {
-                every_line: true,
-                ..Default::default()
-            },
-            move |lua, _debug| {
+        tl.borrow()
+            .as_ref()
+            .unwrap()
+            .set_hook(HookTriggers::every_line(), move |lua, _debug| {
                lua.globals().set("ok", 1i64)?;
                TL_LUA.with(|tl| {
                    tl.borrow().as_ref().unwrap().set_hook(
-                        HookTriggers {
-                            every_line: true,
-                            ..Default::default()
-                        },
+                        HookTriggers::every_line(),
                        move |lua, _debug| {
                            lua.load(
                                r#"
@@ -228,8 +215,7 @@ fn test_hook_swap_within_hook() -> Result<()> {
                        },
                    )
                })
-            },
-        )
+            })
    })?;

    TL_LUA.with(|tl| {
@@ -0,0 +1,69 @@
+#![cfg(feature = "luau")]
+
+use std::env;
+use std::fs;
+
+use mlua::{Error, Lua, Result, Value};
+
+#[test]
+fn test_require() -> Result<()> {
+    let lua = Lua::new();
+
+    let temp_dir = tempfile::tempdir().unwrap();
+    fs::write(
+        temp_dir.path().join("module.luau"),
+        r#"
+        counter = counter or 0
+        return counter + 1
+    "#,
+    )?;
+
+    env::set_var("LUAU_PATH", temp_dir.path().join("?.luau"));
+    lua.load(
+        r#"
+        local module = require("module")
+        assert(module == 1)
+        module = require("module")
+        assert(module == 1)
+    "#,
+    )
+    .exec()
+}
+
+#[test]
+fn test_vectors() -> Result<()> {
+    let lua = Lua::new();
+
+    let globals = lua.globals();
+    globals.set(
+        "vector",
+        lua.create_function(|_, (x, y, z)| Ok(Value::Vector(x, y, z)))?,
+    )?;
+
+    let v: [f32; 3] = lua
+        .load("return vector(1, 2, 3) + vector(3, 2, 1)")
+        .eval()?;
+    assert_eq!(v, [4.0, 4.0, 4.0]);
+
+    Ok(())
+}
+
+#[test]
+fn test_readonly_table() -> Result<()> {
+    let lua = Lua::new();
+
+    let t = lua.create_table()?;
+    assert!(!t.is_readonly());
+    t.set_readonly(true);
+    assert!(t.is_readonly());
+
+    match t.set("key", "value") {
+        Err(Error::RuntimeError(err)) if err.contains("Attempt to modify a readonly table") => {}
+        r => panic!(
+            "expected RuntimeError(...) with a specific message, got {:?}",
+            r
+        ),
+    };
+
+    Ok(())
+}
@@ -41,7 +41,12 @@ fn test_gc_control() -> Result<()> {
    #[cfg(feature = "lua54")]
    assert_eq!(lua.gc_gen(0, 0), mlua::GCMode::Incremental);

-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luau"
+    ))]
    {
        assert!(lua.gc_is_running());
        lua.gc_stop();
@@ -1,5 +1,8 @@
 [target.x86_64-apple-darwin]
 rustflags = ["-C", "link-args=-rdynamic"]

+[target.aarch64-apple-darwin]
+rustflags = ["-C", "link-args=-rdynamic"]
+
 [target.x86_64-unknown-linux-gnu]
 rustflags = ["-C", "link-args=-rdynamic"]
@@ -2,7 +2,10 @@

 use std::collections::HashMap;

-use mlua::{Error, Lua, LuaSerdeExt, Result as LuaResult, SerializeOptions, UserData, Value};
+use mlua::{
+    DeserializeOptions, Error, Lua, LuaSerdeExt, Result as LuaResult, SerializeOptions, UserData,
+    Value,
+};
 use serde::{Deserialize, Serialize};

 #[test]
@@ -141,6 +144,29 @@ fn test_serialize_failure() -> Result<(), Box<dyn std::error::Error>> {
    Ok(())
 }

+#[cfg(feature = "luau")]
+#[test]
+fn test_serialize_vector() -> Result<(), Box<dyn std::error::Error>> {
+    let lua = Lua::new();
+
+    let globals = lua.globals();
+    globals.set(
+        "vector",
+        lua.create_function(|_, (x, y, z)| Ok(Value::Vector(x, y, z)))?,
+    )?;
+
+    let val = lua.load("{_vector = vector(1, 2, 3)}").eval::<Value>()?;
+    let json = serde_json::json!({
+        "_vector": [1.0, 2.0, 3.0],
+    });
+    assert_eq!(serde_json::to_value(&val)?, json);
+
+    let expected_json = lua.from_value::<serde_json::Value>(val)?;
+    assert_eq!(expected_json, json);
+
+    Ok(())
+}
+
 #[test]
 fn test_to_value_struct() -> LuaResult<()> {
    let lua = Lua::new();
@@ -175,30 +201,6 @@ fn test_to_value_struct() -> LuaResult<()> {
 fn test_to_value_enum() -> LuaResult<()> {
    let lua = Lua::new();
    let globals = lua.globals();
-    globals.set("null", lua.null())?;
-
-    #[derive(Serialize)]
-    struct Test {
-        name: String,
-        key: i64,
-        data: Option<bool>,
-    }
-
-    let test = Test {
-        name: "alex".to_string(),
-        key: -16,
-        data: None,
-    };
-
-    globals.set("value", lua.to_value(&test)?)?;
-    lua.load(
-        r#"
-            assert(value["name"] == "alex")
-            assert(value["key"] == -16)
-            assert(value["data"] == null)
-        "#,
-    )
-    .exec()?;

    #[derive(Serialize)]
    enum E {
@@ -302,6 +304,36 @@ fn test_to_value_with_options() -> Result<(), Box<dyn std::error::Error>> {
    Ok(())
 }

+#[test]
+fn test_from_value_nested_tables() -> Result<(), Box<dyn std::error::Error>> {
+    let lua = Lua::new();
+
+    let value = lua
+        .load(
+            r#"
+            local table_a = {a = "a"}
+            local table_b = {"b"}
+            return {
+                a = table_a,
+                b = {table_b, table_b},
+                ab = {a = table_a, b = table_b}
+            }
+        "#,
+        )
+        .eval::<Value>()?;
+    let got = lua.from_value::<serde_json::Value>(value)?;
+    assert_eq!(
+        got,
+        serde_json::json!({
+            "a": {"a": "a"},
+            "b": [["b"], ["b"]],
+            "ab": {"a": {"a": "a"}, "b": ["b"]},
+        })
+    );
+
+    Ok(())
+}
+
 #[test]
 fn test_from_value_struct() -> Result<(), Box<dyn std::error::Error>> {
    let lua = Lua::new();
@@ -310,7 +342,7 @@ fn test_from_value_struct() -> Result<(), Box<dyn std::error::Error>> {
    struct Test {
        int: u32,
        seq: Vec<String>,
-        map: std::collections::HashMap<i32, i32>,
+        map: HashMap<i32, i32>,
        empty: Vec<()>,
        tuple: (u8, u8, u8),
    }
@@ -413,3 +445,60 @@ fn test_from_value_enum_untagged() -> Result<(), Box<dyn std::error::Error>> {

    Ok(())
 }
+
+#[test]
+fn test_from_value_with_options() -> Result<(), Box<dyn std::error::Error>> {
+    let lua = Lua::new();
+
+    // Deny unsupported types by default
+    let value = Value::Function(lua.create_function(|_, ()| Ok(()))?);
+    match lua.from_value::<Option<String>>(value) {
+        Ok(v) => panic!("expected deserialization error, got {:?}", v),
+        Err(Error::DeserializeError(err)) => {
+            assert!(err.contains("unsupported value type"))
+        }
+        Err(err) => panic!("expected `DeserializeError` error, got {:?}", err),
+    };
+
+    // Allow unsupported types
+    let value = Value::Function(lua.create_function(|_, ()| Ok(()))?);
+    let options = DeserializeOptions::new().deny_unsupported_types(false);
+    assert_eq!(lua.from_value_with::<()>(value, options)?, ());
+
+    // Allow unsupported types (in a table seq)
+    let value = lua.load(r#"{"a", "b", function() end, "c"}"#).eval()?;
+    let options = DeserializeOptions::new().deny_unsupported_types(false);
+    assert_eq!(
+        lua.from_value_with::<Vec<String>>(value, options)?,
+        vec!["a".to_string(), "b".to_string(), "c".to_string()]
+    );
+
+    // Deny recursive tables by default
+    let value = lua.load(r#"local t = {}; t.t = t; return t"#).eval()?;
+    match lua.from_value::<HashMap<String, Option<String>>>(value) {
+        Ok(v) => panic!("expected deserialization error, got {:?}", v),
+        Err(Error::DeserializeError(err)) => {
+            assert!(err.contains("recursive table detected"))
+        }
+        Err(err) => panic!("expected `DeserializeError` error, got {:?}", err),
+    };
+
+    // Check recursion when using `Serialize` impl
+    let t = lua.create_table()?;
+    t.set("t", t.clone())?;
+    assert!(serde_json::to_string(&t).is_err());
+
+    // Serialize Lua globals table
+    #[derive(Debug, Deserialize)]
+    struct Globals {
+        hello: String,
+    }
+    let options = DeserializeOptions::new()
+        .deny_unsupported_types(false)
+        .deny_recursive_tables(false);
+    lua.load(r#"hello = "world""#).exec()?;
+    let globals: Globals = lua.from_value_with(Value::Table(lua.globals()), options)?;
+    assert_eq!(globals.hello, "world");
+
+    Ok(())
+}
@@ -1,4 +1,4 @@
-use mlua::{Lua, Nil, Result, Table, TableExt, Value};
+use mlua::{Error, Lua, Nil, Result, Table, TableExt, Value};

 #[test]
 fn test_set_get() -> Result<()> {
@@ -139,14 +139,6 @@ fn test_table_sequence_from() -> Result<()> {
        vec![1, 2, 3]
    );

-    assert_eq!(
-        get_table
-            .call::<_, Table>(&[1, 2, 3])?
-            .sequence_values()
-            .collect::<Result<Vec<i64>>>()?,
-        vec![1, 2, 3]
-    );
-
    Ok(())
 }

@@ -274,7 +266,12 @@ fn test_table_call() -> Result<()> {

    lua.load(
        r#"
-        table = {a = 1}
+        table = {a = 1, b = 2}
+        setmetatable(table, {
+            __call = function(t, key)
+                return "call_"..t[key]
+            end
+        })

        function table.func(key)
            return "func_"..key
@@ -289,11 +286,19 @@ fn test_table_call() -> Result<()> {

    let table: Table = lua.globals().get("table")?;

+    assert_eq!(table.call::<_, String>("b")?, "call_2");
    assert_eq!(table.call_function::<_, _, String>("func", "a")?, "func_a");
    assert_eq!(
        table.call_method::<_, _, String>("method", "a")?,
        "method_1"
    );

+    // Test calling non-callable table
+    let table2 = lua.create_table()?;
+    assert!(matches!(
+        table2.call::<_, ()>(()),
+        Err(Error::RuntimeError(_))
+    ));
+
    Ok(())
 }
@@ -11,6 +11,7 @@ use mlua::{
    UserData, Value, Variadic,
 };

+#[cfg(not(feature = "luau"))]
 #[test]
 fn test_safety() -> Result<()> {
    let lua = Lua::new();
@@ -46,23 +47,6 @@ fn test_safety() -> Result<()> {
        Err(e) => panic!("expected RuntimeError, got {:?}", e),
        Ok(_) => panic!("expected RuntimeError, got no error"),
    }
-
-    match lua.load("1 + 1").set_mode(ChunkMode::Binary).exec() {
-        Err(Error::SafetyError(msg)) => {
-            assert!(msg.contains("binary chunks are disabled in safe mode"))
-        }
-        Err(e) => panic!("expected SafetyError, got {:?}", e),
-        Ok(_) => panic!("expected SafetyError, got no error"),
-    }
-
-    let bytecode = lua.load("return 1 + 1").into_function()?.dump(true);
-    match lua.load(&bytecode).exec() {
-        Err(Error::SafetyError(msg)) => {
-            assert!(msg.contains("binary chunks are disabled in safe mode"))
-        }
-        Err(e) => panic!("expected SafetyError, got {:?}", e),
-        Ok(_) => panic!("expected SafetyError, got no error"),
-    }
    drop(lua);

    // Test safety rules after dynamically loading `package` library
@@ -120,6 +104,7 @@ fn test_exec() -> Result<()> {
        "#,
        )
        .eval()?;
+    println!("checkpoint");
    assert!(module.contains_key("func")?);
    assert_eq!(
        module.get::<_, Function>("func")?.call::<_, String>(())?,
@@ -166,7 +151,10 @@ fn test_load_mode() -> Result<()> {
        Err(e) => panic!("expected SyntaxError, got {:?}", e),
    };

+    #[cfg(not(feature = "luau"))]
    let bytecode = lua.load("return 1 + 1").into_function()?.dump(true);
+    #[cfg(feature = "luau")]
+    let bytecode = mlua::Compiler::new().compile("return 1 + 1");
    assert_eq!(lua.load(&bytecode).eval::<i32>()?, 2);
    assert_eq!(
        lua.load(&bytecode)
@@ -250,15 +238,7 @@ fn test_error() -> Result<()> {
        }
    }

-    impl error::Error for TestError {
-        fn description(&self) -> &str {
-            "test error"
-        }
-
-        fn cause(&self) -> Option<&dyn error::Error> {
-            None
-        }
-    }
+    impl error::Error for TestError {}

    let lua = Lua::new();

@@ -295,8 +275,8 @@ fn test_error() -> Result<()> {
            end, 3)

            local function handler(err)
-                if string.match(_VERSION, ' 5%.1$') or string.match(_VERSION, ' 5%.2$') then
-                    -- Special case for Lua 5.1/5.2
+                if string.match(_VERSION, ' 5%.1$') or string.match(_VERSION, ' 5%.2$') or _VERSION == "Luau" then
+                    -- Special case for Lua 5.1/5.2 and Luau
                    local caps = string.match(err, ': (%d+)$')
                    if caps then
                        err = caps
@@ -800,6 +780,17 @@ fn test_drop_registry_value() -> Result<()> {
    Ok(())
 }

+#[test]
+fn test_replace_registry_value() -> Result<()> {
+    let lua = Lua::new();
+
+    let key = lua.create_registry_value::<i32>(42)?;
+    lua.replace_registry_value(&key, "new value")?;
+    assert_eq!(lua.registry_value::<String>(&key)?, "new value");
+
+    Ok(())
+}
+
 #[test]
 fn test_lua_registry_hash() -> Result<()> {
    let lua = Lua::new();
@@ -847,6 +838,37 @@ fn test_mismatched_registry_key() -> Result<()> {
    Ok(())
 }

+#[test]
+fn test_application_data() -> Result<()> {
+    let lua = Lua::new();
+
+    lua.set_app_data("test1");
+    lua.set_app_data(vec!["test2"]);
+
+    let f = lua.create_function(|lua, ()| {
+        {
+            let data1 = lua.app_data_ref::<&str>().unwrap();
+            assert_eq!(*data1, "test1");
+        }
+        let mut data2 = lua.app_data_mut::<Vec<&str>>().unwrap();
+        assert_eq!(*data2, vec!["test2"]);
+        data2.push("test3");
+        Ok(())
+    })?;
+    f.call(())?;
+
+    assert_eq!(*lua.app_data_ref::<&str>().unwrap(), "test1");
+    assert_eq!(
+        *lua.app_data_ref::<Vec<&str>>().unwrap(),
+        vec!["test2", "test3"]
+    );
+
+    lua.remove_app_data::<Vec<&str>>();
+    assert!(matches!(lua.app_data_ref::<Vec<&str>>(), None));
+
+    Ok(())
+}
+
 #[test]
 fn test_recursion() -> Result<()> {
    let lua = Lua::new();
@@ -1046,17 +1068,26 @@ fn test_context_thread() -> Result<()> {
        )
        .into_function()?;

-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luajit52"
+    ))]
    f.call::<_, ()>(lua.current_thread())?;

-    #[cfg(any(feature = "lua51", feature = "luajit"))]
+    #[cfg(any(
+        feature = "lua51",
+        all(feature = "luajit", not(feature = "luajit52")),
+        feature = "luau"
+    ))]
    f.call::<_, ()>(Nil)?;

    Ok(())
 }

 #[test]
-#[cfg(any(feature = "lua51", feature = "luajit"))]
+#[cfg(any(feature = "lua51", all(feature = "luajit", not(feature = "luajit52"))))]
 fn test_context_thread_51() -> Result<()> {
    let lua = Lua::new();

@@ -1105,12 +1136,139 @@ fn test_load_from_function() -> Result<()> {
    assert_eq!(t.get::<_, String>("__name")?, "my_module");
    assert_eq!(i.load(Ordering::Relaxed), 1);

-    let _: Value = lua.load_from_function("my_module", func)?;
+    let _: Value = lua.load_from_function("my_module", func.clone())?;
    assert_eq!(i.load(Ordering::Relaxed), 1);

    let func_nil = lua.create_function(move |_, _: String| Ok(Value::Nil))?;
    let v: Value = lua.load_from_function("my_module2", func_nil)?;
    assert_eq!(v, Value::Boolean(true));

+    // Test unloading and loading again
+    lua.unload("my_module")?;
+    let _: Value = lua.load_from_function("my_module", func)?;
+    assert_eq!(i.load(Ordering::Relaxed), 2);
+
+    // Unloading nonexistent module must not fail
+    lua.unload("my_module2")?;
+
    Ok(())
 }
+
+#[test]
+fn test_inspect_stack() -> Result<()> {
+    let lua = Lua::new();
+
+    // Not inside any function
+    assert!(lua.inspect_stack(0).is_none());
+
+    let logline = lua.create_function(|lua, msg: StdString| {
+        let debug = lua.inspect_stack(1).unwrap(); // caller
+        let source = debug.source().short_src.map(core::str::from_utf8);
+        let source = source.transpose().unwrap().unwrap_or("?");
+        let line = debug.curr_line();
+        Ok(format!("{}:{} {}", source, line, msg))
+    })?;
+    lua.globals().set("logline", logline)?;
+
+    lua.load(
+        r#"
+        local function foo()
+            local line = logline("hello")
+            return line
+        end
+        local function bar()
+            return foo()
+        end
+
+        assert(foo() == '[string "chunk"]:3 hello')
+        assert(bar() == '[string "chunk"]:3 hello')
+        assert(logline("world") == '[string "chunk"]:12 world')
+    "#,
+    )
+    .set_name("chunk")?
+    .exec()?;
+
+    Ok(())
+}
+
+#[test]
+fn test_multi_states() -> Result<()> {
+    let lua = Lua::new();
+
+    let f = lua.create_function(|_, g: Option<Function>| {
+        if let Some(g) = g {
+            g.call(())?;
+        }
+        Ok(())
+    })?;
+    lua.globals().set("f", f)?;
+
+    lua.load("f(function() coroutine.wrap(function() f() end)() end)")
+        .exec()?;
+
+    Ok(())
+}
+
+#[test]
+#[cfg(feature = "lua54")]
+fn test_warnings() -> Result<()> {
+    let lua = Lua::new();
+    lua.set_app_data::<Vec<(StdString, bool)>>(Vec::new());
+
+    lua.set_warning_function(|lua, msg, tocont| {
+        let msg = msg.to_string_lossy().to_string();
+        lua.app_data_mut::<Vec<(StdString, bool)>>()
+            .unwrap()
+            .push((msg, tocont));
+        Ok(())
+    });
+
+    lua.warning("native warning ...", true)?;
+    lua.warning("finish", false)?;
+    lua.load(r#"warn("lua warning", "continue")"#).exec()?;
+
+    lua.remove_warning_function();
+    lua.warning("one more warning", false)?;
+
+    let messages = lua.app_data_ref::<Vec<(StdString, bool)>>().unwrap();
+    assert_eq!(
+        *messages,
+        vec![
+            ("native warning ...".to_string(), true),
+            ("finish".to_string(), false),
+            ("lua warning".to_string(), true),
+            ("continue".to_string(), false),
+        ]
+    );
+
+    // Trigger error inside warning
+    lua.set_warning_function(|_, _, _| Err(Error::RuntimeError("warning error".to_string())));
+    assert!(matches!(
+        lua.load(r#"warn("test")"#).exec(),
+        Err(Error::CallbackError { cause, .. })
+            if matches!(*cause, Error::RuntimeError(ref err) if err == "warning error")
+    ));
+
+    Ok(())
+}
+
+#[test]
+#[cfg(feature = "luajit")]
+#[should_panic]
+fn test_luajit_cdata() {
+    let lua = unsafe { Lua::unsafe_new() };
+    let _v: Result<Value> = lua
+        .load(
+            r#"
+        local ffi = require("ffi")
+        ffi.cdef[[
+            void *malloc(size_t size);
+            void free(void *ptr);
+        ]]
+        local ptr = ffi.C.malloc(1)
+        ffi.C.free(ptr)
+        return ptr
+    "#,
+        )
+        .eval();
+}
@@ -94,7 +94,11 @@ fn test_thread() -> Result<()> {
 }

 #[test]
-#[cfg(any(feature = "lua54", all(feature = "luajit", feature = "vendored")))]
+#[cfg(any(
+    feature = "lua54",
+    all(feature = "luajit", feature = "vendored"),
+    feature = "luau",
+))]
 fn test_thread_reset() -> Result<()> {
    use mlua::{AnyUserData, UserData};
    use std::sync::Arc;
@@ -121,16 +125,29 @@ fn test_thread_reset() -> Result<()> {
        assert_eq!(Arc::strong_count(&arc), 1);
    }

-    // Check for errors (Lua 5.4 only)
+    // Check for errors
+    let func: Function = lua.load(r#"function(ud) error("test error") end"#).eval()?;
+    let thread = lua.create_thread(func.clone())?;
+    let _ = thread.resume::<_, AnyUserData>(MyUserData(arc.clone()));
+    assert_eq!(thread.status(), ThreadStatus::Error);
+    assert_eq!(Arc::strong_count(&arc), 2);
    #[cfg(feature = "lua54")]
    {
-        let func: Function = lua.load(r#"function(ud) error("test error") end"#).eval()?;
-        let thread = lua.create_thread(func.clone())?;
-        let _ = thread.resume::<_, AnyUserData>(MyUserData(arc.clone()));
-        assert_eq!(thread.status(), ThreadStatus::Error);
-        assert_eq!(Arc::strong_count(&arc), 2);
        assert!(thread.reset(func.clone()).is_err());
-        assert_eq!(thread.status(), ThreadStatus::Error);
+        // Reset behavior has changed in Lua v5.4.4
+        // It's became possible to force reset thread by popping error object
+        assert!(matches!(
+            thread.status(),
+            ThreadStatus::Unresumable | ThreadStatus::Error
+        ));
+        // Would pass in 5.4.4
+        // assert!(thread.reset(func.clone()).is_ok());
+        // assert_eq!(thread.status(), ThreadStatus::Resumable);
+    }
+    #[cfg(any(feature = "lua54", feature = "luau"))]
+    {
+        assert!(thread.reset(func.clone()).is_ok());
+        assert_eq!(thread.status(), ThreadStatus::Resumable);
    }

    Ok(())
@@ -147,7 +164,8 @@ fn test_coroutine_from_closure() -> Result<()> {
        feature = "lua54",
        feature = "lua53",
        feature = "lua52",
-        feature = "luajit"
+        feature = "luajit",
+        feature = "luau"
    ))]
    let thrd: Thread = lua.load("coroutine.create(main)").eval()?;
    #[cfg(feature = "lua51")]
@@ -36,6 +36,7 @@ fn test_user_data() -> Result<()> {

 #[test]
 fn test_methods() -> Result<()> {
+    #[cfg_attr(feature = "serialize", derive(serde::Serialize))]
    struct MyUserData(i64);

    impl UserData for MyUserData {
@@ -48,29 +49,38 @@ fn test_methods() -> Result<()> {
        }
    }

-    let lua = Lua::new();
-    let globals = lua.globals();
-    let userdata = lua.create_userdata(MyUserData(42))?;
-    globals.set("userdata", userdata.clone())?;
-    lua.load(
-        r#"
-        function get_it()
-            return userdata:get_value()
-        end
+    fn check_methods(lua: &Lua, userdata: AnyUserData) -> Result<()> {
+        let globals = lua.globals();
+        globals.set("userdata", userdata.clone())?;
+        lua.load(
+            r#"
+            function get_it()
+                return userdata:get_value()
+            end

-        function set_it(i)
-            return userdata:set_value(i)
-        end
-    "#,
-    )
-    .exec()?;
-    let get = globals.get::<_, Function>("get_it")?;
-    let set = globals.get::<_, Function>("set_it")?;
-    assert_eq!(get.call::<_, i64>(())?, 42);
-    userdata.borrow_mut::<MyUserData>()?.0 = 64;
-    assert_eq!(get.call::<_, i64>(())?, 64);
-    set.call::<_, ()>(100)?;
-    assert_eq!(get.call::<_, i64>(())?, 100);
+            function set_it(i)
+                return userdata:set_value(i)
+            end
+        "#,
+        )
+        .exec()?;
+        let get = globals.get::<_, Function>("get_it")?;
+        let set = globals.get::<_, Function>("set_it")?;
+        assert_eq!(get.call::<_, i64>(())?, 42);
+        userdata.borrow_mut::<MyUserData>()?.0 = 64;
+        assert_eq!(get.call::<_, i64>(())?, 64);
+        set.call::<_, ()>(100)?;
+        assert_eq!(get.call::<_, i64>(())?, 100);
+        Ok(())
+    }
+
+    let lua = Lua::new();
+
+    check_methods(&lua, lua.create_userdata(MyUserData(42))?)?;
+
+    // Additionally check serializable userdata
+    #[cfg(feature = "serialize")]
+    check_methods(&lua, lua.create_ser_userdata(MyUserData(42))?)?;

    Ok(())
 }
@@ -101,7 +111,12 @@ fn test_metamethods() -> Result<()> {
                    Err("no such custom index".to_lua_err())
                }
            });
-            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            #[cfg(any(
+                feature = "lua54",
+                feature = "lua53",
+                feature = "lua52",
+                feature = "luajit52"
+            ))]
            methods.add_meta_method(MetaMethod::Pairs, |lua, data, ()| {
                use std::iter::FromIterator;
                let stateless_iter = lua.create_function(|_, (data, i): (MyUserData, i64)| {
@@ -126,11 +141,16 @@ fn test_metamethods() -> Result<()> {
        10
    );

-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    let pairs_it = {
-        lua.load(
+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luajit52"
+    ))]
+    let pairs_it = lua
+        .load(
            r#"
-            function pairs_it()
+            function()
                local r = 0
                for i, v in pairs(userdata1) do
                    r = r + v
@@ -139,17 +159,21 @@ fn test_metamethods() -> Result<()> {
            end
        "#,
        )
-        .exec()?;
-        globals.get::<_, Function>("pairs_it")?
-    };
+        .eval::<Function>()?;

    assert_eq!(lua.load("userdata1 - userdata2").eval::<MyUserData>()?.0, 4);
    assert_eq!(lua.load("userdata1:get()").eval::<i64>()?, 7);
    assert_eq!(lua.load("userdata2.inner").eval::<i64>()?, 3);
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    assert_eq!(pairs_it.call::<_, i64>(())?, 28);
    assert!(lua.load("userdata2.nonexist_field").eval::<()>().is_err());

+    #[cfg(any(
+        feature = "lua54",
+        feature = "lua53",
+        feature = "lua52",
+        feature = "luajit52"
+    ))]
+    assert_eq!(pairs_it.call::<_, i64>(())?, 28);
+
    let userdata2: Value = globals.get("userdata2")?;
    let userdata3: Value = globals.get("userdata3")?;

@@ -253,7 +277,80 @@ fn test_gc_userdata() -> Result<()> {
 }

 #[test]
-fn test_destroy_userdata() -> Result<()> {
+fn test_userdata_take() -> Result<()> {
+    #[derive(Debug)]
+    struct MyUserdata(Arc<i64>);
+
+    impl UserData for MyUserdata {
+        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
+            methods.add_method("num", |_, this, ()| Ok(*this.0))
+        }
+    }
+
+    #[cfg(feature = "serialize")]
+    impl serde::Serialize for MyUserdata {
+        fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+        where
+            S: serde::Serializer,
+        {
+            serializer.serialize_i64(*self.0)
+        }
+    }
+
+    fn check_userdata_take(lua: &Lua, userdata: AnyUserData, rc: Arc<i64>) -> Result<()> {
+        lua.globals().set("userdata", userdata.clone())?;
+        assert_eq!(Arc::strong_count(&rc), 3);
+        let userdata_copy = userdata.clone();
+        {
+            let _value = userdata.borrow::<MyUserdata>()?;
+            // We should not be able to take userdata if it's borrowed
+            match userdata_copy.take::<MyUserdata>() {
+                Err(Error::UserDataBorrowMutError) => {}
+                r => panic!("expected `UserDataBorrowMutError` error, got {:?}", r),
+            }
+        }
+
+        let value = userdata_copy.take::<MyUserdata>()?;
+        assert_eq!(*value.0, 18);
+        drop(value);
+        lua.gc_collect()?;
+        assert_eq!(Arc::strong_count(&rc), 1);
+
+        match userdata.borrow::<MyUserdata>() {
+            Err(Error::UserDataDestructed) => {}
+            r => panic!("expected `UserDataDestructed` error, got {:?}", r),
+        }
+        match lua.load("userdata:num()").exec() {
+            Err(Error::CallbackError { ref cause, .. }) => match cause.as_ref() {
+                Error::CallbackDestructed => {}
+                err => panic!("expected `CallbackDestructed`, got {:?}", err),
+            },
+            r => panic!("improper return for destructed userdata: {:?}", r),
+        }
+        Ok(())
+    }
+
+    let lua = Lua::new();
+
+    let rc = Arc::new(18);
+    let userdata = lua.create_userdata(MyUserdata(rc.clone()))?;
+    userdata.set_nth_user_value(2, MyUserdata(rc.clone()))?;
+    check_userdata_take(&lua, userdata, rc)?;
+
+    // Additionally check serializable userdata
+    #[cfg(feature = "serialize")]
+    {
+        let rc = Arc::new(18);
+        let userdata = lua.create_ser_userdata(MyUserdata(rc.clone()))?;
+        userdata.set_nth_user_value(2, MyUserdata(rc.clone()))?;
+        check_userdata_take(&lua, userdata, rc)?;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn test_userdata_destroy() -> Result<()> {
    struct MyUserdata(Arc<()>);

    impl UserData for MyUserdata {}
@@ -261,12 +358,15 @@ fn test_destroy_userdata() -> Result<()> {
    let rc = Arc::new(());

    let lua = Lua::new();
-    lua.globals().set("userdata", MyUserdata(rc.clone()))?;
+    let ud = lua.create_userdata(MyUserdata(rc.clone()))?;
+    ud.set_user_value(MyUserdata(rc.clone()))?;
+    lua.globals().set("userdata", ud)?;

-    assert_eq!(Arc::strong_count(&rc), 2);
+    assert_eq!(Arc::strong_count(&rc), 3);

-    // should destroy all objects
-    let _ = lua.globals().raw_remove("userdata")?;
+    // Should destroy all objects
+    lua.globals().raw_remove("userdata")?;
+    lua.gc_collect()?;
    lua.gc_collect()?;

    assert_eq!(Arc::strong_count(&rc), 1);
@@ -275,16 +375,32 @@ fn test_destroy_userdata() -> Result<()> {
 }

 #[test]
-fn test_user_value() -> Result<()> {
+fn test_user_values() -> Result<()> {
    struct MyUserData;

    impl UserData for MyUserData {}

    let lua = Lua::new();
    let ud = lua.create_userdata(MyUserData)?;
-    ud.set_user_value("hello")?;
-    assert_eq!(ud.get_user_value::<String>()?, "hello");
-    assert!(ud.get_user_value::<u32>().is_err());
+
+    ud.set_nth_user_value(1, "hello")?;
+    ud.set_nth_user_value(2, "world")?;
+    ud.set_nth_user_value(65535, 321)?;
+    assert_eq!(ud.get_nth_user_value::<String>(1)?, "hello");
+    assert_eq!(ud.get_nth_user_value::<String>(2)?, "world");
+    assert_eq!(ud.get_nth_user_value::<Value>(3)?, Value::Nil);
+    assert_eq!(ud.get_nth_user_value::<i32>(65535)?, 321);
+
+    assert!(ud.get_nth_user_value::<Value>(0).is_err());
+    assert!(ud.get_nth_user_value::<Value>(65536).is_err());
+
+    // Named user values
+    ud.set_named_user_value("name", "alex")?;
+    ud.set_named_user_value("age", 10)?;
+
+    assert_eq!(ud.get_named_user_value::<_, String>("name")?, "alex");
+    assert_eq!(ud.get_named_user_value::<_, i32>("age")?, 10);
+    assert_eq!(ud.get_named_user_value::<_, Value>("nonexist")?, Value::Nil);

    Ok(())
 }
Author	SHA1	Message	Date
Alex Orlenko	de1cfa070f	v0.8.0-beta.2	2022-03-25 00:44:02 +00:00
Alex Orlenko	ec1fa04085	Update docs	2022-03-25 00:43:54 +00:00
Alex Orlenko	714dd6249f	Enable Thread::reset for Luau	2022-03-23 21:13:48 +00:00
Alex Orlenko	5089dd73c0	Update luau-src to 0.2.1 to fix performance issues related to longjmp	2022-03-23 01:25:34 +00:00
Alex Orlenko	9533f08d3a	Use `lua_xpush` for Luau	2022-03-23 01:24:54 +00:00
Alex Orlenko	0a3b65af88	Support `readonly` table attribute (luau)	2022-03-22 21:33:29 +00:00
Alex Orlenko	3a9c8c2da2	Add Luau vector datatype support	2022-03-22 21:14:06 +00:00
Alex Orlenko	952dae1de5	v0.8.0-beta.1	2022-03-22 01:01:18 +00:00
Alex Orlenko	c88e5f0c4b	Update README	2022-03-22 00:49:50 +00:00
Alex Orlenko	55b778c68b	Fix clippy warnings	2022-03-22 00:47:31 +00:00
Alex Orlenko	c6d3727171	Prepare v0.8.0-beta.1	2022-03-21 01:37:08 +00:00
Alex Orlenko	4e0ba6559e	Add `require` function to Luau	2022-03-21 01:08:48 +00:00
Alex Orlenko	405cff5d49	Move StaticUserData* implementation from `lua` module to the new `userdata_impl`	2022-03-21 01:08:48 +00:00
Alex Orlenko	37cddc6b1c	Replace compat53_countlevels with lua_stackdepth for Luau	2022-03-21 01:08:48 +00:00
Alex Orlenko	2c069f7033	Update to luau 0.519	2022-03-21 01:08:48 +00:00
Alex Orlenko	1e61d1dadc	Return binary chunks support in safe mode. Lua has many ways to load binary bytecode and this restriction was easy to bypass.	2022-03-21 01:08:47 +00:00
Alex Orlenko	32124b31a0	Move chunks structs to a new module. Add Luau Compiler interface to compile sources.	2022-03-21 01:08:47 +00:00
Alex Orlenko	3e5f8e7bb8	Enable `Lua::inspect_stack` for Luau	2022-03-21 01:08:47 +00:00
Alex Orlenko	cab92f4ea2	Update luaL_traceback for Luau	2022-03-21 01:08:47 +00:00
Alex Orlenko	fa99f62a99	Fix __index and __newindex wrappers for Luau	2022-03-21 01:08:40 +00:00
Alex Orlenko	eed7b1f3af	More ffi module refactoring	2022-03-20 20:30:20 +00:00
Alex Orlenko	c322e028e2	Initial Luau support	2022-03-20 20:30:20 +00:00
Alex Orlenko	6dc127f4eb	Refactor ffi module Initial Luau support work	2022-03-20 20:30:18 +00:00
Tarik02	d4f8dce597	Fix async userdata __index, __newindex metamethods	2022-03-20 20:03:47 +00:00
Alex Orlenko	c85616137a	v0.7.4	2022-03-01 19:59:49 +00:00
Alex Orlenko	f52d106a82	Fix "find_dummy" compile error if no lua feature selected	2022-03-01 19:59:42 +00:00
Alex Orlenko	10826a7e67	Update `create_registry_value` doc	2022-02-15 19:45:37 +00:00
Alex Orlenko	18c3255c90	Optimize `Lua::create_registry_value` by reusing previously expired registry keys.	2022-02-14 21:20:57 +00:00
Alex Orlenko	6190427f37	Add Lua::replace_registry_value	2022-02-14 20:51:24 +00:00
Alex Orlenko	9a5a341e44	Recognize LuaJIT TCDATA type to generate correct panic message. Relates to #127 Should be fixed in a next major release by adding support of TCDATA type.	2022-02-12 18:40:18 +00:00
Alex Orlenko	dd91ebfbe5	Grow/check Lua stack in unpack	2022-02-12 17:10:43 +00:00
Alex Orlenko	f9fe869b76	Optimize async calls: Rewrite "unpack" function using C api rather than high level abstraction.	2022-01-29 12:39:30 +00:00
Alex Orlenko	6e4033abba	Fix tests for Lua 5.4.4	2022-01-29 12:36:09 +00:00
Alex Orlenko	c213a85ef0	v0.7.3	2022-01-19 18:12:45 +00:00
Alex Orlenko	4963cc1b8b	Fix cross compilation (bug introduced in `84a174c`)	2022-01-19 17:42:32 +00:00
Alex Orlenko	418e8fba32	v0.7.2	2022-01-17 11:12:46 +00:00
Alex Orlenko	08a7e30820	Update README	2022-01-17 11:11:56 +00:00
Alex Orlenko	19676bda40	Update CHANGELOG	2022-01-16 23:50:26 +00:00
Alex Orlenko	5a06778fbc	Always restore original Lua state after creating Future in async call. Fixes #121	2022-01-16 20:57:43 +00:00
Alex Orlenko	e33bdddc7a	Pass Box wrapped pointer to allocator fn instead of reference	2022-01-08 23:06:01 +00:00
Alex Orlenko	cfb5d3fd45	Fix clippy warnings	2021-12-28 12:23:06 +00:00
Alex Orlenko	84a174c94d	Allow `pkg-config` to omit include paths if they equals to standard. See #114	2021-12-28 12:02:02 +00:00
Alex Orlenko	888b2bbf8d	Refactor `build/find_normal.rs` to include error messages instead of `unwrap()`	2021-12-28 10:26:12 +00:00
Alex Orlenko	386eb7a2b7	v0.7.1	2021-12-23 19:42:52 +00:00
Alex Orlenko	66c9c633b2	Generate traceback from level 0 (instead of 1) Fixes #112	2021-12-23 17:53:20 +00:00
Alex Orlenko	f1e357ce52	Hide (doc) into_static/from_static methods	2021-12-01 00:28:08 +00:00
Alex Orlenko	be09a1fabf	Update lifetimes for few functions in Lua	2021-11-30 23:14:08 +00:00
Alex Orlenko	30af045c6f	Lift minimum Rust requirement to 1.53+	2021-11-29 10:46:09 +00:00
Alex Orlenko	e809640b7e	Update CI (switch to ubuntu-20.04 and add luajit52)	2021-11-27 13:44:30 +00:00
Alex Orlenko	cb3ef20ffc	Update README (remove ref to benchmarks)	2021-11-27 13:44:09 +00:00
Alex Orlenko	3b6564c02a	Update compile tests (messages)	2021-11-27 13:42:22 +00:00
Alex Orlenko	89580dd863	v0.7.0	2021-11-25 18:18:38 +00:00
Alex Orlenko	a0554a56d4	Update dependencies	2021-11-25 18:12:29 +00:00
Alex Orlenko	2fee3e7891	Update docs	2021-11-25 18:01:41 +00:00
Alex Orlenko	9f073ad879	Update README & CHANGELOG	2021-11-25 13:32:13 +00:00
Alex Orlenko	1b74c89509	More performance optimizations	2021-11-25 11:16:12 +00:00
Alex Orlenko	440862de38	Update tests	2021-11-23 19:12:27 +00:00
Alex Orlenko	066d28f5e5	Update `Lua::unload` doc & fix clippy warnings	2021-11-23 19:01:23 +00:00
Alex Orlenko	4528f93345	Merge pull request #103 from polachok/unload Add `Lua::unload()` to unload modules	2021-11-23 18:11:13 +00:00
Alexander Polakov	d49757c7db	Add unload() to remove module	2021-11-23 18:36:57 +03:00
Alex Orlenko	170818c469	Add `call()` function to `TableExt` to call tables with `__call` metamethod as functions	2021-11-21 23:47:45 +00:00
Alex Orlenko	55c8af1e6b	Add minimum Rust requirements to README	2021-11-21 23:42:49 +00:00
Alex Orlenko	e2ebe65306	Add `get_named_user_value` and `set_named_user_value` to `AnyUserData`	2021-11-21 23:42:47 +00:00
Alex Orlenko	f0f5a8a0af	Update CHANGELOG	2021-11-17 23:41:30 +00:00
Alex Orlenko	0e1be19cbb	Move hook_proc under `Lua::set_hook` to use callback_error_ext	2021-11-16 12:27:56 +00:00
Alex Orlenko	0ef709672d	Add set_warning_function/remove_warning_function/warning functions to Lua for 5.4 This utilizes Lua 5.4 warnings system (https://www.lua.org/manual/5.4/manual.html#pdf-warn)	2021-11-16 12:05:34 +00:00
Alex Orlenko	41503b4fb8	Update callback_error_ext (+ fix callback multi states handling)	2021-11-16 11:53:51 +00:00
Alex Orlenko	19bd254e1e	Update comments	2021-11-14 23:27:20 +00:00
Alex Orlenko	50f20e0c2c	Add thread (coroutine) cache to reset and later reuse to execute async functions. It works on Lua 5.4 and LuaJIT (vendored) with `lua_resetthread` function.	2021-11-14 23:19:47 +00:00
Alex Orlenko	7efe807199	Include `StdLib` to prelude	2021-11-14 23:19:47 +00:00
Alex Orlenko	63ea8c7662	Rename wrapped_failures pool to cache	2021-11-14 23:19:47 +00:00
Alex Orlenko	863d36d5a1	Performance optimization: cache and reuse `MultiValue` containers	2021-11-12 15:32:53 +00:00
Alex Orlenko	a8017c10b9	Update callback_error(_ext)	2021-11-12 12:41:03 +00:00
Alex Orlenko	2c7d7117d2	Optimize MultiValue allocations (recycle old container)	2021-11-12 10:55:20 +00:00
Alex Orlenko	6d689c35aa	Update `hook::Debug` struct	2021-11-09 18:20:36 +00:00
Alex Orlenko	8af1304fd0	Add `Lua::inspect_stack` to get information about the interpreter runtime stack. This functionality is provided by `lua_getstack`.	2021-11-09 14:18:14 +00:00
Alex Orlenko	153502ec73	Add `set_nth_user_value` and `get_nth_user_value` to `AnyUserData` with `n` up to 65535 for all Lua versions.	2021-11-08 21:16:31 +00:00
Alex Orlenko	2ea2b1f4fb	Refactor `Error::CallbackError` reporting and include source to fmt::Display implementation. This fixes #71.	2021-11-07 22:53:37 +00:00
Alex Orlenko	ef8c1556e6	Add optional Send to Lua::app_data	2021-11-07 15:03:17 +00:00
Alex Orlenko	b0da2fc439	Switch Table::serialize to FxHashSet	2021-11-07 14:49:19 +00:00
Alex Orlenko	204eedde3c	Merge branch 'dev'	2021-11-07 13:07:22 +00:00
Alex Orlenko	fbc2973aff	Fix recursive tables serialization when using `serde::ser::Serialize` implementation for Table. Fixes #98.	2021-11-06 21:12:00 +00:00
Alex Orlenko	d0641d812f	Refactor a bit conversion int->number	2021-11-04 13:15:26 +00:00
Alex Orlenko	ad70ba54a5	Publish `AnyUserData::take`	2021-11-04 12:32:19 +00:00
Alex Orlenko	806f0bcef4	Add luajit52 support (LuaJIT with partial compatibility with Lua 5.2)	2021-11-04 12:26:11 +00:00
Alex Orlenko	0741db7565	Make (De)SerializeOptions as const	2021-11-04 01:07:38 +00:00
Alex Orlenko	d88a4282c7	Replace macro-based implementation `ToLua` for arrays to const generics	2021-11-04 00:59:39 +00:00
Alex Orlenko	d7d987fa14	Add async meta methods for all Lua except 51	2021-11-04 00:57:49 +00:00
Alex Orlenko	4d3ac6d8c5	Add new "application data" api	2021-10-19 11:45:39 +01:00
Alex Orlenko	a9ca99349c	Switch to FxHash	2021-10-19 11:45:38 +01:00
Alex Orlenko	f71db80a74	Change definition of `lua_State` to opaque struct	2021-10-19 11:45:38 +01:00
Alex Orlenko	09af3e021a	v0.6.6	2021-10-12 12:22:14 +01:00
Alex Orlenko	9e3d495f91	Calculate coverage for Lua 5.4 instead of Lua 5.3	2021-10-12 12:10:04 +01:00
Alex Orlenko	cab2e5a48e	Fix clippy warnings	2021-10-12 12:02:42 +01:00
Alex Orlenko	25a4879cde	Update examples: async_http_client/async_http_server/async_tcp_server Make them following best practices and remove `unsafe` code.	2021-10-12 11:55:25 +01:00
Alex Orlenko	ed48b11e7f	Update documentation references Using rustdoc links (see RFC https://github.com/rust-lang/rfcs/pull/1946)	2021-10-12 00:49:45 +01:00
Alex Orlenko	559f9e6c6b	Add `target.aarch64-apple-darwin` conf to module examples	2021-10-11 18:07:34 +01:00
Alex Orlenko	458b06796c	Fixed LUA_REGISTRYINDEX when generating `glue.rs` on cross-compiling for lua51(jit)	2021-10-08 21:15:22 +01:00
Alex Orlenko	259eb09ae1	v0.6.5	2021-10-05 18:11:32 +01:00
Alex Orlenko	a544e41b33	Add (hidden) method `UserData::take()` to take out value from userdata	2021-10-05 15:46:50 +01:00
Alex Orlenko	235fba821e	Update CHANGELOG	2021-10-04 23:28:24 +01:00
Alex Orlenko	c8c64a1b5a	Add serializing i128/u128 types. Fixes #81.	2021-10-04 23:20:11 +01:00
Alex Orlenko	eff0bbb052	Add `Location::caller()` information to `Lua::load()` if chunk's name is None	2021-10-03 23:20:07 +01:00
Alex Orlenko	d098c9ccf6	Refactor Waker handling in async code. Instead of storing `Option<Waker>` in the Lua registry, store it on the reference thread. It gives approx +10% performance gain when calling async function.	2021-10-03 22:09:19 +01:00
Alex Orlenko	c62b17a5c8	Fixed bug when polling async futures (#77 ) We expect first value returned via coroutine.yield() to be a special Pending type. But instead we checked second value.	2021-10-02 07:23:24 +01:00
Alex Orlenko	584b377640	v0.6.4	2021-09-28 18:53:47 +01:00
Alex Orlenko	1141073a65	Update CHANGELOG	2021-09-28 18:51:42 +01:00
Alex Orlenko	5b1483bd56	Change syntax of `protect_lua` macro	2021-09-28 18:47:08 +01:00
Alex Orlenko	a74b637ed4	Update check_stack requirements	2021-09-28 18:41:25 +01:00
Alex Orlenko	7623016d4a	Fix doc feature labels	2021-09-28 18:15:53 +01:00
Alex Orlenko	bdd3c923ba	Fix table traversal used in recursion detection. This fixes serializing same table multiple times within a parent table.	2021-09-28 16:41:39 +01:00
Alex Orlenko	d586eef0f5	Refactor UserData metatables handling	2021-09-28 16:33:36 +01:00
Alex Orlenko	01154c0616	Minor refacor of wrapped failures cache	2021-09-28 16:27:24 +01:00
Alex Orlenko	e42d67c70d	Make `protect_lua` as a smart macro to choose from C/closure	2021-09-28 16:26:30 +01:00
Alex Orlenko	771a7775c5	Perf optimization: refactor metatable cache	2021-09-28 16:25:08 +01:00
Alex Orlenko	ee1c8a1a3d	Add inline attributes to few hot funcs	2021-09-28 16:19:29 +01:00
Alex Orlenko	3597e34ffb	Fix internal HookCallback type (missing optional Send)	2021-09-28 16:19:12 +01:00
Alex Orlenko	35eedd5a5e	v0.6.3	2021-09-16 00:55:49 +01:00
Alex Orlenko	53f873a482	Update compile tests error messages	2021-09-16 00:49:17 +01:00
Alex Orlenko	fc1fe2c15e	Add `DeserializeOptions` struct to control deserializer behavior. This solves #74 and provides a way to deserialize a Lua globals table.	2021-09-15 23:45:08 +01:00
Alex Orlenko	7e7a44f4cd	Update CHANGELOG	2021-08-22 16:31:14 +01:00
Alex Orlenko	63c4861520	Create FUNDING.yml	2021-08-22 16:22:20 +01:00
Alex Orlenko	27e7facf9b	Fix clippy warnings	2021-08-22 00:35:31 +01:00
Alex Orlenko	31d32f2dda	Wrap `ExtraData` to `Arc<UnsafeCell>>` instead of raw pointer and attach finalizer. This would allow to properly deallocate memory in module mode when closing lua state.	2021-08-21 23:17:09 +01:00
Alex Orlenko	7d1b322e18	Change `ExtraData::mem_info` to `Box<MemoryInfo>`	2021-08-19 01:42:32 +01:00
Alex Orlenko	d906405818	Simplify interface of `hook::HookTriggers`	2021-08-18 18:49:17 +01:00
Alex Orlenko	60fd060d47	Clarify about calling `Lua::init_from_ptr()` multiple times	2021-08-17 15:34:34 +01:00
Alex Orlenko	9f02a9ca09	Add `Debug::event()` to the hook's Debug structure	2021-08-17 15:17:03 +01:00
Alex Orlenko	1d7f105585	Don't catch Rust panics in userdata finalizer on drop	2021-08-06 11:14:16 +01:00
Alex Orlenko	1020315a9b	Update documentation about `FromLua` for UserData. Closes #64	2021-08-04 12:12:02 +01:00