Update CHANGELOG for v0.10.0-beta.1

Update async examples (use send feature)
Mark LightUserData as Send+Sync (send feature flag)
2026-06-08 16:05:43 +00:00 · 2024-07-31 13:42:39 +01:00 · 2024-07-31 13:42:39 +01:00 · 2024-07-31 13:42:39 +01:00 · 2024-07-31 13:42:38 +01:00 · 2024-07-31 13:42:38 +01:00
137 changed files with 16518 additions and 10022 deletions
@@ -14,7 +14,7 @@ jobs:

      - name: Generate coverage report
        run: |
-          cargo tarpaulin --out xml --tests --exclude-files benches/* --exclude-files src/ffi/*/*
+          cargo tarpaulin --out xml --tests --exclude-files benches/* --exclude-files mlua-sys/src/*/*

      - name: Upload report to codecov.io
        uses: codecov/codecov-action@v3
@@ -9,7 +9,7 @@ jobs:
      matrix:
        os: [ubuntu-22.04, macos-latest, windows-latest]
        rust: [stable]
-        lua: [lua54, lua53, lua52, lua51, luajit, luau]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
        include:
          - os: ubuntu-22.04
            target: x86_64-unknown-linux-gnu
@@ -18,7 +18,7 @@ jobs:
          - os: windows-latest
            target: x86_64-pc-windows-msvc
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
        with:
          toolchain: ${{ matrix.rust }}
@@ -27,7 +27,7 @@ jobs:
      - name: Build ${{ matrix.lua }} vendored
        run: |
          cargo build --features "${{ matrix.lua }},vendored"
-          cargo build --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot"
+          cargo build --features "${{ matrix.lua }},vendored,async,send,serialize,macros,unstable"
        shell: bash
      - name: Build ${{ matrix.lua }} pkg-config
        if: ${{ matrix.os == 'ubuntu-22.04' }}
@@ -44,13 +44,13 @@ jobs:
      matrix:
        lua: [lua54, lua53, lua52, lua51, luajit]
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
        with:
          toolchain: stable
          target: aarch64-apple-darwin
      - name: Cross-compile
-        run: cargo build --target aarch64-apple-darwin --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot"
+        run: cargo build --target aarch64-apple-darwin --features "${{ matrix.lua }},vendored,async,send,serialize,macros,unstable"

  build_aarch64_cross_ubuntu:
    name: Cross-compile to aarch64-unknown-linux-gnu
@@ -60,7 +60,7 @@ jobs:
      matrix:
        lua: [lua54, lua53, lua52, lua51, luajit]
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
        with:
          toolchain: stable
@@ -71,7 +71,7 @@ jobs:
          sudo apt-get install -y --no-install-recommends gcc-aarch64-linux-gnu libc6-dev-arm64-cross
        shell: bash
      - name: Cross-compile
-        run: cargo build --target aarch64-unknown-linux-gnu --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot"
+        run: cargo build --target aarch64-unknown-linux-gnu --features "${{ matrix.lua }},vendored,async,send,serialize,macros,unstable"
        shell: bash

  build_armv7_cross_ubuntu:
@@ -82,7 +82,7 @@ jobs:
      matrix:
        lua: [lua54, lua53, lua52, lua51]
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
        with:
          toolchain: stable
@@ -93,7 +93,7 @@ jobs:
          sudo apt-get install -y --no-install-recommends gcc-arm-linux-gnueabihf libc-dev-armhf-cross
        shell: bash
      - name: Cross-compile
-        run: cargo build --target armv7-unknown-linux-gnueabihf --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot"
+        run: cargo build --target armv7-unknown-linux-gnueabihf --features "${{ matrix.lua }},vendored,async,send,serialize,macros,unstable"
        shell: bash

  test:
@@ -104,7 +104,7 @@ jobs:
      matrix:
        os: [ubuntu-22.04, macos-latest, windows-latest]
        rust: [stable, nightly]
-        lua: [lua54, lua53, lua52, lua51, luajit, luajit52, luau]
+        lua: [lua54, lua53, lua52, lua51, luajit, luajit52, luau, luau-jit, luau-vector4]
        include:
          - os: ubuntu-22.04
            target: x86_64-unknown-linux-gnu
@@ -113,22 +113,23 @@ jobs:
          - os: windows-latest
            target: x86_64-pc-windows-msvc
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
        with:
          toolchain: ${{ matrix.rust }}
          target: ${{ matrix.target }}
-      - uses: Swatinem/rust-cache@v1
+      - uses: Swatinem/rust-cache@v2
      - name: Run ${{ matrix.lua }} tests
        run: |
          cargo test --features "${{ matrix.lua }},vendored"
-          cargo test --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot"
+          cargo test --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
+          cargo test --features "${{ matrix.lua }},vendored,async,serialize,macros,unstable"
        shell: bash
      - 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,parking_lot" -- --ignored
+          TRYBUILD=overwrite cargo test --features "${{ matrix.lua }},vendored,async,send,serialize,macros,unstable" -- --ignored
        shell: bash

  test_with_sanitizer:
@@ -139,22 +140,23 @@ jobs:
      matrix:
        os: [ubuntu-22.04]
        rust: [nightly]
-        lua: [lua54, lua53, lua52, lua51, luajit, luau]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
        include:
          - os: ubuntu-22.04
            target: x86_64-unknown-linux-gnu
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
        with:
          toolchain: ${{ matrix.rust }}
          target: ${{ matrix.target }}
-      - uses: Swatinem/rust-cache@v1
+      - uses: Swatinem/rust-cache@v2
      - name: Run ${{ matrix.lua }} tests with address sanitizer
        run: |
-          RUSTFLAGS="-Z sanitizer=address" \
-            cargo test --tests --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
+            cargo test --tests --features "${{ matrix.lua }},vendored,async,send,serialize,macros,unstable" --target x86_64-unknown-linux-gnu -- --skip test_too_many_recursions
        shell: bash
+        env:
+          RUSTFLAGS: -Z sanitizer=address

  test_modules:
    name: Test modules
@@ -164,19 +166,19 @@ jobs:
      matrix:
        os: [ubuntu-22.04, macos-latest]
        rust: [stable]
-        lua: [lua54, lua53, lua52, lua51, luajit]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau]
        include:
          - os: ubuntu-22.04
            target: x86_64-unknown-linux-gnu
          - os: macos-latest
            target: x86_64-apple-darwin
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
        with:
          toolchain: ${{ matrix.rust }}
          target: ${{ matrix.target }}
-      - uses: Swatinem/rust-cache@v1
+      - uses: Swatinem/rust-cache@v2
      - name: Run ${{ matrix.lua }} module tests
        run: |
          (cd tests/module && cargo build --release --features "${{ matrix.lua }}")
@@ -195,7 +197,7 @@ jobs:
        shell: msys2 {0}
    steps:
      - uses: msys2/setup-msys2@v2
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - name: Install Rust & Lua
        run: |
          pacman -S --noconfirm mingw-w64-x86_64-rust mingw-w64-x86_64-lua mingw-w64-x86_64-luajit mingw-w64-x86_64-pkg-config
@@ -204,30 +206,52 @@ jobs:
          (cd tests/module && cargo build --release --features "${{ matrix.lua }}")
          (cd tests/module/loader && cargo test --release --features "${{ matrix.lua }}")

+  test_wasm32_emscripten:
+    name: Test on wasm32-unknown-emscripten
+    runs-on: ubuntu-22.04
+    needs: build
+    strategy:
+      matrix:
+        lua: [lua54, lua53, lua52, lua51, luau]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          toolchain: stable
+          target: wasm32-unknown-emscripten
+      - name: Install Emscripten
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends emscripten
+      - name: Run ${{ matrix.lua }} tests
+        run: |
+          cargo test --tests --features "${{ matrix.lua }},vendored"
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,send,serialize,macros"
+          cargo test --tests --features "${{ matrix.lua }},vendored,async,serialize,macros,unstable"
+
  rustfmt:
    name: Rustfmt
    runs-on: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v3
-      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
        with:
-          toolchain: stable
          components: rustfmt
      - run: cargo fmt -- --check

  clippy:
-    name: Clippy check
+    name: Clippy
    runs-on: ubuntu-22.04
    strategy:
      matrix:
-        lua: [lua54, lua53, lua52, lua51, luajit, luau]
+        lua: [lua54, lua53, lua52, lua51, luajit, luau, luau-jit, luau-vector4]
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@stable
        with:
          toolchain: nightly
          components: clippy
-      - uses: actions-rs/clippy-check@v1
+      - uses: giraffate/clippy-action@v1
        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --features "${{ matrix.lua }},vendored,async,send,serialize,macros,parking_lot"
+          reporter: 'github-pr-review'
+          clippy_flags: --features "${{ matrix.lua }},vendored,async,send,serialize,macros,unstable"
@@ -4,3 +4,4 @@ Cargo.lock

 .vscode/
 .DS_Store
+.stignore
@@ -1,3 +1,178 @@
+## v0.10.0-beta.1
+
+- Dropped `'lua` lifetime (subtypes now store a weak reference to Lua)
+- Removed (experimental) owned types (they no longer needed)
+- Make Lua types truly `Send` and `Sync` (when enabling `send` feature flag)
+- Removed `UserData` impl for Rc/Arc types ("any" userdata functions can be used instead)
+- `Lua::replace_registry_value` takes `&mut RegistryKey`
+- `Lua::scope` temporary disabled (will be re-added in the next release)
+
+## v0.9.9
+
+- Minimal Luau updated to 0.629
+- Fixed bug when attempting to reset or resume already running coroutines (#416).
+- Added `RegistryKey::id()` method to get the underlying Lua registry key id.
+
+## v0.9.8
+
+- Fixed serializing same table multiple times (#408)
+- Use `mlua-sys` v0.6 (to support Luau 0.624+)
+- Fixed cross compilation of windows dlls from unix (#394)
+
+## v0.9.7
+
+- Implemented `IntoLua` for `RegistryKey`
+- Mark `__idiv` metamethod as available for luau
+- Added `Function::deep_clone()` method (Luau)
+- Added `SerializeOptions::detect_serde_json_arbitrary_precision` option
+- Added `Lua::create_buffer()` method (Luau)
+- Support serializing buffer type as a byte slice (Luau)
+- Perf: Implemented `push_into_stack`/`from_stack` for `Option<T>`
+- Added `Lua::create_ser_any_userdata()` method
+
+## v0.9.6
+
+- Added `to_pointer` function to `Function`/`Table`/`Thread`
+- Implemented `IntoLua` for `&Value`
+- Implemented `FromLua` for `RegistryKey`
+- Faster (~5%) table array traversal during serialization
+- Some performance improvements for bool/int types
+
+## v0.9.5
+
+- Minimal Luau updated to 0.609
+- Luau max stack size increased to 1M (from 100K)
+- Implemented `IntoLua` for refs to `String`/`Table`/`Function`/`AnyUserData`/`Thread` + `RegistryKey`
+- Implemented `IntoLua` and `FromLua` for `OwnedThread`/`OwnedString`
+- Fixed `FromLua` derive proc macro to cover more cases
+
+## v0.9.4
+
+- Fixed loading all-in-one modules under mixed states (eg. main state and coroutines)
+
+## v0.9.3
+
+- WebAssembly support (`wasm32-unknown-emscripten` target)
+- Performance improvements (faster Lua function calls for lua51/jit/luau)
+
+## v0.9.2
+
+- Added binary modules support to Luau
+- Added Luau package module (uses `StdLib::PACKAGE`) with loaders (follows lua5.1 interface)
+- Added support of Luau 0.601+ buffer type (represented as userdata in Rust)
+- LuaJIT `cdata` type is also represented as userdata in Rust (instead of panic)
+- Vendored LuaJIT switched to rolling vanilla (from openresty)
+- Added `Table::for_each` method for fast table pairs traversal (faster than `pairs`)
+- Performance improvements around table traversal (and faster serialization)
+- Bug fixes and improvements
+
+## v0.9.1
+
+- impl Default for Lua
+- impl IntoLuaMulti for `std::result::Result<(), E>`
+- Fix using wrong userdata index after processing Variadic args (#311)
+
+## v0.9.0
+
+Changes since v0.9.0-rc.3
+
+- Improved non-static (scoped) userdata support
+- Added `Scope::create_any_userdata()` method
+- Added `Lua::set_vector_metatable()` method (`unstable` feature flag)
+- Added `OwnedThread` type (`unstable` feature flag)
+- Minimal Luau updated to 0.590
+- Added new option `sort_keys` to `DeserializeOptions` (`Lua::from_value()` method)
+- Changed `Table::raw_len()` output type to `usize`
+- Helper functions for `Value` (eg: `Value::as_number()`/`Value::as_string`/etc)
+- Performance improvements
+
+## v0.9.0-rc.3
+
+- Minimal Luau updated to 0.588
+
+## v0.9.0-rc.2
+
+- Added `#[derive(FromLua)]` macro to opt-in into `FromLua<T> where T: 'static + Clone` (userdata type).
+- Support vendored module mode for windows (raw-dylib linking, Rust 1.71+)
+- `module` and `vendored` features are now mutually exclusive
+- Use `C-unwind` ABI (Rust 1.71+)
+- Changed `AsChunk` trait to support capturing wrapped Lua types
+
+## v0.9.0-rc.1
+
+- `UserDataMethods::add_async_method()` takes `&T` instead of cloning `T`
+- Implemented `PartialEq<[T]>` for tables
+- Added Luau 4-dimensional vectors support (`luau-vector4` feature)
+- `Table::sequence_values()` iterator no longer uses any metamethods (`Table::raw_sequence_values()` is deprecated)
+- Added `Table:is_empty()` function that checks both hash and array parts
+- Refactored Debug interface
+- Re-exported `ffi` (`mlua-sys`) crate for easier writing of unsafe code
+- Refactored Lua 5.4 warnings interface
+- Take `&str` as function name in `TableExt` and `AnyUserDataExt` traits
+- Added module attribule `skip_memory_check` to improve performance
+- Added `AnyUserData::wrap()` to provide more easy way of creating _any_ userdata in Lua
+
+## v0.9.0-beta.3
+
+- Added `OwnedAnyUserData::take()`
+- Switch to `DeserializeOwned`
+- Overwrite error context when called multiple times
+- New feature flag `luau-jit` to enable (experimental) Luau codegen backend
+- Set `__name` field in userdata metatable
+- Added `Value::to_string()` method similar to `luaL_tolstring`
+- Lua 5.4.6
+- Application data container now allows to mutably and immutably borrow different types at the same time
+- Performance optimizations
+- Support getting and setting environment for Lua functions.
+- Added `UserDataFields::add_field()` method to add static fields to UserData
+
+Breaking changes:
+- Require environment to be a `Table` instead of `Value` in Chunks.
+- `AsChunk::env()` renamed to `AsChunk::environment()`
+
+## v0.9.0-beta.2
+
+New features:
+- Added `Thread::set_hook()` function to set hook on threads
+- Added pretty print to the Debug formatting to Lua `Value` and `Table`
+- ffi layer moved to `mlua-sys` crate
+- Added OwnedString (unstable)
+
+Breaking changes:
+- Refactor `HookTriggers` (make it const)
+
+## v0.9.0-beta.1
+
+New features:
+- Owned Lua types (unstable feature flag)
+- New functions `Function::wrap`/`Function::wrap_mut`/`Function::wrap_async`
+- `Lua::register_userdata_type()` to register a custom userdata types (without requiring `UserData` trait)
+- `Lua::create_any_userdata()`
+- Added `create_userdata_ref`/`create_userdata_ref_mut` for scopes
+- Added `AnyUserDataExt` trait with auxiliary functions for `AnyUserData`
+- Added `UserDataRef` and `UserDataRefMut` type wrapped that implement `FromLua`
+- Improved error handling:
+  * Improved error reporting when calling Rust functions from Lua.
+  * Added `Error::BadArgument` to help identify bad argument position or name
+  * Added `ErrorContext` extension trait to attach additional context to `Error`
+
+Breaking changes:
+- Refactored `AsChunk` trait
+- `ToLua`/`ToLuaMulti` renamed to `IntoLua`/`IntoLuaMulti`
+- Renamed `to_lua_err` to `into_lua_err`
+- Removed `FromLua` impl for `T: UserData+Clone`
+- Removed `Lua::async_scope`
+- Added `&Lua` arg to Luau interrupt callback
+
+Other:
+- Better Debug for String
+- Allow deserializing values from serializable UserData using `Lua::from_value()` method
+- Added `Table::clear()` method
+- Added `Error::downcast_ref()` method
+- Support setting memory limit for Lua 5.1/JIT/Luau
+- Support setting module name in `#[lua_module(name = "...")]` macro
+- Minor fixes and improvements
+
 ## v0.8.10

 - Update to Luau 0.590 (luau0-src to 0.7.x)
@@ -1,7 +1,8 @@
 [package]
 name = "mlua"
-version = "0.8.10" # remember to update mlua_derive
-authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@chucklefish.org>"]
+version = "0.10.0-beta.1" # remember to update mlua_derive
+authors = ["Aleksandr Orlenko <zxteam@pm.me>", "kyren <catherine@kyju.org>"]
+rust-version = "1.71"
 edition = "2021"
 repository = "https://github.com/khvzak/mlua"
 documentation = "https://docs.rs/mlua"
@@ -9,76 +10,86 @@ readme = "README.md"
 keywords = ["lua", "luajit", "luau", "async", "scripting"]
 categories = ["api-bindings", "asynchronous"]
 license = "MIT"
-links = "lua"
-build = "build/main.rs"
 description = """
 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 = ["lua54", "vendored", "async", "send", "serialize", "macros", "parking_lot"]
+features = ["lua54", "vendored", "async", "send", "serialize", "macros", "unstable"]
 rustdoc-args = ["--cfg", "docsrs"]

 [workspace]
 members = [
    "mlua_derive",
+    "mlua-sys",
 ]

 [features]
-lua54 = []
-lua53 = []
-lua52 = []
-lua51 = []
-luajit = []
-luajit52 = ["luajit"]
-luau = ["luau0-src"]
-vendored = ["lua-src", "luajit-src"]
-module = ["mlua_derive"]
-async = ["futures-core", "futures-task", "futures-util"]
+lua54 = ["ffi/lua54"]
+lua53 = ["ffi/lua53"]
+lua52 = ["ffi/lua52"]
+lua51 = ["ffi/lua51"]
+luajit = ["ffi/luajit"]
+luajit52 = ["luajit", "ffi/luajit52"]
+luau = ["ffi/luau", "dep:libloading"]
+luau-jit = ["luau", "ffi/luau-codegen"]
+luau-vector4 = ["luau", "ffi/luau-vector4"]
+vendored = ["ffi/vendored"]
+module = ["dep:mlua_derive", "ffi/module"]
+async = ["dep:futures-util"]
 send = []
-serialize = ["serde", "erased-serde"]
+serialize = ["dep:serde", "dep:erased-serde", "dep:serde-value"]
 macros = ["mlua_derive/macros"]
+unstable = []

 [dependencies]
-mlua_derive = { version = "=0.8.0", optional = true, path = "mlua_derive" }
-bstr = { version = "0.2", features = ["std"], default_features = false }
-once_cell = { version = "1.0" }
+mlua_derive = { version = "=0.9.3", optional = true, path = "mlua_derive" }
+bstr = { version = "1.0", features = ["std"], default-features = false }
 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 }
+rustc-hash = "2.0"
+futures-util = { version = "0.3", optional = true, default-features = false, features = ["std"] }
 serde = { version = "1.0", optional = true }
-erased-serde = { version = "0.3", optional = true }
-parking_lot = { version = "0.12", optional = true }
+erased-serde = { version = "0.4", optional = true }
+serde-value = { version = "0.7", optional = true }
+parking_lot = { version = "0.12", features = ["arc_lock"] }

-[build-dependencies]
-cc = { version = "1.0" }
-pkg-config = { version = "0.3.17" }
-lua-src = { version = ">= 546.0.0, < 546.1.0", optional = true }
-luajit-src = { version = ">= 210.4.0, < 210.5.0", optional = true }
-luau0-src = { version = "0.7.0", optional = true }
+ffi = { package = "mlua-sys", version = "0.6.1", path = "mlua-sys" }
+
+[target.'cfg(unix)'.dependencies]
+libloading = { version = "0.8", optional = true }

 [dev-dependencies]
-rustyline = "10.0"
-criterion = { version = "0.3.4", features = ["html_reports", "async_tokio"] }
 trybuild = "1.0"
-futures = "0.3.5"
-hyper = { version = "0.14", features = ["client", "server"] }
-reqwest = { version = "0.11", features = ["json"] }
-tokio = { version = "1.0", features = ["full"] }
-futures-timer = "3.0"
+hyper = { version = "1.2", features = ["full"] }
+hyper-util = { version = "0.1.3", features = ["full"] }
+http-body-util = "0.1.1"
+reqwest = { version = "0.12", features = ["json"] }
+tokio = { version = "1.0", features = ["macros", "rt", "time"] }
 serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
+serde_json = { version = "1.0", features = ["arbitrary_precision"] }
 maplit = "1.0"
 tempfile = "3"
+static_assertions = "1.0"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dev-dependencies]
+criterion = { version = "0.5", features = ["async_tokio"] }
+rustyline = "14.0"
+tokio = { version = "1.0", features = ["full"] }
+
+[lints.rust]
+unexpected_cfgs = { level = "allow", check-cfg = ['cfg(tarpaulin_include)'] }

 [[bench]]
 name = "benchmark"
 harness = false
 required-features = ["async"]

+[[bench]]
+name = "serde"
+harness = false
+required-features = ["serialize"]
+
 [[example]]
 name = "async_http_client"
 required-features = ["async", "macros"]
@@ -89,11 +100,11 @@ required-features = ["async", "serialize", "macros"]

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

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

 [[example]]
 name = "guided_tour"
@@ -7,9 +7,9 @@
 [crates.io]: https://crates.io/crates/mlua
 [API Documentation]: https://docs.rs/mlua/badge.svg
 [docs.rs]: https://docs.rs/mlua
-[Coverage Status]: https://codecov.io/gh/khvzak/mlua/branch/v0.8/graph/badge.svg?token=99339FS1CG
-[codecov.io]: https://codecov.io/gh/khvzak/mlua
-[MSRV]: https://img.shields.io/badge/rust-1.56+-brightgreen.svg?&logo=rust
+[Coverage Status]: https://codecov.io/gh/mlua-rs/mlua/branch/main/graph/badge.svg?token=99339FS1CG
+[codecov.io]: https://codecov.io/gh/mlua-rs/mlua
+[MSRV]: https://img.shields.io/badge/rust-1.71+-brightgreen.svg?&logo=rust

 [Guided Tour] | [Benchmarks] | [FAQ]

@@ -17,6 +17,8 @@
 [Benchmarks]: https://github.com/khvzak/script-bench-rs
 [FAQ]: FAQ.md

+# The main branch is the v0.10, development version of `mlua`. Please see the [v0.9](https://github.com/mlua-rs/mlua/tree/v0.9) branch for the stable versions of `mlua`.
+
 `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.

@@ -24,6 +26,8 @@ Started as `rlua` fork, `mlua` supports Lua 5.4, 5.3, 5.2, 5.1 (including LuaJIT

 `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).

+WebAssembly (WASM) is supported through `wasm32-unknown-emscripten` target for all Lua versions excluding JIT.
+
 [GitHub Actions]: https://github.com/khvzak/mlua/actions
 [Roblox Luau]: https://luau-lang.org

@@ -41,6 +45,8 @@ Below is a list of the available feature flags. By default `mlua` does not enabl
 * `luajit`: activate [LuaJIT] support
 * `luajit52`: activate [LuaJIT] support with partial compatibility with Lua 5.2
 * `luau`: activate [Luau] support (auto vendored mode)
+* `luau-jit`: activate [Luau] support with JIT backend.
+* `luau-vector4`: activate [Luau] support with 4-dimensional vector.
 * `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])
@@ -48,6 +54,7 @@ Below is a list of the available feature flags. By default `mlua` does not enabl
 * `serialize`: add serialization and deserialization support to `mlua` types using [serde] framework
 * `macros`: enable procedural macros (such as `chunk!`)
 * `parking_lot`: support UserData types wrapped in [parking_lot]'s primitives (`Arc<Mutex>` and `Arc<RwLock>`)
+* `unstable`: enable **unstable** features. The public API of these features may break between releases.

 [5.4]: https://www.lua.org/manual/5.4/manual.html
 [5.3]: https://www.lua.org/manual/5.3/manual.html
@@ -75,6 +82,20 @@ This works using Lua [coroutines](https://www.lua.org/manual/5.3/manual.html#2.6
 - [HTTP Server](examples/async_http_server.rs)
 - [TCP Server](examples/async_tcp_server.rs)

+
+**shell command examples**:
+```shell
+# async http client (hyper)
+cargo run --example async_http_client --features=lua54,async,macros
+
+# async http client (reqwest)
+cargo run --example async_http_reqwest --features=lua54,async,macros,serialize
+
+# async http server
+cargo run --example async_http_server --features=lua54,async,macros
+curl -v http://localhost:3000
+```
+
 ### Serialization (serde) support

 With `serialize` feature flag enabled, `mlua` allows you to serialize/deserialize any type that implements [`serde::Serialize`] and [`serde::Deserialize`] into/from [`mlua::Value`]. In addition `mlua` provides [`serde::Serialize`] trait implementation for it (including `UserData` support).
@@ -91,12 +112,12 @@ You have to enable one of the features: `lua54`, `lua53`, `lua52`, `lua51`, `lua

 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.
-To achieve this, mlua supports `LUA_INC`, `LUA_LIB`, `LUA_LIB_NAME` and `LUA_LINK` environment variables.
+To achieve this, mlua supports `LUA_LIB`, `LUA_LIB_NAME` and `LUA_LINK` environment variables.
 `LUA_LINK` is optional and may be `dylib` (a dynamic library) or `static` (a static library, `.a` archive).

 An example how to use them:
 ``` sh
-my_project $ LUA_INC=$HOME/tmp/lua-5.2.4/src LUA_LIB=$HOME/tmp/lua-5.2.4/src LUA_LIB_NAME=lua LUA_LINK=static cargo build
+my_project $ LUA_LIB=$HOME/tmp/lua-5.2.4/src LUA_LIB_NAME=lua LUA_LINK=static cargo build
 ```

 `mlua` also supports vendored lua/luajit using the auxiliary crates [lua-src](https://crates.io/crates/lua-src) and
@@ -110,7 +131,7 @@ Add to `Cargo.toml` :

 ``` toml
 [dependencies]
-mlua = { version = "0.8", features = ["lua54", "vendored"] }
+mlua = { version = "0.9.9", features = ["lua54", "vendored"] }
 ```

 `main.rs`
@@ -145,7 +166,7 @@ Add to `Cargo.toml` :
 crate-type = ["cdylib"]

 [dependencies]
-mlua = { version = "0.8", features = ["lua54", "vendored", "module"] }
+mlua = { version = "0.9.9", features = ["lua54", "module"] }
 ```

 `lib.rs` :
@@ -190,20 +211,22 @@ rustflags = [
 ]
 ```
 On Linux you can build modules normally with `cargo build --release`.
-Vendored and non-vendored builds are supported for these OS.

-On Windows `vendored` mode for modules is not supported since you need to link to a Lua dll.
-Easiest way is to use either MinGW64 (as part of [MSYS2](https://github.com/msys2/msys2) package) with `pkg-config` or
-MSVC with `LUA_INC` / `LUA_LIB` / `LUA_LIB_NAME` environment variables.
+On Windows the target module will be linked with `lua5x.dll` library (depending on your feature flags).
+Your main application should provide this library.

-More details about compiling and linking Lua modules can be found on the [Building Modules](http://lua-users.org/wiki/BuildingModules) page.
+Module builds don't require Lua lib or headers to be installed on the system.

 ### Publishing to luarocks.org

 There is a LuaRocks build backend for mlua modules [`luarocks-build-rust-mlua`].

 Modules written in Rust and published to luarocks:
+- [`decasify`](https://github.com/alerque/decasify)
 - [`lua-ryaml`](https://github.com/khvzak/lua-ryaml)
+- [`tiktoken_core`](https://github.com/gptlang/lua-tiktoken)
+- [`toml-edit`](https://github.com/vhyrro/toml-edit.lua)
+- [`typst-lua`](https://github.com/rousbound/typst-lua)

 [`luarocks-build-rust-mlua`]: https://luarocks.org/modules/khvzak/luarocks-build-rust-mlua

@@ -1,5 +1,7 @@
-use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::time::Duration;
+
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 use tokio::runtime::Runtime;
 use tokio::task;

@@ -10,10 +12,10 @@ fn collect_gc_twice(lua: &Lua) {
    lua.gc_collect().unwrap();
 }

-fn create_table(c: &mut Criterion) {
+fn table_create_empty(c: &mut Criterion) {
    let lua = Lua::new();

-    c.bench_function("create [table empty]", |b| {
+    c.bench_function("table [create empty]", |b| {
        b.iter_batched(
            || collect_gc_twice(&lua),
            |_| {
@@ -24,71 +26,55 @@ fn create_table(c: &mut Criterion) {
    });
 }

-fn create_array(c: &mut Criterion) {
+fn table_create_array(c: &mut Criterion) {
    let lua = Lua::new();

-    c.bench_function("create [array] 10", |b| {
+    c.bench_function("table [create array]", |b| {
        b.iter_batched(
            || collect_gc_twice(&lua),
            |_| {
-                let table = lua.create_table().unwrap();
-                for i in 1..=10 {
-                    table.set(i, i).unwrap();
-                }
+                lua.create_sequence_from(1..=10).unwrap();
            },
            BatchSize::SmallInput,
        );
    });
 }

-fn create_string_table(c: &mut Criterion) {
+fn table_create_hash(c: &mut Criterion) {
    let lua = Lua::new();

-    c.bench_function("create [table string] 10", |b| {
+    c.bench_function("table [create hash]", |b| {
        b.iter_batched(
            || collect_gc_twice(&lua),
            |_| {
-                let table = lua.create_table().unwrap();
-                for &s in &["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"] {
-                    let s = lua.create_string(s).unwrap();
-                    table.set(s.clone(), s).unwrap();
-                }
+                lua.create_table_from(
+                    ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"]
+                        .into_iter()
+                        .map(|s| (s, s)),
+                )
+                .unwrap();
            },
            BatchSize::SmallInput,
        );
    });
 }

-fn create_function(c: &mut Criterion) {
+fn table_get_set(c: &mut Criterion) {
    let lua = Lua::new();

-    c.bench_function("create [function] 10", |b| {
+    c.bench_function("table [get and set]", |b| {
        b.iter_batched(
-            || collect_gc_twice(&lua),
-            |_| {
-                for i in 0..10 {
-                    lua.create_function(move |_, ()| Ok(i)).unwrap();
-                }
-            },
-            BatchSize::SmallInput,
-        );
-    });
-}
-
-fn call_lua_function(c: &mut Criterion) {
-    let lua = Lua::new();
-
-    c.bench_function("call Lua function [sum] 3 10", |b| {
-        b.iter_batched_ref(
            || {
                collect_gc_twice(&lua);
-                lua.load("function(a, b, c) return a + b + c end")
-                    .eval::<LuaFunction>()
-                    .unwrap()
+                lua.create_table().unwrap()
            },
-            |function| {
-                for i in 0..10 {
-                    let _result: i64 = function.call((i, i + 1, i + 2)).unwrap();
+            |table| {
+                for (i, s) in ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
+                    .into_iter()
+                    .enumerate()
+                {
+                    table.raw_set(s, i).unwrap();
+                    assert_eq!(table.raw_get::<_, usize>(s).unwrap(), i);
                }
            },
            BatchSize::SmallInput,
@@ -96,197 +82,309 @@ fn call_lua_function(c: &mut Criterion) {
    });
 }

-fn call_sum_callback(c: &mut Criterion) {
+fn table_traversal_pairs(c: &mut Criterion) {
    let lua = Lua::new();
-    let callback = lua
-        .create_function(|_, (a, b, c): (i64, i64, i64)| Ok(a + b + c))
+
+    c.bench_function("table [traversal pairs]", |b| {
+        b.iter_batched(
+            || lua.globals(),
+            |globals| {
+                for kv in globals.pairs::<String, LuaValue>() {
+                    let (_k, _v) = kv.unwrap();
+                }
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn table_traversal_for_each(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    c.bench_function("table [traversal for_each]", |b| {
+        b.iter_batched(
+            || lua.globals(),
+            |globals| globals.for_each::<String, LuaValue>(|_k, _v| Ok(())),
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn table_traversal_sequence(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    let table = lua.create_sequence_from(1..1000).unwrap();
+
+    c.bench_function("table [traversal sequence]", |b| {
+        b.iter_batched(
+            || table.clone(),
+            |table| {
+                for v in table.sequence_values::<i32>() {
+                    let _i = v.unwrap();
+                }
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn function_create(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    c.bench_function("function [create Rust]", |b| {
+        b.iter_batched(
+            || collect_gc_twice(&lua),
+            |_| {
+                lua.create_function(|_, ()| Ok(123)).unwrap();
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn function_call_sum(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    let sum = lua
+        .create_function(|_, (a, b, c): (i64, i64, i64)| Ok(a + b - c))
        .unwrap();
-    lua.globals().set("callback", callback).unwrap();

-    c.bench_function("call Rust callback [sum] 3 10", |b| {
-        b.iter_batched_ref(
-            || {
-                collect_gc_twice(&lua);
-                lua.load("function() for i = 1,10 do callback(i, i+1, i+2) end end")
-                    .eval::<LuaFunction>()
-                    .unwrap()
-            },
-            |function| {
-                function.call::<_, ()>(()).unwrap();
+    c.bench_function("function [call Rust sum]", |b| {
+        b.iter_batched(
+            || collect_gc_twice(&lua),
+            |_| {
+                assert_eq!(sum.call::<_, i64>((10, 20, 30)).unwrap(), 0);
            },
            BatchSize::SmallInput,
        );
    });
 }

-fn call_async_sum_callback(c: &mut Criterion) {
-    let options = LuaOptions::new().thread_cache_size(1024);
+fn function_call_lua_sum(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    let sum = lua
+        .load("function(a, b, c) return a + b - c end")
+        .eval::<LuaFunction>()
+        .unwrap();
+
+    c.bench_function("function [call Lua sum]", |b| {
+        b.iter_batched(
+            || collect_gc_twice(&lua),
+            |_| {
+                assert_eq!(sum.call::<_, i64>((10, 20, 30)).unwrap(), 0);
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn function_call_concat(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    let concat = lua
+        .create_function(|_, (a, b): (LuaString, LuaString)| Ok(format!("{}{}", a.to_str()?, b.to_str()?)))
+        .unwrap();
+    let i = AtomicUsize::new(0);
+
+    c.bench_function("function [call Rust concat string]", |b| {
+        b.iter_batched(
+            || {
+                collect_gc_twice(&lua);
+                i.fetch_add(1, Ordering::Relaxed)
+            },
+            |i| {
+                assert_eq!(
+                    concat.call::<_, LuaString>(("num:", i)).unwrap(),
+                    format!("num:{i}")
+                );
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn function_call_lua_concat(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    let concat = lua
+        .load("function(a, b) return a..b end")
+        .eval::<LuaFunction>()
+        .unwrap();
+    let i = AtomicUsize::new(0);
+
+    c.bench_function("function [call Lua concat string]", |b| {
+        b.iter_batched(
+            || {
+                collect_gc_twice(&lua);
+                i.fetch_add(1, Ordering::Relaxed)
+            },
+            |i| {
+                assert_eq!(
+                    concat.call::<_, LuaString>(("num:", i)).unwrap(),
+                    format!("num:{i}")
+                );
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn function_async_call_sum(c: &mut Criterion) {
+    let options = LuaOptions::new().thread_pool_size(1024);
    let lua = Lua::new_with(LuaStdLib::ALL_SAFE, options).unwrap();
-    let callback = lua
+
+    let sum = lua
        .create_async_function(|_, (a, b, c): (i64, i64, i64)| async move {
            task::yield_now().await;
-            Ok(a + b + c)
+            Ok(a + b - c)
        })
        .unwrap();
-    lua.globals().set("callback", callback).unwrap();

-    c.bench_function("call async Rust callback [sum] 3 10", |b| {
+    c.bench_function("function [async call Rust sum]", |b| {
        let rt = Runtime::new().unwrap();
        b.to_async(rt).iter_batched(
-            || {
-                collect_gc_twice(&lua);
-                lua.load("function() for i = 1,10 do callback(i, i+1, i+2) end end")
-                    .eval::<LuaFunction>()
-                    .unwrap()
-            },
-            |function| async move {
-                function.call_async::<_, ()>(()).await.unwrap();
+            || collect_gc_twice(&lua),
+            |_| async {
+                assert_eq!(sum.call_async::<_, i64>((10, 20, 30)).await.unwrap(), 0);
            },
            BatchSize::SmallInput,
        );
    });
 }

-fn call_concat_callback(c: &mut Criterion) {
+fn registry_value_create(c: &mut Criterion) {
    let lua = Lua::new();
-    let callback = lua
-        .create_function(|_, (a, b): (LuaString, LuaString)| {
-            Ok(format!("{}{}", a.to_str()?, b.to_str()?))
-        })
-        .unwrap();
-    lua.globals().set("callback", callback).unwrap();
+    lua.gc_stop();

-    c.bench_function("call Rust callback [concat string] 10", |b| {
-        b.iter_batched_ref(
-            || {
-                collect_gc_twice(&lua);
-                lua.load("function() for i = 1,10 do callback('a', tostring(i)) end end")
-                    .eval::<LuaFunction>()
-                    .unwrap()
-            },
-            |function| {
-                function.call::<_, ()>(()).unwrap();
-            },
+    c.bench_function("registry value [create]", |b| {
+        b.iter_batched(
+            || collect_gc_twice(&lua),
+            |_| lua.create_registry_value("hello").unwrap(),
            BatchSize::SmallInput,
        );
    });
 }

-fn create_registry_values(c: &mut Criterion) {
+fn registry_value_get(c: &mut Criterion) {
    let lua = Lua::new();
+    lua.gc_stop();

-    c.bench_function("create [registry value] 10", |b| {
+    let value = lua.create_registry_value("hello").unwrap();
+
+    c.bench_function("registry value [get]", |b| {
        b.iter_batched(
            || collect_gc_twice(&lua),
            |_| {
-                for _ in 0..10 {
-                    lua.create_registry_value(lua.pack(true).unwrap()).unwrap();
-                }
-                lua.expire_registry_values();
+                assert_eq!(lua.registry_value::<LuaString>(&value).unwrap(), "hello");
            },
            BatchSize::SmallInput,
        );
    });
 }

-fn create_userdata(c: &mut Criterion) {
-    struct UserData(i64);
+fn userdata_create(c: &mut Criterion) {
+    struct UserData(#[allow(unused)] i64);
    impl LuaUserData for UserData {}

    let lua = Lua::new();

-    c.bench_function("create [table userdata] 10", |b| {
+    c.bench_function("userdata [create]", |b| {
        b.iter_batched(
            || collect_gc_twice(&lua),
            |_| {
-                let table: LuaTable = lua.create_table().unwrap();
-                for i in 1..11 {
-                    table.set(i, UserData(i)).unwrap();
-                }
+                lua.create_userdata(UserData(123)).unwrap();
            },
            BatchSize::SmallInput,
        );
    });
 }

-fn call_userdata_index(c: &mut Criterion) {
-    struct UserData(i64);
+fn userdata_call_index(c: &mut Criterion) {
+    struct UserData(#[allow(unused)] 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));
+        fn add_methods<'a, M: LuaUserDataMethods<'a, Self>>(methods: &mut M) {
+            methods.add_meta_method(LuaMetaMethod::Index, move |_, _, key: LuaString| Ok(key));
        }
    }

    let lua = Lua::new();
-    lua.globals().set("userdata", UserData(10)).unwrap();
+    let ud = lua.create_userdata(UserData(123)).unwrap();
+    let index = lua
+        .load("function(ud) return ud.test end")
+        .eval::<LuaFunction>()
+        .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();
+    c.bench_function("userdata [call index]", |b| {
+        b.iter_batched(
+            || collect_gc_twice(&lua),
+            |_| {
+                assert_eq!(index.call::<_, LuaString>(&ud).unwrap(), "test");
            },
            BatchSize::SmallInput,
        );
    });
 }

-fn call_userdata_method(c: &mut Criterion) {
+fn userdata_call_method(c: &mut Criterion) {
    struct UserData(i64);
    impl LuaUserData for UserData {
-        fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
-            methods.add_method("method", |_, this, ()| Ok(this.0));
+        fn add_methods<'a, M: LuaUserDataMethods<'a, Self>>(methods: &mut M) {
+            methods.add_method("add", |_, this, i: i64| Ok(this.0 + i));
        }
    }

    let lua = Lua::new();
-    lua.globals().set("userdata", UserData(10)).unwrap();
+    let ud = lua.create_userdata(UserData(123)).unwrap();
+    let method = lua
+        .load("function(ud, i) return ud:add(i) end")
+        .eval::<LuaFunction>()
+        .unwrap();
+    let i = AtomicUsize::new(0);

-    c.bench_function("call [userdata method] 10", |b| {
-        b.iter_batched_ref(
+    c.bench_function("userdata [call method]", |b| {
+        b.iter_batched(
            || {
                collect_gc_twice(&lua);
-                lua.load("function() for i = 1,10 do userdata:method() end end")
-                    .eval::<LuaFunction>()
-                    .unwrap()
+                i.fetch_add(1, Ordering::Relaxed)
            },
-            |function| {
-                function.call::<_, ()>(()).unwrap();
+            |i| {
+                assert_eq!(method.call::<_, usize>((&ud, i)).unwrap(), 123 + i);
            },
            BatchSize::SmallInput,
        );
    });
 }

-fn call_async_userdata_method(c: &mut Criterion) {
-    #[derive(Clone, Copy)]
+fn userdata_async_call_method(c: &mut Criterion) {
    struct UserData(i64);
    impl LuaUserData for UserData {
-        fn add_methods<'lua, M: LuaUserDataMethods<'lua, Self>>(methods: &mut M) {
-            methods.add_async_method("method", |_, this, ()| async move { Ok(this.0) });
+        fn add_methods<'a, M: LuaUserDataMethods<'a, Self>>(methods: &mut M) {
+            methods.add_async_method("add", |_, this, i: i64| async move {
+                task::yield_now().await;
+                Ok(this.0 + i)
+            });
        }
    }

-    let options = LuaOptions::new().thread_cache_size(1024);
+    let options = LuaOptions::new().thread_pool_size(1024);
    let lua = Lua::new_with(LuaStdLib::ALL_SAFE, options).unwrap();
-    lua.globals().set("userdata", UserData(10)).unwrap();
+    let ud = lua.create_userdata(UserData(123)).unwrap();
+    let method = lua
+        .load("function(ud, i) return ud:add(i) end")
+        .eval::<LuaFunction>()
+        .unwrap();
+    let i = AtomicUsize::new(0);

-    c.bench_function("call async [userdata method] 10", |b| {
+    c.bench_function("userdata [async call method] 10", |b| {
        let rt = Runtime::new().unwrap();
        b.to_async(rt).iter_batched(
            || {
                collect_gc_twice(&lua);
-                lua.load("function() for i = 1,10 do userdata:method() end end")
-                    .eval::<LuaFunction>()
-                    .unwrap()
+                (method.clone(), ud.clone(), i.fetch_add(1, Ordering::Relaxed))
            },
-            |function| async move {
-                function.call_async::<_, ()>(()).await.unwrap();
+            |(method, ud, i)| async move {
+                assert_eq!(method.call_async::<_, usize>((ud, i)).await.unwrap(), 123 + i);
            },
            BatchSize::SmallInput,
        );
@@ -296,23 +394,32 @@ fn call_async_userdata_method(c: &mut Criterion) {
 criterion_group! {
    name = benches;
    config = Criterion::default()
-        .sample_size(300)
+        .sample_size(500)
        .measurement_time(Duration::from_secs(10))
        .noise_threshold(0.02);
    targets =
-        create_table,
-        create_array,
-        create_string_table,
-        create_function,
-        call_lua_function,
-        call_sum_callback,
-        call_async_sum_callback,
-        call_concat_callback,
-        create_registry_values,
-        create_userdata,
-        call_userdata_index,
-        call_userdata_method,
-        call_async_userdata_method,
+        table_create_empty,
+        table_create_array,
+        table_create_hash,
+        table_get_set,
+        table_traversal_pairs,
+        table_traversal_for_each,
+        table_traversal_sequence,
+
+        function_create,
+        function_call_sum,
+        function_call_lua_sum,
+        function_call_concat,
+        function_call_lua_concat,
+        function_async_call_sum,
+
+        registry_value_create,
+        registry_value_get,
+
+        userdata_create,
+        userdata_call_index,
+        userdata_call_method,
+        userdata_async_call_method,
 }

 criterion_main!(benches);
@@ -0,0 +1,90 @@
+use std::time::Duration;
+
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+
+use mlua::prelude::*;
+
+fn collect_gc_twice(lua: &Lua) {
+    lua.gc_collect().unwrap();
+    lua.gc_collect().unwrap();
+}
+
+fn encode_json(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    let encode = lua
+        .create_function(|_, t: LuaValue| Ok(serde_json::to_string(&t).unwrap()))
+        .unwrap();
+    let table = lua
+        .load(
+            r#"{
+        name = "Clark Kent",
+        address = {
+            city = "Smallville",
+            state = "Kansas",
+            country = "USA",
+        },
+        age = 22,
+        parents = {"Jonathan Kent", "Martha Kent"},
+        superman = true,
+        interests = {"flying", "saving the world", "kryptonite"},
+    }"#,
+        )
+        .eval::<LuaTable>()
+        .unwrap();
+
+    c.bench_function("serialize json", |b| {
+        b.iter_batched(
+            || collect_gc_twice(&lua),
+            |_| {
+                encode.call::<_, LuaString>(&table).unwrap();
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+fn decode_json(c: &mut Criterion) {
+    let lua = Lua::new();
+
+    let decode = lua
+        .create_function(|lua, s: String| {
+            lua.to_value(&serde_json::from_str::<serde_json::Value>(&s).unwrap())
+        })
+        .unwrap();
+    let json = r#"{
+        "name": "Clark Kent",
+        "address": {
+            "city": "Smallville",
+            "state": "Kansas",
+            "country": "USA"
+        },
+        "age": 22,
+        "parents": ["Jonathan Kent", "Martha Kent"],
+        "superman": true,
+        "interests": ["flying", "saving the world", "kryptonite"]
+    }"#;
+
+    c.bench_function("deserialize json", |b| {
+        b.iter_batched(
+            || collect_gc_twice(&lua),
+            |_| {
+                decode.call::<_, LuaTable>(json).unwrap();
+            },
+            BatchSize::SmallInput,
+        );
+    });
+}
+
+criterion_group! {
+    name = benches;
+    config = Criterion::default()
+        .sample_size(500)
+        .measurement_time(Duration::from_secs(10))
+        .noise_threshold(0.02);
+    targets =
+        encode_json,
+        decode_json,
+}
+
+criterion_main!(benches);
@@ -1,5 +0,0 @@
-use std::path::PathBuf;
-
-pub fn probe_lua() -> Option<PathBuf> {
-    None
-}
@@ -1,93 +0,0 @@
-#![allow(dead_code)]
-
-use std::env;
-use std::ops::Bound;
-use std::path::PathBuf;
-
-fn get_env_var(name: &str) -> String {
-    match env::var(name) {
-        Ok(val) => val,
-        Err(env::VarError::NotPresent) => String::new(),
-        Err(err) => panic!("cannot get {}: {}", name, err),
-    }
-}
-
-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");
-
-    println!("cargo:rerun-if-env-changed=LUA_INC");
-    println!("cargo:rerun-if-env-changed=LUA_LIB");
-    println!("cargo:rerun-if-env-changed=LUA_LIB_NAME");
-    println!("cargo:rerun-if-env-changed=LUA_LINK");
-
-    let need_lua_lib = cfg!(any(not(feature = "module"), target_os = "windows"));
-
-    if !include_dir.is_empty() {
-        if need_lua_lib {
-            if lib_dir.is_empty() {
-                panic!("LUA_LIB is not set");
-            }
-            if lua_lib.is_empty() {
-                panic!("LUA_LIB_NAME is not set");
-            }
-
-            let mut link_lib = "";
-            if get_env_var("LUA_LINK") == "static" {
-                link_lib = "static=";
-            };
-            println!("cargo:rustc-link-search=native={}", lib_dir);
-            println!("cargo:rustc-link-lib={}{}", link_lib, lua_lib);
-        }
-        return Some(PathBuf::from(include_dir));
-    }
-
-    // Find using `pkg-config`
-
-    #[cfg(feature = "lua54")]
-    let (incl_bound, excl_bound, alt_probe, ver) = ("5.4", "5.5", "lua5.4", "5.4");
-    #[cfg(feature = "lua53")]
-    let (incl_bound, excl_bound, alt_probe, ver) = ("5.3", "5.4", "lua5.3", "5.3");
-    #[cfg(feature = "lua52")]
-    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(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(alt_probe);
-        }
-
-        lua.unwrap_or_else(|_| panic!("cannot find Lua {} using `pkg-config`", ver))
-            .include_paths
-            .get(0)
-            .cloned()
-    }
-
-    #[cfg(feature = "luajit")]
-    {
-        let lua = pkg_config::Config::new()
-            .range_version((Bound::Included("2.0.4"), Bound::Unbounded))
-            .cargo_metadata(need_lua_lib)
-            .probe("luajit");
-
-        lua.expect("cannot find LuaJIT using `pkg-config`")
-            .include_paths
-            .get(0)
-            .cloned()
-    }
-}
@@ -1,115 +0,0 @@
-#[cfg_attr(
-    any(
-        feature = "luau",
-        all(
-            feature = "vendored",
-            any(
-                feature = "lua54",
-                feature = "lua53",
-                feature = "lua52",
-                feature = "lua51",
-                feature = "luajit"
-            )
-        )
-    ),
-    path = "find_vendored.rs"
-)]
-#[cfg_attr(
-    all(
-        not(feature = "vendored"),
-        any(
-            feature = "lua54",
-            feature = "lua53",
-            feature = "lua52",
-            feature = "lua51",
-            feature = "luajit"
-        )
-    ),
-    path = "find_normal.rs"
-)]
-#[cfg_attr(
-    not(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "lua51",
-        feature = "luajit",
-        feature = "luau"
-    )),
-    path = "find_dummy.rs"
-)]
-mod find;
-
-fn main() {
-    #[cfg(not(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "lua51",
-        feature = "luajit",
-        feature = "luau"
-    )))]
-    compile_error!(
-        "You must enable one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau"
-    );
-
-    #[cfg(all(
-        feature = "lua54",
-        any(
-            feature = "lua53",
-            feature = "lua52",
-            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 = "lua53",
-        any(
-            feature = "lua52",
-            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 = "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", 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"))]
-    compile_error!(
-        "Vendored (static) builds are not supported for modules on Windows.\n"
-            + "Please, use `pkg-config` or custom mode to link to a Lua dll."
-    );
-
-    #[cfg(all(feature = "luau", feature = "module"))]
-    compile_error!("Luau does not support module mode");
-
-    #[cfg(any(not(feature = "module"), target_os = "windows"))]
-    find::probe_lua();
-
-    println!("cargo:rerun-if-changed=build");
-}
@@ -0,0 +1,361 @@
+## mlua v0.9 release notes
+
+The v0.9 version of mlua is a major release that includes a number of API changes and improvements. This release is a stepping stone towards the v1.0.
+This document highlights the most important changes. For a full list of changes, see the [CHANGELOG].
+
+[CHANGELOG]: https://github.com/khvzak/mlua/blob/main/CHANGELOG.md
+
+### New features
+
+#### 1. New Any UserData API
+
+This is a long awaited feature that allows to register in Lua foreign types that cannot implement `UserData` trait because of the Rust orphan rules.
+
+Now you can register any type that implements [`Any`] trait as a userdata type.
+
+Consider the following example:
+
+```rust
+lua.register_userdata_type::<std::string::String>(|reg| {
+    reg.add_method("len", |_, this, ()| Ok(this.len()));
+
+    reg.add_method_mut("push", |_, this, s: String| {
+        this.push_str(&s);
+        Ok(())
+    });
+
+    reg.add_meta_method(MetaMethod::ToString, |lua, this, ()| lua.create_string(this));
+})?;
+
+let s = lua.create_any_userdata("hello".to_string())?;
+lua.load(chunk! {
+    print("s:len() is " .. $s:len())
+    $s:push(" world")
+    // Prints: hello, world
+    print($s)
+})
+.exec()?;
+```
+
+In this example we registered [`std::string::String`] as a userdata type with a set of methods and then created an instance of this type in Lua.
+
+It's _not_ required to register a type before using the `Lua::create_any_userdata()` method, instead an empty metatable will be created for you.
+You can also register the same type multiple times with different methods. Any previously created instances will share the old metatable, while new instances will have the new one.
+
+The new set of API is called `any_userdata` because it allows to register types that implements [`Any`] trait.
+
+[`std::string::String`]: https://doc.rust-lang.org/stable/std/string/struct.String.html
+[`Any`]: https://doc.rust-lang.org/stable/std/any/trait.Any.html
+
+#### 2. Scope support for the new any userdata types
+
+When you need to create non-static userdata instances in Lua, the usual way is use `Lua::scope()` helper to make them scoped. When out of scope, any scoped objects will be automatically
+dropped. The only downside of this approach is that every new instance will have a new metatable. This is not very fast if you need to create a lot of instances.
+
+With the new Any UserData API, you can place non-static references `&T` where `T: 'static` into a scope and they will share a single static metatable.
+
+```rust
+lua.register_userdata_type::<std::string::String>(|reg| {
+    reg.add_method_mut("replace", |_, this, (pat, to): (String, String)| {
+        *this = this.replace(&pat, &to);
+        Ok(())
+    });
+
+    reg.add_meta_method(MetaMethod::ToString, |lua, this, ()| lua.create_string(this));
+})?;
+
+let mut s = "hello, world".to_string();
+
+lua.scope(|scope| {
+    // This userdata instance holds only a mutable reference to our string
+    let ud = scope.create_any_userdata_ref_mut(&mut s)?;
+    lua.load(chunk! {
+        $ud:replace("world", "user")
+    })
+    .exec()
+})?;
+
+// Prints: hello, user!
+println!("{s}!");
+```
+
+#### 3. Owned types (`unstable`)
+
+One of the common questions was how to embed a Lua type into Rust struct to use it later. It was non-trivial to do because of the `'lua` lifetime attached to every Lua value.
+
+In v0.9 mlua introduces "owned" types `OwnedTable`/`OwnedFunction`/`OwnedString`/`OwnedAnyUserData`/ `OwnedThread`that are `'static` (no lifetime attached).
+
+```rust
+let lua = Lua::new();
+
+struct MyStruct {
+    table: OwnedTable,
+    func: OwnedFunction,
+}
+
+let my_struct = MyStruct {
+    table: lua.globals().into_owned(),
+    func: lua
+        .create_function(|_, t: Table| Ok(format!("{t:#?}")))?
+        .into_owned(),
+};
+
+// It's safe to drop Lua!
+drop(lua);
+
+let result = my_struct.func.call::<_, String>(my_struct.table)?;
+println!("{result}");
+```
+
+Prior to v0.9, it was possible to do by creating a reference to the Lua value in registry using `Lua::create_registry_value()`
+and retrieving value later using `Lua::registry_value()` method.
+
+All owned handles hold a *strong* reference to the current Lua instance.
+Be warned, if you place them into a Lua type (eg. `UserData` or a Rust callback), it is *very easy*
+to accidentally cause reference cycles that would prevent destroying Lua instance.
+
+Please note this functionality is available under the `unstable` feature flag and not available when the `send` feature is enabled.
+
+#### New ffi module
+
+In v0.9 release the internal `ffi` module has been moved into the new [`mlua-sys`] crate and became available for public use.
+This crate provides unified Lua FFI API (targeting Lua 5.4) using a (limited) compatibility layer for older versions.
+
+mlua re-exports the `ffi` module aliasing the `mlua-sys` crate and provides (unsafe) functionality to work with raw Lua state:
+
+```rust
+unsafe {
+    unsafe extern "C-unwind" fn lua_add(state: *mut mlua::lua_State) -> i32 {
+        let a = mlua::ffi::luaL_checkinteger(state, 1);
+        let b = mlua::ffi::luaL_checkinteger(state, 2);
+        mlua::ffi::lua_pushinteger(state, a + b);
+        1
+    }
+
+    let add = lua.create_c_function(lua_add)?;
+    assert_eq!(add.call::<_, i32>((2, 3))?, 5);
+}
+```
+
+[`mlua-sys`]: https://crates.io/crates/mlua-sys
+
+#### Luau JIT support
+
+mlua brings support for the new [Luau] JIT backend under the `luau-jit` feature flag.
+
+It will automatically trigger JIT compilation for new Lua chunks. To disable it, just call `lua.enable_jit(false)` before loading Lua code
+(but any previously compiled chunks will remain JIT-compiled).
+
+[Luau]: https://luau-lang.org
+
+### Improvements
+
+#### 1. Better error reporting
+
+When calling a Rust function from Lua and passing wrong arguments, previous mlua versions reported a error message without any context or reference to the particular argument.
+
+In v0.9 it reports a error message with the argument index and expected type:
+
+```rust
+let func = lua.create_function(|_, _a: i32| Ok(()))?;
+lua.load(chunk! {
+    local ok, err = pcall($func, "not a number")
+    // Prints: bad argument #1: error converting Lua string to i32 (expected number or string coercible to number)
+    print(err)
+})
+.exec()?;
+```
+
+Similar changes have been made for userdata functions and methods:
+
+```rust
+lua.register_userdata_type::<&'static str>(|reg| {
+    reg.add_method("len", |_, this, ()| Ok(this.len()));
+})?;
+
+let s = lua.create_any_userdata("hello")?;
+lua.load(chunk! {
+    local ok, err = pcall($s.len, 123)
+    // Prints: bad argument `self` to `&str.len`: error converting Lua integer to userdata
+    print(err)
+})
+.exec()?;
+```
+
+#### 2. Error context
+
+Similar to the [`anyhow`] Error type, now it's possible to attach context to Lua errors:
+
+```rust
+let read = lua.create_function(|lua, path: String| {
+    let bytes = std::fs::read(&path)
+        .into_lua_err()
+        .context(format!("Failed to open `{path}`"))?;
+    Ok(lua.create_string(bytes))
+})?;
+
+lua.load(chunk! {
+    local ok, err = pcall($read, "/nonexistent")
+    /// Prints:
+    /// Failed to open /nonexistent
+    /// No such file or directory (os error 2)
+    /// stack traceback:
+    /// ...
+    print(err)
+})
+.exec()?;
+```
+
+[`anyhow`]: https://crates.io/crates/anyhow
+
+#### 4. New methods `Function::wrap`/`AnyUserData::wrap`
+
+Sometimes it's useful to have `IntoLua` trait implementation for a Rust function or type `T: Any` without needing to call `Lua::create_function()`/`Lua::create_any_userdata()` methods.
+Since v0.9 you can call the new methods `Function::wrap()`/`AnyUserData::wrap()` that allows to do this. They return an abstract type that `impl IntoLua`:
+
+```rust
+lua.globals().set("print_rust", Function::wrap(|_, s: String| Ok(println!("{}", s))))?;
+lua.globals().set("rust_ud", AnyUserData::wrap("hello"))?;
+```
+
+In addition there are also `Function::wrap_mut()`/`Function::wrap_async()` methods that allow to wrap mutable and async functions respectively.
+
+For a `T: 'UserData + 'static` the `IntoLua` trait is still always implemented.
+
+#### `UserDataRef` and `UserDataRefMut` type wrappers
+
+The new wrappers `UserDataRef` and `UserDataRefMut` are receivers for userdata type `T` and borrow underlying instance for the lifetime of the wrapper.
+
+```rust
+lua.globals()
+    .set("ud", AnyUserData::wrap("hello".to_string()))?;
+
+let mut ud_mut: UserDataRefMut<String> = lua.globals().get("ud")?;
+ud_mut.push_str(", Rust");
+drop(ud_mut);
+
+let ud_ref: UserDataRef<String> = lua.globals().get("ud")?;
+// Prints: hello, Rust
+println!("{}", *ud_ref);
+```
+
+In the previous mlua versions the same functionality can be achieved by receiving `AnyUserData` and calling `AnyUserData::borrow()`/`AnyUserData::borrow_mut()` methods.
+
+The new wrappers are identical to Rust [`Ref`]/[`RefMut`] types.
+
+[`Ref`]: https://doc.rust-lang.org/std/cell/struct.Ref.html
+[`RefMut`]: https://doc.rust-lang.org/std/cell/struct.RefMut.html
+
+#### New `AnyUserDataExt` trait
+
+Similar to the `TableExt` trait, the `AnyUserDataExt` provides a set of extra methods for the `AnyUserData` type.
+
+1) `AnyUserDataExt::get()/set()` to get/set a value by key from the userdata, assuming it has `__index` metamethod.
+
+2) `AnyUserDataExt::call()` to call the userdata as a function assuming it has `__call` metamethod.
+
+3) `AnyUserData::call_method(name, ...)` to call the userdata method, assuming it has `__index` metamethod and the associated function.
+
+#### Pretty formatting Lua values
+
+`mlua::Value` implements a new format `:#?` that allows to (recursively) pretty print Lua values:
+
+```rust
+println!("{:#?}", lua.globals());
+```
+
+Prints:
+```
+{
+  ["_G"] = table: 0x7fa2d0706260,
+  ["_VERSION"] = "Lua 5.4",
+  ["assert"] = function: 0x10451d11d,
+  ["collectgarbage"] = function: 0x10451d198,
+  ["coroutine"] = {
+    ["close"] = function: 0x10451e28f,
+    ...
+  },
+  ["dofile"] = function: 0x10451d37c,
+  ...
+}
+```
+
+In addition a new method `Value::to_string()` has been added to convert `Value` to a string (using `__tostring` metamethod if available).
+
+#### Environment for Lua functions
+
+Any Lua functions have an associated environment table that is used to resolve global variables. By default it sets to a Lua globals table.
+
+In the new release it's possible to get or update a function environment using `Function::environment()` or `Function::set_environment()` methods respectively.
+
+```rust
+let f = lua.load("return a").into_function()?;
+
+assert_eq!(f.environment(), Some(lua.globals()));
+
+lua.globals().set("a", 1)?;
+assert_eq!(f.call::<_, i32>(())?, 1);
+
+f.set_environment(lua.create_table_from([("a", "hello")])?)?;
+assert_eq!(f.call::<_, mlua::String>(())?, "hello");
+```
+
+#### Performance optimizations
+
+The new mlua version has a number of performance improvements. Please check the [benchmarks results] to see how mlua compares to rlua and rhai.
+
+[benchmarks results]: https://github.com/khvzak/script-bench-rs
+
+### Changes in `module` mode
+
+#### New attributes
+
+The `lua_module` macro now support the following attributes:
+
+- `name=...` - sets name of the module (defaults to the name of the function).
+
+Eg.:
+
+```rust
+#[mlua::lua_module(name = "alt_module")]
+fn my_module(lua: &Lua) -> LuaResult<LuaTable> {
+    lua.create_table()
+}
+```
+
+Under the hood a new function `luaopen_alt_module` will be created for the Lua module loader.
+
+- `skip_memory_check` - skip memory allocation checks for some operations.
+
+In module mode, mlua runs in unknown environment and cannot say are there any memory limits or not. As result, some operations that require memory allocation runs in
+protected mode. Setting this attribute will improve performance of such operations with risk of having uncaught exceptions and memory leaks.
+
+#### Improved Windows target
+
+In previous mlua versions, building a Lua module for Windows requires having Lua development libraries installed on the system.
+In contrast, on Linux and macOS, modules can be built without any external dependencies using the `-undefined=dynamic_lookup` linker flag.
+
+With Rust 1.71+ it's now possible to lift this restriction for Windows as well. You can build modules normally and they will be linked with
+`lua54.dll`/`lua53.dll`/`lua52.dll`/`lua51.dll` depending on the enabled Lua version.
+
+You still need to have the dll although, linked to application where the module will be loaded.
+
+### Breaking changes
+
+1) `ToLua`/`ToLuaMulti` traits have been renamed to `IntoLua`/`IntoLuaMulti` respectively (with the methods called `into_lua`/`into_lua_multi`).
+
+The main reason for this change is following the Rust self [convention](https://rust-lang.github.io/rust-clippy/master/index.html#/wrong_self_convention).
+
+2) Removed `FromLua` implementation for `T: UserData + Clone`.
+
+During the usage of mlua, it was found that this implementation is not very useful and prevents custom `FromLua` implementations for `T: UserData`.
+It should be a developer decision to opt-in `FromLua` for their `T` if needed rather than having enabled it unconditionally.
+
+To opt-in `FromLua` for `T: Clone` you can use a simple `#[derive(FromLua)]` macro (requires `feature = "macros"`):
+
+```rust
+#[derive(Clone, Copy, mlua::FromLua)]
+struct MyUserData(i32);
+```
+
+`T` is not required to implement `UserData` because of the new relaxed restrictions on userdata types.
@@ -1,33 +1,36 @@
 use std::collections::HashMap;

-use hyper::body::{Body as HyperBody, HttpBody as _};
-use hyper::Client as HyperClient;
+use http_body_util::BodyExt as _;
+use hyper::body::Incoming;
+use hyper_util::client::legacy::Client as HyperClient;
+use hyper_util::rt::TokioExecutor;

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

-struct BodyReader(HyperBody);
+struct BodyReader(Incoming);

 impl UserData for BodyReader {
    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        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();
+        // Every call returns a next chunk
+        methods.add_async_method_mut("read", |lua, reader, ()| async move {
+            if let Some(bytes) = reader.0.frame().await {
+                if let Some(bytes) = bytes.into_lua_err()?.data_ref() {
+                    return Some(lua.create_string(&bytes)).transpose();
+                }
            }
            Ok(None)
        });
    }
 }

-#[tokio::main]
+#[tokio::main(flavor = "current_thread")]
 async fn main() -> Result<()> {
    let lua = Lua::new();

    let fetch_url = lua.create_async_function(|lua, uri: String| async move {
-        let client = HyperClient::new();
-        let uri = uri.parse().to_lua_err()?;
-        let resp = client.get(uri).await.to_lua_err()?;
+        let client = HyperClient::builder(TokioExecutor::new()).build_http::<String>();
+        let uri = uri.parse().into_lua_err()?;
+        let resp = client.get(uri).await.into_lua_err()?;

        let lua_resp = lua.create_table()?;
        lua_resp.set("status", resp.status().as_u16())?;
@@ -37,7 +40,7 @@ async fn main() -> Result<()> {
            headers
                .entry(key.as_str())
                .or_insert(Vec::new())
-                .push(value.to_str().to_lua_err()?);
+                .push(value.to_str().into_lua_err()?);
        }

        lua_resp.set("headers", headers)?;
@@ -56,11 +59,11 @@ async fn main() -> Result<()> {
                end
            end
            repeat
-                local body = res.body:read()
-                if body then
-                    print(body)
+                local chunk = res.body:read()
+                if chunk then
+                    print(chunk)
                end
-            until not body
+            until not chunk
        })
        .into_function()?;

@@ -1,33 +1,27 @@
-use mlua::{chunk, ExternalResult, Lua, LuaSerdeExt, Result};
+use mlua::{chunk, ExternalResult, Lua, LuaSerdeExt, Result, Value};

-#[tokio::main]
+#[tokio::main(flavor = "current_thread")]
 async fn main() -> Result<()> {
    let lua = Lua::new();

-    let null = lua.null();
-
    let fetch_json = lua.create_async_function(|lua, uri: String| async move {
        let resp = reqwest::get(&uri)
            .await
            .and_then(|resp| resp.error_for_status())
-            .to_lua_err()?;
-        let json = resp.json::<serde_json::Value>().await.to_lua_err()?;
+            .into_lua_err()?;
+        let json = resp.json::<serde_json::Value>().await.into_lua_err()?;
        lua.to_value(&json)
    })?;

+    let dbg = lua.create_function(|_, value: Value| {
+        println!("{value:#?}");
+        Ok(())
+    })?;
+
    let f = lua
        .load(chunk! {
-            function print_r(t, indent)
-                local indent = indent or ""
-                for k, v in pairs(t) do
-                    io.write(indent, tostring(k))
-                    if type(v) == "table" then io.write(":\n") print_r(v, indent.."  ")
-                    else io.write(": ", v == $null and "null" or tostring(v), "\n") end
-                end
-            end
-
            local res = $fetch_json(...)
-            print_r(res)
+            $dbg(res)
        })
        .into_function()?;

@@ -1,43 +1,52 @@
+use std::convert::Infallible;
 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::Service;
-use hyper::{Body, Request, Response, Server};
+use http_body_util::combinators::BoxBody;
+use http_body_util::{BodyExt as _, Empty, Full};
+use hyper::body::{Bytes, Incoming};
+use hyper::server::conn::http1;
+use hyper::{Request, Response};
+use hyper_util::rt::TokioIo;
+use tokio::net::TcpListener;

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

-struct LuaRequest(SocketAddr, Request<Body>);
+/// Wrapper around incoming request that implements UserData
+struct LuaRequest(SocketAddr, Request<Incoming>);

 impl UserData for LuaRequest {
    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_method("remote_addr", |_lua, req, ()| Ok((req.0).to_string()));
-        methods.add_method("method", |_lua, req, ()| Ok((req.1).method().to_string()));
+        methods.add_method("remote_addr", |_, req, ()| Ok((req.0).to_string()));
+        methods.add_method("method", |_, req, ()| Ok((req.1).method().to_string()));
+        methods.add_method("path", |_, req, ()| Ok(req.1.uri().path().to_string()));
    }
 }

-pub struct Svc(Rc<Lua>, SocketAddr);
+/// Service that handles incoming requests
+#[derive(Clone)]
+pub struct Svc {
+    handler: Function,
+    peer_addr: SocketAddr,
+}

-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(()))
+impl Svc {
+    pub fn new(handler: Function, peer_addr: SocketAddr) -> Self {
+        Self { handler, peer_addr }
    }
+}

-    fn call(&mut self, req: Request<Body>) -> Self::Future {
+impl hyper::service::Service<Request<Incoming>> for Svc {
+    type Response = Response<BoxBody<Bytes, Infallible>>;
+    type Error = LuaError;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;
+
+    fn call(&self, req: Request<Incoming>) -> Self::Future {
        // If handler returns an error then generate 5xx response
-        let lua = self.0.clone();
-        let lua_req = LuaRequest(self.1, req);
+        let handler = self.handler.clone();
+        let lua_req = LuaRequest(self.peer_addr, 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);
@@ -47,14 +56,15 @@ impl Service<Request<Body>> for Svc {
                    if let Some(headers) = lua_resp.get::<_, Option<Table>>("headers")? {
                        for pair in headers.pairs::<String, LuaString>() {
                            let (h, v) = pair?;
-                            resp = resp.header(&h, v.as_bytes());
+                            resp = resp.header(&h, &*v.as_bytes());
                        }
                    }

+                    // Set body
                    let body = lua_resp
                        .get::<_, Option<LuaString>>("body")?
-                        .map(|b| Body::from(b.as_bytes().to_vec()))
-                        .unwrap_or_else(Body::empty);
+                        .map(|b| Full::new(Bytes::copy_from_slice(&b.as_bytes())).boxed())
+                        .unwrap_or_else(|| Empty::<Bytes>::new().boxed());

                    Ok(resp.body(body).unwrap())
                }
@@ -62,7 +72,7 @@ impl Service<Request<Body>> for Svc {
                    eprintln!("{}", err);
                    Ok(Response::builder()
                        .status(500)
-                        .body(Body::from("Internal Server Error"))
+                        .body(Full::new(Bytes::from("Internal Server Error")).boxed())
                        .unwrap())
                }
            }
@@ -72,65 +82,47 @@ impl Service<Request<Body>> for Svc {

 #[tokio::main(flavor = "current_thread")]
 async fn main() {
-    let lua = Rc::new(Lua::new());
+    let lua = Lua::new();

    // Create Lua handler function
-    let handler: Function = lua
+    let handler = lua
        .load(chunk! {
            function(req)
                return {
                    status = 200,
                    headers = {
                        ["X-Req-Method"] = req:method(),
+                        ["X-Req-Path"] = req:path(),
                        ["X-Remote-Addr"] = req:remote_addr(),
                    },
                    body = "Hello from Lua!\n"
                }
            end
        })
-        .eval()
-        .expect("cannot create Lua handler");
+        .eval::<Function>()
+        .expect("Failed to create Lua handler");

-    // Store it in the Registry
-    lua.set_named_registry_value("http_handler", handler)
-        .expect("cannot store Lua handler");
+    let listen_addr = "127.0.0.1:3000";
+    let listener = TcpListener::bind(listen_addr).await.unwrap();
+    println!("Listening on http://{listen_addr}");

-    let addr = ([127, 0, 0, 1], 3000).into();
-    let server = Server::bind(&addr).executor(LocalExec).serve(MakeSvc(lua));
+    loop {
+        let (stream, peer_addr) = match listener.accept().await {
+            Ok(x) => x,
+            Err(err) => {
+                eprintln!("Failed to accept connection: {err}");
+                continue;
+            }
+        };

-    println!("Listening on http://{}", addr);
-
-    // Create `LocalSet` to spawn !Send futures
-    let local = tokio::task::LocalSet::new();
-    local.run_until(server).await.expect("cannot run server")
-}
-
-struct MakeSvc(Rc<Lua>);
-
-impl Service<&AddrStream> for MakeSvc {
-    type Response = Svc;
-    type Error = hyper::Error;
-    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
-
-    fn poll_ready(&mut self, _: &mut Context) -> Poll<Result<(), Self::Error>> {
-        Poll::Ready(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)]
-struct LocalExec;
-
-impl<F> hyper::rt::Executor<F> for LocalExec
-where
-    F: std::future::Future + 'static, // not requiring `Send`
-{
-    fn execute(&self, fut: F) {
-        tokio::task::spawn_local(fut);
+        let svc = Svc::new(handler.clone(), peer_addr);
+        tokio::task::spawn(async move {
+            if let Err(err) = http1::Builder::new()
+                .serve_connection(TokioIo::new(stream), svc)
+                .await
+            {
+                eprintln!("Error serving connection: {:?}", err);
+            }
+        });
    }
 }
@@ -1,59 +1,42 @@
 use std::io;
 use std::net::SocketAddr;
-use std::rc::Rc;

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

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

 struct LuaTcpStream(TcpStream);

 impl UserData for LuaTcpStream {
    fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_method("peer_addr", |_, this, ()| {
-            Ok(this.0.peer_addr()?.to_string())
+        methods.add_method("peer_addr", |_, this, ()| Ok(this.0.peer_addr()?.to_string()));
+
+        methods.add_async_method_mut("read", |lua, this, size| async move {
+            let mut buf = vec![0; size];
+            let n = this.0.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_mut("write", |_, this, data: LuaString| async move {
+            let n = this.0.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_function("close", |_, this: AnyUserData| async move {
-            let mut this = this.borrow_mut::<Self>()?;
+        methods.add_async_method_mut("close", |_, this, ()| async move {
            this.0.shutdown().await?;
            Ok(())
        });
    }
 }

-async fn run_server(lua: Lua, handler: RegistryKey) -> io::Result<()> {
+async fn run_server(handler: Function) -> io::Result<()> {
    let addr: SocketAddr = ([127, 0, 0, 1], 3000).into();
    let listener = TcpListener::bind(addr).await.expect("cannot bind addr");

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

-    let lua = Rc::new(lua);
-    let handler = Rc::new(handler);
    loop {
        let (stream, _) = match listener.accept().await {
            Ok(res) => res,
@@ -61,13 +44,8 @@ async fn run_server(lua: Lua, handler: RegistryKey) -> io::Result<()> {
            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");
-
+        tokio::task::spawn(async move {
            let stream = LuaTcpStream(stream);
            if let Err(err) = handler.call_async::<_, ()>(stream).await {
                eprintln!("{}", err);
@@ -81,7 +59,7 @@ async fn main() {
    let lua = Lua::new();

    // Create Lua handler function
-    let handler_fn = lua
+    let handler = lua
        .load(chunk! {
            function(stream)
                local peer_addr = stream:peer_addr()
@@ -103,15 +81,7 @@ async fn main() {
        .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(run_server(lua, handler))
-        .await
-        .expect("cannot run server")
+    run_server(handler).await.expect("cannot run server")
 }

 fn is_transient_error(e: &io::Error) -> bool {
@@ -1,7 +1,7 @@
 use std::f32;
 use std::iter::FromIterator;

-use mlua::{chunk, Function, Lua, MetaMethod, Result, UserData, UserDataMethods, Variadic};
+use mlua::{chunk, FromLua, Function, Lua, MetaMethod, Result, UserData, UserDataMethods, Value, Variadic};

 fn main() -> Result<()> {
    // You can create a new Lua state with `Lua::new()`. This loads the default Lua std library
@@ -22,7 +22,7 @@ fn main() -> Result<()> {

    // You can load and evaluate Lua code. The returned type of `Lua::load` is a builder
    // that allows you to change settings before running Lua code. Here, we are using it to set
-    // the name of the laoded chunk to "example code", which will be used when Lua error
+    // the name of the loaded chunk to "example code", which will be used when Lua error
    // messages are printed.

    lua.load(
@@ -30,7 +30,7 @@ fn main() -> Result<()> {
            global = 'foo'..'bar'
        "#,
    )
-    .set_name("example code")?
+    .set_name("example code")
    .exec()?;
    assert_eq!(globals.get::<_, String>("global")?, "foobar");

@@ -87,7 +87,7 @@ fn main() -> Result<()> {
    let print: Function = globals.get("print")?;
    print.call::<_, ()>("hello from rust")?;

-    // This API generally handles variadics using tuples. This is one way to call a function with
+    // This API generally handles variadic using tuples. This is one way to call a function with
    // multiple parameters:

    print.call::<_, ()>(("hello", "again", "from", "rust"))?;
@@ -98,7 +98,7 @@ fn main() -> Result<()> {
        ["hello", "yet", "again", "from", "rust"].iter().cloned(),
    ))?;

-    // You can bind rust functions to Lua as well. Callbacks receive the Lua state inself as their
+    // You can bind rust functions to Lua as well. Callbacks receive the Lua state itself as their
    // first parameter, and the arguments given to the function as the second parameter. The type
    // of the arguments can be anything that is convertible from the parameters given by Lua, in
    // this case, the function expects two string sequences.
@@ -151,6 +151,16 @@ fn main() -> Result<()> {
    #[derive(Copy, Clone)]
    struct Vec2(f32, f32);

+    // We can implement `FromLua` trait for our `Vec2` to return a copy
+    impl FromLua for Vec2 {
+        fn from_lua(value: Value, _: &Lua) -> Result<Self> {
+            match value {
+                Value::UserData(ud) => Ok(*ud.borrow::<Self>()?),
+                _ => unreachable!(),
+            }
+        }
+    }
+
    impl UserData for Vec2 {
        fn add_methods<'lua, M: UserDataMethods<'lua, Self>>(methods: &mut M) {
            methods.add_method("magnitude", |_, vec, ()| {
@@ -167,19 +177,15 @@ fn main() -> Result<()> {
    let vec2_constructor = lua.create_function(|_, (x, y): (f32, f32)| Ok(Vec2(x, y)))?;
    globals.set("vec2", vec2_constructor)?;

-    assert!(
-        (lua.load("(vec2(1, 2) + vec2(2, 2)):magnitude()")
-            .eval::<f32>()?
-            - 5.0)
-            .abs()
-            < f32::EPSILON
-    );
+    assert!((lua.load("(vec2(1, 2) + vec2(2, 2)):magnitude()").eval::<f32>()? - 5.0).abs() < f32::EPSILON);

    // Normally, Rust types passed to `Lua` must be `'static`, because there is no way to be
    // sure of their lifetime inside the Lua state. There is, however, a limited way to lift this
    // requirement. You can call `Lua::scope` to create userdata and callbacks types that only live
    // for as long as the call to scope, but do not have to be `'static` (and `Send`).

+    // TODO: Re-enable this
+    /*
    {
        let mut rust_val = 0;

@@ -201,6 +207,7 @@ fn main() -> Result<()> {

        assert_eq!(rust_val, 42);
    }
+    */

    // We were able to run our 'sketchy' function inside the scope just fine. However, if we
    // try to run our 'sketchy' function outside of the scope, the function we created will have
@@ -2,7 +2,7 @@
 name = "rust_module"
 version = "0.0.0"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
-edition = "2018"
+edition = "2021"

 [lib]
 crate-type = ["cdylib"]
@@ -1,11 +1,11 @@
 //! This example shows a simple read-evaluate-print-loop (REPL).

 use mlua::{Error, Lua, MultiValue};
-use rustyline::Editor;
+use rustyline::DefaultEditor;

 fn main() {
    let lua = Lua::new();
-    let mut editor = Editor::<()>::new().expect("Failed to make rustyline editor");
+    let mut editor = DefaultEditor::new().expect("Failed to create editor");

    loop {
        let mut prompt = "> ";
@@ -19,12 +19,12 @@ fn main() {

            match lua.load(&line).eval::<MultiValue>() {
                Ok(values) => {
-                    editor.add_history_entry(line);
+                    editor.add_history_entry(line).unwrap();
                    println!(
                        "{}",
                        values
                            .iter()
-                            .map(|value| format!("{:?}", value))
+                            .map(|value| format!("{:#?}", value))
                            .collect::<Vec<_>>()
                            .join("\t")
                    );
@@ -28,9 +28,14 @@ fn main() -> Result<()> {
    let globals = lua.globals();

    // Create Car struct from a Lua table
-    let car: Car = lua.from_value(lua.load(r#"
+    let car: Car = lua.from_value(
+        lua.load(
+            r#"
        {active = true, model = "Volkswagen Golf", transmission = "Automatic", engine = {v = 1499, kw = 90}}
-    "#).eval()?)?;
+    "#,
+        )
+        .eval()?,
+    )?;

    // Set it as (serializable) userdata
    globals.set("null", lua.null())?;
@@ -0,0 +1,46 @@
+[package]
+name = "mlua-sys"
+version = "0.6.2"
+authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
+rust-version = "1.71"
+edition = "2021"
+repository = "https://github.com/khvzak/mlua"
+documentation = "https://docs.rs/mlua-sys"
+readme = "README.md"
+categories = ["external-ffi-bindings"]
+license = "MIT"
+links = "lua"
+build = "build/main.rs"
+description = """
+Low level (FFI) bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau
+"""
+
+[package.metadata.docs.rs]
+features = ["lua54", "vendored"]
+rustdoc-args = ["--cfg", "docsrs"]
+
+[features]
+lua54 = []
+lua53 = []
+lua52 = []
+lua51 = []
+luajit = []
+luajit52 = ["luajit"]
+luau = ["luau0-src"]
+luau-codegen = ["luau"]
+luau-vector4 = ["luau"]
+vendored = ["lua-src", "luajit-src"]
+module = []
+
+[dependencies]
+
+[build-dependencies]
+cc = "1.0"
+cfg-if = "1.0"
+pkg-config = "0.3.17"
+lua-src = { version = ">= 547.0.0, < 547.1.0", optional = true }
+luajit-src = { version = ">= 210.5.0, < 210.6.0", optional = true }
+luau0-src = { version = "0.10.0", optional = true }
+
+[lints.rust]
+unexpected_cfgs = { level = "allow", check-cfg = ['cfg(raw_dylib)'] }
@@ -0,0 +1,8 @@
+# mlua-sys
+
+Low level (FFI) bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox [Luau].
+
+Intended to be consumed by the [mlua] crate.
+
+[Luau]: https://github.com/Roblox/luau
+[mlua]: https://crates.io/crates/mlua
@@ -0,0 +1,58 @@
+#![allow(dead_code)]
+
+use std::env;
+use std::ops::Bound;
+
+pub fn probe_lua() {
+    let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
+
+    if target_arch == "wasm32" && cfg!(not(feature = "vendored")) {
+        panic!("Please enable `vendored` feature to build for wasm32");
+    }
+
+    let lib_dir = env::var("LUA_LIB").unwrap_or_default();
+    let lua_lib = env::var("LUA_LIB_NAME").unwrap_or_default();
+
+    println!("cargo:rerun-if-env-changed=LUA_LIB");
+    println!("cargo:rerun-if-env-changed=LUA_LIB_NAME");
+    println!("cargo:rerun-if-env-changed=LUA_LINK");
+
+    if !lua_lib.is_empty() {
+        if !lib_dir.is_empty() {
+            println!("cargo:rustc-link-search=native={lib_dir}");
+        }
+        let mut link_lib = "";
+        if env::var("LUA_LINK").as_deref() == Ok("static") {
+            link_lib = "static=";
+        };
+        println!("cargo:rustc-link-lib={link_lib}{lua_lib}");
+        return;
+    }
+
+    // Find using `pkg-config`
+
+    #[cfg(feature = "lua54")]
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.4", "5.5", Some("lua5.4"), "5.4");
+    #[cfg(feature = "lua53")]
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.3", "5.4", Some("lua5.3"), "5.3");
+    #[cfg(feature = "lua52")]
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.2", "5.3", Some("lua5.2"), "5.2");
+    #[cfg(feature = "lua51")]
+    let (incl_bound, excl_bound, alt_probe, ver) = ("5.1", "5.2", Some("lua5.1"), "5.1");
+    #[cfg(feature = "luajit")]
+    let (incl_bound, excl_bound, alt_probe, ver) = ("2.0.4", "2.2", None, "JIT");
+
+    #[rustfmt::skip]
+    let mut lua = pkg_config::Config::new()
+        .range_version((Bound::Included(incl_bound), Bound::Excluded(excl_bound)))
+        .cargo_metadata(true)
+        .probe(if cfg!(feature = "luajit") { "luajit" } else { "lua" });
+
+    if lua.is_err() && alt_probe.is_some() {
+        lua = pkg_config::Config::new()
+            .cargo_metadata(true)
+            .probe(alt_probe.unwrap());
+    }
+
+    lua.unwrap_or_else(|err| panic!("cannot find Lua{ver} using `pkg-config`: {err}"));
+}
@@ -1,28 +1,29 @@
 #![allow(dead_code)]

-use std::path::PathBuf;
-
-pub fn probe_lua() -> Option<PathBuf> {
+pub fn probe_lua() {
    #[cfg(feature = "lua54")]
    let artifacts = lua_src::Build::new().build(lua_src::Lua54);
+
    #[cfg(feature = "lua53")]
    let artifacts = lua_src::Build::new().build(lua_src::Lua53);
+
    #[cfg(feature = "lua52")]
    let artifacts = lua_src::Build::new().build(lua_src::Lua52);
+
    #[cfg(feature = "lua51")]
    let artifacts = lua_src::Build::new().build(lua_src::Lua51);
+
    #[cfg(feature = "luajit")]
-    let artifacts = {
-        let mut builder = luajit_src::Build::new();
-        if cfg!(feature = "luajit52") {
-            builder.lua52compat(true);
-        }
-        builder.build()
-    };
+    let artifacts = luajit_src::Build::new()
+        .lua52compat(cfg!(feature = "luajit52"))
+        .build();
+
    #[cfg(feature = "luau")]
-    let artifacts = luau0_src::Build::new().build();
+    let artifacts = luau0_src::Build::new()
+        .enable_codegen(cfg!(feature = "luau-codegen"))
+        .set_max_cstack_size(1000000)
+        .set_vector_size(if cfg!(feature = "luau-vector4") { 4 } else { 3 })
+        .build();

    artifacts.print_cargo_metadata();
-
-    Some(artifacts.include_dir().to_owned())
 }
@@ -0,0 +1,19 @@
+cfg_if::cfg_if! {
+    if #[cfg(all(feature = "lua54", not(any(feature = "lua53", feature = "lua52", feature = "lua51", feature = "luajit", feature = "luau"))))] {
+        include!("main_inner.rs");
+    } else if #[cfg(all(feature = "lua53", not(any(feature = "lua54", feature = "lua52", feature = "lua51", feature = "luajit", feature = "luau"))))] {
+        include!("main_inner.rs");
+    } else if #[cfg(all(feature = "lua52", not(any(feature = "lua54", feature = "lua53", feature = "lua51", feature = "luajit", feature = "luau"))))] {
+        include!("main_inner.rs");
+    } else if #[cfg(all(feature = "lua51", not(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luajit", feature = "luau"))))] {
+        include!("main_inner.rs");
+    } else if #[cfg(all(feature = "luajit", not(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "lua51", feature = "luau"))))] {
+        include!("main_inner.rs");
+    } else if #[cfg(all(feature = "luau", not(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "lua51", feature = "luajit"))))] {
+        include!("main_inner.rs");
+    } else {
+        fn main() {
+            compile_error!("You can enable only one of the features: lua54, lua53, lua52, lua51, luajit, luajit52, luau");
+        }
+    }
+}
@@ -0,0 +1,35 @@
+use std::env;
+
+cfg_if::cfg_if! {
+    if #[cfg(any(feature = "luau", feature = "vendored"))] {
+        #[path = "find_vendored.rs"]
+        mod find;
+    } else {
+        #[path = "find_normal.rs"]
+        mod find;
+    }
+}
+
+fn main() {
+    #[cfg(all(feature = "luau", feature = "module", windows))]
+    compile_error!("Luau does not support `module` mode on Windows");
+
+    #[cfg(all(feature = "module", feature = "vendored"))]
+    compile_error!("`vendored` and `module` features are mutually exclusive");
+
+    println!("cargo:rerun-if-changed=build");
+
+    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
+    if target_os == "windows" && cfg!(feature = "module") {
+        if !std::env::var("LUA_LIB_NAME").unwrap_or_default().is_empty() {
+            // Don't use raw-dylib linking
+            find::probe_lua();
+            return;
+        }
+
+        println!("cargo:rustc-cfg=raw_dylib");
+    }
+
+    #[cfg(not(feature = "module"))]
+    find::probe_lua();
+}
@@ -1,103 +1,105 @@
-//! Low level bindings to Lua 5.4/5.3/5.2/5.1 including LuaJIT.
+//! Low level bindings to Lua 5.4/5.3/5.2/5.1 (including LuaJIT) and Roblox Luau.

 #![allow(non_camel_case_types, non_snake_case, dead_code)]
+#![allow(clippy::missing_safety_doc)]
+#![doc(test(attr(deny(warnings))))]
+#![cfg_attr(docsrs, feature(doc_cfg))]

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

-#[cfg(feature = "lua54")]
+#[cfg(any(feature = "lua54", doc))]
 pub use lua54::*;

-#[cfg(feature = "lua53")]
+#[cfg(any(feature = "lua53", doc))]
 pub use lua53::*;

-#[cfg(feature = "lua52")]
+#[cfg(any(feature = "lua52", doc))]
 pub use lua52::*;

-#[cfg(any(feature = "lua51", feature = "luajit"))]
+#[cfg(any(feature = "lua51", feature = "luajit", doc))]
 pub use lua51::*;

-#[cfg(feature = "luau")]
+#[cfg(any(feature = "luau", doc))]
 pub use luau::*;

 #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+#[doc(hidden)]
 pub const LUA_MAX_UPVALUES: c_int = 255;

-#[cfg(any(feature = "lua51", all(feature = "luajit", not(feature = "vendored"))))]
+#[cfg(any(feature = "lua51", feature = "luajit"))]
+#[doc(hidden)]
 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")]
+#[doc(hidden)]
 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`
+#[doc(hidden)]
 pub const LUA_TRACEBACK_STACK: c_int = 11;

+// Copied from https://github.com/rust-lang/rust/blob/master/library/std/src/sys/pal/common/alloc.rs
 // 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(
+#[cfg(any(
    target_arch = "x86",
    target_arch = "arm",
+    target_arch = "m68k",
+    target_arch = "csky",
    target_arch = "mips",
+    target_arch = "mips32r6",
    target_arch = "powerpc",
    target_arch = "powerpc64",
    target_arch = "sparc",
-    target_arch = "asmjs",
    target_arch = "wasm32",
    target_arch = "hexagon",
-    all(target_arch = "riscv32", not(target_os = "espidf")),
+    all(target_arch = "riscv32", not(any(target_os = "espidf", target_os = "zkvm"))),
    all(target_arch = "xtensa", not(target_os = "espidf")),
-)))]
+))]
+#[doc(hidden)]
 pub const SYS_MIN_ALIGN: usize = 8;
-#[cfg(all(any(
+#[cfg(any(
    target_arch = "x86_64",
    target_arch = "aarch64",
+    target_arch = "arm64ec",
+    target_arch = "loongarch64",
    target_arch = "mips64",
+    target_arch = "mips64r6",
    target_arch = "s390x",
    target_arch = "sparc64",
    target_arch = "riscv64",
    target_arch = "wasm64",
-)))]
+))]
+#[doc(hidden)]
 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"),
+// The allocator on the esp-idf and zkvm platforms guarantee 4 byte alignment.
+#[cfg(any(
+    all(target_arch = "riscv32", any(target_os = "espidf", target_os = "zkvm")),
    all(target_arch = "xtensa", target_os = "espidf"),
-)))]
+))]
+#[doc(hidden)]
 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 _);
-    symbols.push(lua_isuserdata as _);
-    symbols.push(lua_tocfunction as _);
-    symbols.push(luaL_loadstring as _);
-    symbols.push(luaL_openlibs as _);
-    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-    {
-        symbols.push(lua_getglobal as _);
-        symbols.push(lua_setglobal as _);
-        symbols.push(luaL_setfuncs as _);
-    }
-}
+#[macro_use]
+mod macros;

-#[cfg(feature = "lua54")]
+#[cfg(any(feature = "lua54", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "lua54")))]
 pub mod lua54;

-#[cfg(feature = "lua53")]
+#[cfg(any(feature = "lua53", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "lua53")))]
 pub mod lua53;

-#[cfg(feature = "lua52")]
+#[cfg(any(feature = "lua52", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "lua52")))]
 pub mod lua52;

-#[cfg(any(feature = "lua51", feature = "luajit"))]
+#[cfg(any(feature = "lua51", feature = "luajit", doc))]
+#[cfg_attr(docsrs, doc(cfg(any(feature = "lua51", feature = "luajit"))))]
 pub mod lua51;

-#[cfg(feature = "luau")]
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
 pub mod luau;
@@ -2,10 +2,8 @@
 //!
 //! Based on github.com/keplerproject/lua-compat-5.3

-use std::convert::TryInto;
-use std::mem;
 use std::os::raw::{c_char, c_int, c_void};
-use std::ptr;
+use std::{mem, ptr};

 use super::lauxlib::*;
 use super::lua::*;
@@ -329,12 +327,7 @@ pub unsafe fn lua_setuservalue(L: *mut lua_State, idx: c_int) {
 }

 #[inline(always)]
-pub unsafe fn lua_dump(
-    L: *mut lua_State,
-    writer: lua_Writer,
-    data: *mut c_void,
-    _strip: c_int,
-) -> c_int {
+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)
 }

@@ -366,12 +359,7 @@ pub unsafe fn lua_pushglobaltable(L: *mut lua_State) {
 }

 #[inline(always)]
-pub unsafe fn lua_resume(
-    L: *mut lua_State,
-    _from: *mut lua_State,
-    narg: c_int,
-    nres: *mut c_int,
-) -> c_int {
+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);
@@ -447,12 +435,7 @@ pub unsafe fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer {
    res
 }

-pub unsafe fn luaL_traceback(
-    L: *mut lua_State,
-    L1: *mut lua_State,
-    msg: *const c_char,
-    mut level: c_int,
-) {
+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 = compat53_countlevels(L1);
@@ -486,10 +469,10 @@ pub unsafe fn luaL_traceback(
    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 {
+pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize) -> *const c_char {
+    idx = lua_absindex(L, idx);
    if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
-        let t = lua_type(L, idx);
-        match t {
+        match lua_type(L, idx) {
            LUA_TNIL => {
                lua_pushliteral(L, "nil");
            }
@@ -503,7 +486,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
                    lua_pushliteral(L, "true");
                }
            }
-            _ => {
+            t => {
                let tt = luaL_getmetafield(L, idx, cstr!("__name"));
                let name = if tt == LUA_TSTRING {
                    lua_tostring(L, -1)
@@ -512,7 +495,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
                };
                lua_pushfstring(L, cstr!("%s: %p"), name, lua_topointer(L, idx));
                if tt != LUA_TNIL {
-                    lua_replace(L, -2);
+                    lua_replace(L, -2); // remove '__name'
                }
            }
        };
@@ -544,12 +527,7 @@ pub unsafe fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_ch
    0
 }

-pub unsafe fn luaL_requiref(
-    L: *mut lua_State,
-    modname: *const c_char,
-    openf: lua_CFunction,
-    glb: c_int,
-) {
+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 {
@@ -14,7 +14,8 @@ pub struct luaL_Reg {
    pub func: lua_CFunction,
 }

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
    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;
@@ -42,7 +43,7 @@ extern "C" {
    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_error(L: *mut lua_State, fmt: *const c_char, ...) -> c_int;

    pub fn luaL_checkoption(
        L: *mut lua_State,
@@ -56,17 +57,13 @@ extern "C" {
 pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
    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_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;
@@ -73,23 +73,23 @@ pub type lua_Integer = i32;
 pub type lua_Integer = i64;

 /// 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_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;

 // Type for functions that read/write blocks when loading/dumping Lua chunks
+#[rustfmt::skip]
 pub type lua_Reader =
-    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+#[rustfmt::skip]
 pub type lua_Writer =
-    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+    unsafe extern "C-unwind" 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;
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
    //
    // State manipulation
    //
@@ -97,9 +97,6 @@ extern "C" {
    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;

    //
@@ -221,21 +218,33 @@ pub const LUA_GCSTEP: c_int = 5;
 pub const LUA_GCSETPAUSE: c_int = 6;
 pub const LUA_GCSETSTEPMUL: c_int = 7;

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
    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) -> !;
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
+    #[link_name = "lua_error"]
+    fn lua_error_(L: *mut lua_State) -> c_int;
    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);
 }

+// lua_error does not return but is declared to return int, and Rust translates
+// ! to void which can cause link-time errors if the platform linker is aware
+// of return types and requires they match (for example: wasm does this).
+#[inline(always)]
+pub unsafe fn lua_error(L: *mut lua_State) -> ! {
+    lua_error_(L);
+    unreachable!();
+}
+
 //
 // Some useful macros (implemented as Rust functions)
 //
@@ -319,6 +328,14 @@ 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_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void {
+    if lua_islightuserdata(L, idx) != 0 {
+        return lua_touserdata(L, idx);
+    }
+    ptr::null_mut()
+}
+
 #[inline(always)]
 pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
    lua_tolstring(L, i, ptr::null_mut())
@@ -351,9 +368,10 @@ 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);
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
    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;
@@ -361,12 +379,7 @@ extern "C" {
    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_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;
@@ -20,7 +20,8 @@ pub const LUA_JITLIBNAME: &str = "jit";
 #[cfg(feature = "luajit")]
 pub const LUA_FFILIBNAME: &str = "ffi";

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua51", kind = "raw-dylib"))]
+extern "C-unwind" {
    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;
@@ -2,7 +2,6 @@
 //!
 //! 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;

@@ -158,22 +157,12 @@ pub unsafe fn lua_rawseti(L: *mut lua_State, idx: c_int, n: lua_Integer) {
 }

 #[inline(always)]
-pub unsafe fn lua_dump(
-    L: *mut lua_State,
-    writer: lua_Writer,
-    data: *mut c_void,
-    _strip: c_int,
-) -> c_int {
+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 {
+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);
@@ -205,10 +194,10 @@ pub unsafe fn luaL_newmetatable(L: *mut lua_State, tname: *const c_char) -> c_in
    }
 }

-pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char {
+pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize) -> *const c_char {
+    idx = lua_absindex(L, idx);
    if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
-        let t = lua_type(L, idx);
-        match t {
+        match lua_type(L, idx) {
            LUA_TNIL => {
                lua_pushliteral(L, "nil");
            }
@@ -222,7 +211,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
                    lua_pushliteral(L, "true");
                }
            }
-            _ => {
+            t => {
                let tt = luaL_getmetafield(L, idx, cstr!("__name"));
                let name = if tt == LUA_TSTRING {
                    lua_tostring(L, -1)
@@ -231,7 +220,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
                };
                lua_pushfstring(L, cstr!("%s: %p"), name, lua_topointer(L, idx));
                if tt != LUA_TNIL {
-                    lua_replace(L, -2);
+                    lua_replace(L, -2); // remove '__name'
                }
            }
        };
@@ -241,12 +230,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
    lua_tolstring(L, -1, len)
 }

-pub unsafe fn luaL_requiref(
-    L: *mut lua_State,
-    modname: *const c_char,
-    openf: lua_CFunction,
-    glb: c_int,
-) {
+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 {
@@ -14,7 +14,8 @@ pub struct luaL_Reg {
    pub func: lua_CFunction,
 }

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
    pub fn luaL_checkversion_(L: *mut lua_State, ver: lua_Number);

    #[link_name = "luaL_getmetafield"]
@@ -24,12 +25,8 @@ extern "C" {
    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_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;
@@ -48,7 +45,7 @@ extern "C" {
    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_error(L: *mut lua_State, fmt: *const c_char, ...) -> c_int;

    pub fn luaL_checkoption(
        L: *mut lua_State,
@@ -65,12 +62,12 @@ extern "C" {
 pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
    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;
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char) -> c_int;
 }

 #[inline(always)]
@@ -78,7 +75,8 @@ pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
    luaL_loadfilex(L, f, ptr::null())
 }

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
    pub fn luaL_loadbufferx(
        L: *mut lua_State,
        buff: *const c_char,
@@ -106,12 +104,7 @@ extern "C" {
    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,
-    );
+    pub fn luaL_requiref_(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int);
 }

 //
@@ -170,12 +163,7 @@ pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
 // 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 {
+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())
 }

@@ -78,23 +78,23 @@ pub type lua_Integer = i64;
 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_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;

 // Type for functions that read/write blocks when loading/dumping Lua chunks
+#[rustfmt::skip]
 pub type lua_Reader =
-    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+#[rustfmt::skip]
 pub type lua_Writer =
-    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+    unsafe extern "C-unwind" 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;
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
    //
    // State manipulation
    //
@@ -155,20 +155,19 @@ 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" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
    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" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
    //
    // Push functions (C -> stack)
    //
@@ -223,13 +222,7 @@ extern "C" {
    //
    // '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_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,
@@ -262,16 +255,12 @@ pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_in
    lua_pcallk(L, n, r, f, 0, None)
 }

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
    //
    // Coroutine functions
    //
-    pub fn lua_yieldk(
-        L: *mut lua_State,
-        nresults: c_int,
-        ctx: c_int,
-        k: Option<lua_CFunction>,
-    ) -> c_int;
+    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;
@@ -298,15 +287,18 @@ pub const LUA_GCISRUNNING: c_int = 9;
 pub const LUA_GCGEN: c_int = 10;
 pub const LUA_GCINC: c_int = 11;

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
    //
    // Miscellaneous functions
    //
-    pub fn lua_error(L: *mut lua_State) -> !;
+    #[link_name = "lua_error"]
+    fn lua_error_(L: *mut lua_State) -> c_int;
    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);
@@ -314,6 +306,15 @@ extern "C" {
    pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut c_void);
 }

+// lua_error does not return but is declared to return int, and Rust translates
+// ! to void which can cause link-time errors if the platform linker is aware
+// of return types and requires they match (for example: wasm does this).
+#[inline(always)]
+pub unsafe fn lua_error(L: *mut lua_State) -> ! {
+    lua_error_(L);
+    unreachable!();
+}
+
 //
 // Some useful macros (implemented as Rust functions)
 //
@@ -405,6 +406,14 @@ pub unsafe fn lua_pushglobaltable(L: *mut lua_State) {
    lua_rawgeti_(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS as _)
 }

+#[inline(always)]
+pub unsafe fn lua_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void {
+    if lua_islightuserdata(L, idx) != 0 {
+        return lua_touserdata(L, idx);
+    }
+    ptr::null_mut()
+}
+
 #[inline(always)]
 pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
    lua_tolstring(L, i, ptr::null_mut())
@@ -437,9 +446,10 @@ 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);
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
    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;
@@ -450,7 +460,7 @@ extern "C" {
    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_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;
@@ -14,7 +14,8 @@ pub const LUA_MATHLIBNAME: &str = "math";
 pub const LUA_DBLIBNAME: &str = "debug";
 pub const LUA_LOADLIBNAME: &str = "package";

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua52", kind = "raw-dylib"))]
+extern "C-unwind" {
    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;
@@ -1,16 +1,11 @@
-//! MLua compatibility layer for Lua 5.2
+//! MLua compatibility layer for Lua 5.3

 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 {
+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);
@@ -20,20 +20,18 @@ pub struct luaL_Reg {
    pub func: lua_CFunction,
 }

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
    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;
+    #[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_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;
@@ -49,7 +47,7 @@ extern "C" {
    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_error(L: *mut lua_State, fmt: *const c_char, ...) -> c_int;

    pub fn luaL_checkoption(
        L: *mut lua_State,
@@ -66,12 +64,12 @@ extern "C" {
 pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
    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;
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char) -> c_int;
 }

 #[inline(always)]
@@ -79,7 +77,8 @@ pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
    luaL_loadfilex(L, f, ptr::null())
 }

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
    pub fn luaL_loadbufferx(
        L: *mut lua_State,
        buff: *const c_char,
@@ -106,12 +105,7 @@ extern "C" {

    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,
-    );
+    pub fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int);
 }

 //
@@ -167,15 +161,15 @@ pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
    lua::lua_getfield(L, lua::LUA_REGISTRYINDEX, n);
 }

+#[inline(always)]
+pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) -> *const c_char {
+    luaL_tolstring_(L, lua::lua_absindex(L, idx), len)
+}
+
 // 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 {
+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())
 }

@@ -1,9 +1,8 @@
 //! 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;
+use std::{mem, ptr};

 // Mark for precompiled code (`<esc>Lua`)
 pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
@@ -82,27 +81,27 @@ pub type lua_Unsigned = u64;
 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;
+pub type lua_CFunction = unsafe extern "C-unwind" 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;
+    unsafe extern "C-unwind" 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
+#[rustfmt::skip]
 pub type lua_Reader =
-    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+#[rustfmt::skip]
 pub type lua_Writer =
-    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+    unsafe extern "C-unwind" 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;
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
    //
    // State manipulation
    //
@@ -167,20 +166,19 @@ 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" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
    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" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
    //
    // Push functions (C -> stack)
    //
@@ -252,12 +250,7 @@ extern "C" {
        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;
+    pub fn lua_dump(L: *mut lua_State, writer: lua_Writer, data: *mut c_void, strip: c_int) -> c_int;
 }

 #[inline(always)]
@@ -270,7 +263,8 @@ pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_in
    lua_pcallk(L, n, r, f, 0, None)
 }

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
    //
    // Coroutine functions
    //
@@ -304,15 +298,18 @@ pub const LUA_GCSETPAUSE: c_int = 6;
 pub const LUA_GCSETSTEPMUL: c_int = 7;
 pub const LUA_GCISRUNNING: c_int = 9;

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
    //
    // Miscellaneous functions
    //
-    pub fn lua_error(L: *mut lua_State) -> !;
+    #[link_name = "lua_error"]
+    fn lua_error_(L: *mut lua_State) -> c_int;
    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);
@@ -321,6 +318,15 @@ extern "C" {
    pub fn lua_setallocf(L: *mut lua_State, f: lua_Alloc, ud: *mut c_void);
 }

+// lua_error does not return but is declared to return int, and Rust translates
+// ! to void which can cause link-time errors if the platform linker is aware
+// of return types and requires they match (for example: wasm does this).
+#[inline(always)]
+pub unsafe fn lua_error(L: *mut lua_State) -> ! {
+    lua_error_(L);
+    unreachable!();
+}
+
 //
 // Some useful macros (implemented as Rust functions)
 //
@@ -412,6 +418,14 @@ 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_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void {
+    if lua_islightuserdata(L, idx) != 0 {
+        return lua_touserdata(L, idx);
+    }
+    ptr::null_mut()
+}
+
 #[inline(always)]
 pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
    lua_tolstring(L, i, ptr::null_mut())
@@ -461,9 +475,10 @@ 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);
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
    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;
@@ -15,7 +15,8 @@ pub const LUA_MATHLIBNAME: &str = "math";
 pub const LUA_DBLIBNAME: &str = "debug";
 pub const LUA_LOADLIBNAME: &str = "package";

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua53", kind = "raw-dylib"))]
+extern "C-unwind" {
    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;
@@ -20,7 +20,8 @@ pub struct luaL_Reg {
    pub func: lua_CFunction,
 }

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
    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;
@@ -28,12 +29,8 @@ extern "C" {
    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_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;
@@ -49,7 +46,7 @@ extern "C" {
    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_error(L: *mut lua_State, fmt: *const c_char, ...) -> c_int;

    pub fn luaL_checkoption(
        L: *mut lua_State,
@@ -66,12 +63,12 @@ extern "C" {
 pub const LUA_NOREF: c_int = -2;
 pub const LUA_REFNIL: c_int = -1;

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
    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;
+    pub fn luaL_loadfilex(L: *mut lua_State, filename: *const c_char, mode: *const c_char) -> c_int;
 }

 #[inline(always)]
@@ -79,7 +76,8 @@ pub unsafe fn luaL_loadfile(L: *mut lua_State, f: *const c_char) -> c_int {
    luaL_loadfilex(L, f, ptr::null())
 }

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
    pub fn luaL_loadbufferx(
        L: *mut lua_State,
        buff: *const c_char,
@@ -108,12 +106,7 @@ extern "C" {

    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,
-    );
+    pub fn luaL_requiref(L: *mut lua_State, modname: *const c_char, openf: lua_CFunction, glb: c_int);
 }

 //
@@ -172,12 +165,7 @@ pub unsafe fn luaL_getmetatable(L: *mut lua_State, n: *const c_char) {
 // 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 {
+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())
 }

@@ -1,9 +1,8 @@
 //! 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;
+use std::{mem, ptr};

 // Mark for precompiled code (`<esc>Lua`)
 pub const LUA_SIGNATURE: &[u8] = b"\x1bLua";
@@ -81,31 +80,30 @@ pub type lua_Unsigned = u64;
 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;
+pub type lua_CFunction = unsafe extern "C-unwind" 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;
+    unsafe extern "C-unwind" 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
+#[rustfmt::skip]
 pub type lua_Reader =
-    unsafe extern "C" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+    unsafe extern "C-unwind" fn(L: *mut lua_State, ud: *mut c_void, sz: *mut usize) -> *const c_char;
+#[rustfmt::skip]
 pub type lua_Writer =
-    unsafe extern "C" fn(L: *mut lua_State, p: *const c_void, sz: usize, ud: *mut c_void) -> c_int;
+    unsafe extern "C-unwind" 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;
+#[rustfmt::skip]
+pub type lua_Alloc =
+    unsafe extern "C-unwind" 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);
+pub type lua_WarnFunction = unsafe extern "C-unwind" fn(ud: *mut c_void, msg: *const c_char, tocont: c_int);

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
    //
    // State manipulation
    //
@@ -149,13 +147,21 @@ extern "C" {
    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;
+    #[link_name = "lua_rawlen"]
+    fn lua_rawlen_(L: *mut lua_State, idx: c_int) -> lua_Unsigned;
    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;
 }

+// lua_rawlen's return type changed from size_t to lua_Unsigned int in Lua 5.4.
+// This adapts the crate API to the new Lua ABI.
+#[inline(always)]
+pub unsafe fn lua_rawlen(L: *mut lua_State, idx: c_int) -> usize {
+    lua_rawlen_(L, idx) as usize
+}
+
 //
 // Comparison and arithmetic functions
 //
@@ -174,20 +180,19 @@ 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" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
+    pub fn lua_arith(L: *mut lua_State, op: c_int);
    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" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
    //
    // Push functions (C -> stack)
    //
@@ -259,12 +264,7 @@ extern "C" {
        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;
+    pub fn lua_dump(L: *mut lua_State, writer: lua_Writer, data: *mut c_void, strip: c_int) -> c_int;
 }

 #[inline(always)]
@@ -277,7 +277,8 @@ pub unsafe fn lua_pcall(L: *mut lua_State, n: c_int, r: c_int, f: c_int) -> c_in
    lua_pcallk(L, n, r, f, 0, None)
 }

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
    //
    // Coroutine functions
    //
@@ -287,12 +288,7 @@ extern "C" {
        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_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;
 }
@@ -305,7 +301,8 @@ pub unsafe fn lua_yield(L: *mut lua_State, n: c_int) -> c_int {
 //
 // Warning-related functions
 //
-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
    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);
 }
@@ -325,15 +322,18 @@ pub const LUA_GCISRUNNING: c_int = 9;
 pub const LUA_GCGEN: c_int = 10;
 pub const LUA_GCINC: c_int = 11;

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
    pub fn lua_gc(L: *mut lua_State, what: c_int, ...) -> c_int;
 }

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
    //
    // Miscellaneous functions
    //
-    pub fn lua_error(L: *mut lua_State) -> !;
+    #[link_name = "lua_error"]
+    fn lua_error_(L: *mut lua_State) -> c_int;
    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);
@@ -345,6 +345,15 @@ extern "C" {
    pub fn lua_closeslot(L: *mut lua_State, idx: c_int);
 }

+// lua_error does not return but is declared to return int, and Rust translates
+// ! to void which can cause link-time errors if the platform linker is aware
+// of return types and requires they match (for example: wasm does this).
+#[inline(always)]
+pub unsafe fn lua_error(L: *mut lua_State) -> ! {
+    lua_error_(L);
+    unreachable!();
+}
+
 //
 // Some useful macros (implemented as Rust functions)
 //
@@ -436,6 +445,14 @@ 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_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void {
+    if lua_islightuserdata(L, idx) != 0 {
+        return lua_touserdata(L, idx);
+    }
+    ptr::null_mut()
+}
+
 #[inline(always)]
 pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
    lua_tolstring(L, i, ptr::null_mut())
@@ -500,9 +517,10 @@ 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);
+pub type lua_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
    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;
@@ -14,7 +14,8 @@ pub const LUA_MATHLIBNAME: &str = "math";
 pub const LUA_DBLIBNAME: &str = "debug";
 pub const LUA_LOADLIBNAME: &str = "package";

-extern "C" {
+#[cfg_attr(all(windows, raw_dylib), link(name = "lua54", kind = "raw-dylib"))]
+extern "C-unwind" {
    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;
@@ -3,9 +3,8 @@
 //! 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 std::{mem, ptr};

 use super::lauxlib::*;
 use super::lua::*;
@@ -53,11 +52,7 @@ unsafe fn compat53_findfield(L: *mut lua_State, objidx: c_int, level: c_int) ->
    0 // not found
 }

-unsafe fn compat53_pushglobalfuncname(
-    L: *mut lua_State,
-    level: c_int,
-    ar: *mut lua_Debug,
-) -> c_int {
+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);
@@ -281,12 +276,7 @@ pub unsafe fn lua_pushglobaltable(L: *mut lua_State) {
 }

 #[inline(always)]
-pub unsafe fn lua_resume(
-    L: *mut lua_State,
-    from: *mut lua_State,
-    narg: c_int,
-    nres: *mut c_int,
-) -> c_int {
+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);
@@ -323,7 +313,7 @@ pub unsafe fn luaL_getmetafield(L: *mut lua_State, obj: c_int, e: *const c_char)
 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"));
+        lua_setfield(L, -2, cstr!("__type"));
        1
    } else {
        0
@@ -345,18 +335,10 @@ pub unsafe fn luaL_loadbufferx(
    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,
-            );
+            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,
-            );
+            lua_pushfstring(L, cstr!("attempt to load a text chunk (mode is '%s')"), mode);
            return LUA_ERRSYNTAX;
        }
    }
@@ -397,12 +379,7 @@ pub unsafe fn luaL_len(L: *mut lua_State, idx: c_int) -> lua_Integer {
    res
 }

-pub unsafe fn luaL_traceback(
-    L: *mut lua_State,
-    L1: *mut lua_State,
-    msg: *const c_char,
-    mut level: c_int,
-) {
+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);
@@ -436,10 +413,10 @@ pub unsafe fn luaL_traceback(
    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 {
+pub unsafe fn luaL_tolstring(L: *mut lua_State, mut idx: c_int, len: *mut usize) -> *const c_char {
+    idx = lua_absindex(L, idx);
    if luaL_callmeta(L, idx, cstr!("__tostring")) == 0 {
-        let t = lua_type(L, idx);
-        match t {
+        match lua_type(L, idx) {
            LUA_TNIL => {
                lua_pushliteral(L, "nil");
            }
@@ -453,8 +430,8 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
                    lua_pushliteral(L, "true");
                }
            }
-            _ => {
-                let tt = luaL_getmetafield(L, idx, cstr!("__name"));
+            t => {
+                let tt = luaL_getmetafield(L, idx, cstr!("__type"));
                let name = if tt == LUA_TSTRING {
                    lua_tostring(L, -1)
                } else {
@@ -462,7 +439,7 @@ pub unsafe fn luaL_tolstring(L: *mut lua_State, idx: c_int, len: *mut usize) ->
                };
                lua_pushfstring(L, cstr!("%s: %p"), name, lua_topointer(L, idx));
                if tt != LUA_TNIL {
-                    lua_replace(L, -2);
+                    lua_replace(L, -2); // remove '__type'
                }
            }
        };
@@ -494,12 +471,7 @@ pub unsafe fn luaL_getsubtable(L: *mut lua_State, idx: c_int, fname: *const c_ch
    0
 }

-pub unsafe fn luaL_requiref(
-    L: *mut lua_State,
-    modname: *const c_char,
-    openf: lua_CFunction,
-    glb: c_int,
-) {
+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 {
@@ -3,9 +3,7 @@
 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,
-};
+use super::lua::{self, lua_CFunction, lua_Integer, lua_Number, lua_State, lua_Unsigned, LUA_REGISTRYINDEX};

 #[repr(C)]
 pub struct luaL_Reg {
@@ -13,7 +11,7 @@ pub struct luaL_Reg {
    pub func: lua_CFunction,
 }

-extern "C" {
+extern "C-unwind" {
    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;
@@ -52,6 +50,8 @@ extern "C" {
    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_checkbuffer(L: *mut lua_State, narg: c_int, len: *mut usize) -> *mut c_void;
+
    pub fn luaL_where(L: *mut lua_State, lvl: c_int);

    #[link_name = "luaL_errorL"]
@@ -142,9 +142,12 @@ pub unsafe fn luaL_sandbox(L: *mut lua_State, enabled: c_int) {

    // set all builtin metatables to read-only
    lua_pushliteral(L, "");
-    lua_getmetatable(L, -1);
-    lua_setreadonly(L, -1, enabled);
-    lua_pop(L, 2);
+    if lua_getmetatable(L, -1) != 0 {
+        lua_setreadonly(L, -1, enabled);
+        lua_pop(L, 2);
+    } else {
+        lua_pop(L, 1);
+    }

    // set globals to readonly and activate safeenv since the env is immutable
    lua_setreadonly(L, LUA_GLOBALSINDEX, enabled);
@@ -152,5 +155,48 @@ pub unsafe fn luaL_sandbox(L: *mut lua_State, enabled: c_int) {
 }

 //
-// TODO: Generic Buffer Manipulation
+// Generic Buffer Manipulation
 //
+
+/// Buffer size used for on-stack string operations. This limit depends on native stack size.
+pub const LUA_BUFFERSIZE: usize = 512;
+
+#[repr(C)]
+pub struct luaL_Strbuf {
+    p: *mut c_char,   // current position in buffer
+    end: *mut c_char, // end of the current buffer
+    L: *mut lua_State,
+    storage: *mut c_void, // TString
+    buffer: [c_char; LUA_BUFFERSIZE],
+}
+
+// For compatibility
+pub type luaL_Buffer = luaL_Strbuf;
+
+extern "C-unwind" {
+    pub fn luaL_buffinit(L: *mut lua_State, B: *mut luaL_Strbuf);
+    pub fn luaL_buffinitsize(L: *mut lua_State, B: *mut luaL_Strbuf, size: usize) -> *mut c_char;
+    pub fn luaL_prepbuffsize(B: *mut luaL_Strbuf, size: usize) -> *mut c_char;
+    pub fn luaL_addlstring(B: *mut luaL_Strbuf, s: *const c_char, l: usize);
+    pub fn luaL_addvalue(B: *mut luaL_Strbuf);
+    pub fn luaL_addvalueany(B: *mut luaL_Strbuf, idx: c_int);
+    pub fn luaL_pushresult(B: *mut luaL_Strbuf);
+    pub fn luaL_pushresultsize(B: *mut luaL_Strbuf, size: usize);
+}
+
+pub unsafe fn luaL_addchar(B: *mut luaL_Strbuf, c: c_char) {
+    if (*B).p >= (*B).end {
+        luaL_prepbuffsize(B, 1);
+    }
+    *(*B).p = c;
+    (*B).p = (*B).p.add(1);
+}
+
+pub unsafe fn luaL_addstring(B: *mut luaL_Strbuf, s: *const c_char) {
+    // Calculate length of s
+    let mut len = 0;
+    while *s.add(len) != 0 {
+        len += 1;
+    }
+    luaL_addlstring(B, s, len);
+}
@@ -2,13 +2,19 @@

 use std::marker::{PhantomData, PhantomPinned};
 use std::os::raw::{c_char, c_double, c_float, c_int, c_uint, c_void};
-use std::ptr;
+use std::{mem, ptr};

 // Option for multiple returns in 'lua_pcall' and 'lua_call'
 pub const LUA_MULTRET: c_int = -1;

 // Max number of Lua stack slots
-const LUAI_MAXCSTACK: c_int = 100000;
+const LUAI_MAXCSTACK: c_int = 1000000;
+
+// Number of valid Lua userdata tags
+const LUA_UTAG_LIMIT: c_int = 128;
+
+// Number of valid Lua lightuserdata tags
+const LUA_LUTAG_LIMIT: c_int = 128;

 //
 // Pseudo-indices
@@ -55,6 +61,7 @@ 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;
+pub const LUA_TBUFFER: c_int = 10;

 /// Guaranteed number of Lua stack slots available to a C function.
 pub const LUA_MINSTACK: c_int = 20;
@@ -69,21 +76,23 @@ pub type lua_Integer = c_int;
 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;
+pub type lua_CFunction = unsafe extern "C-unwind" fn(L: *mut lua_State) -> c_int;
+pub type lua_Continuation = unsafe extern "C-unwind" 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);
+pub type lua_Udestructor = unsafe extern "C-unwind" fn(*mut c_void);
+pub type lua_Destructor = unsafe extern "C-unwind" fn(L: *mut lua_State, *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;
+pub type lua_Alloc =
+    unsafe extern "C-unwind" fn(ud: *mut c_void, ptr: *mut c_void, osize: usize, nsize: usize) -> *mut c_void;

-extern "C" {
+/// Returns Luau release version (eg. `0.xxx`).
+pub const fn luau_version() -> Option<&'static str> {
+    option_env!("LUAU_VERSION")
+}
+
+extern "C-unwind" {
    //
    // State manipulation
    //
@@ -137,10 +146,13 @@ extern "C" {
    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_tolightuserdata(L: *mut lua_State, idx: c_int) -> *mut c_void;
+    pub fn lua_tolightuserdatatagged(L: *mut lua_State, idx: c_int, tag: c_int) -> *mut c_void;
    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_lightuserdatatag(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_tobuffer(L: *mut lua_State, idx: c_int, len: *mut usize) -> *mut c_void;
    pub fn lua_topointer(L: *mut lua_State, idx: c_int) -> *const c_void;

    //
@@ -150,7 +162,10 @@ extern "C" {
    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);
+    #[cfg(not(feature = "luau-vector4"))]
    pub fn lua_pushvector(L: *mut lua_State, x: c_float, y: c_float, z: c_float);
+    #[cfg(feature = "luau-vector4")]
+    pub fn lua_pushvector(L: *mut lua_State, x: c_float, y: c_float, z: c_float, w: c_float);
    #[link_name = "lua_pushlstring"]
    pub fn lua_pushlstring_(L: *mut lua_State, s: *const c_char, l: usize);
    #[link_name = "lua_pushstring"]
@@ -168,10 +183,12 @@ extern "C" {
    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_pushlightuserdatatagged(L: *mut lua_State, p: *mut c_void, tag: c_int);
    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;

+    pub fn lua_newbuffer(L: *mut lua_State, sz: usize) -> *mut c_void;
+
    //
    // Get functions (Lua -> stack)
    //
@@ -242,14 +259,14 @@ pub const LUA_GCSETGOAL: c_int = 7;
 pub const LUA_GCSETSTEPMUL: c_int = 8;
 pub const LUA_GCSETSTEPSIZE: c_int = 9;

-extern "C" {
+extern "C-unwind" {
    pub fn lua_gc(L: *mut lua_State, what: c_int, data: c_int) -> c_int;
 }

 //
 // Memory statistics
 //
-extern "C" {
+extern "C-unwind" {
    pub fn lua_setmemcat(L: *mut lua_State, category: c_int);
    pub fn lua_totalbytes(L: *mut lua_State, category: c_int) -> usize;
 }
@@ -257,7 +274,7 @@ extern "C" {
 //
 // Miscellaneous functions
 //
-extern "C" {
+extern "C-unwind" {
    pub fn lua_error(L: *mut lua_State) -> !;
    pub fn lua_next(L: *mut lua_State, idx: c_int) -> c_int;
    pub fn lua_rawiter(L: *mut lua_State, idx: c_int, iter: c_int) -> c_int;
@@ -265,13 +282,15 @@ extern "C" {
    // TODO: lua_encodepointer
    pub fn lua_clock() -> c_double;
    pub fn lua_setuserdatatag(L: *mut lua_State, idx: c_int, tag: c_int);
-    pub fn lua_setuserdatadtor(
-        L: *mut lua_State,
-        tag: c_int,
-        dtor: Option<unsafe extern "C" fn(*mut lua_State, *mut c_void)>,
-    );
+    pub fn lua_setuserdatadtor(L: *mut lua_State, tag: c_int, dtor: Option<lua_Destructor>);
+    pub fn lua_getuserdatadtor(L: *mut lua_State, tag: c_int) -> Option<lua_Destructor>;
+    pub fn lua_setuserdatametatable(L: *mut lua_State, tag: c_int, idx: c_int);
+    pub fn lua_getuserdatametatable(L: *mut lua_State, tag: c_int);
+    pub fn lua_setlightuserdataname(L: *mut lua_State, tag: c_int, name: *const c_char);
+    pub fn lua_getlightuserdataname(L: *mut lua_State, tag: c_int) -> *const c_char;
    pub fn lua_clonefunction(L: *mut lua_State, idx: c_int);
    pub fn lua_cleartable(L: *mut lua_State, idx: c_int);
+    pub fn lua_getallocf(L: *mut lua_State, ud: *mut *mut c_void) -> lua_Alloc;
 }

 //
@@ -280,7 +299,7 @@ extern "C" {
 pub const LUA_NOREF: c_int = -1;
 pub const LUA_REFNIL: c_int = 0;

-extern "C" {
+extern "C-unwind" {
    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);
 }
@@ -319,6 +338,15 @@ pub unsafe fn lua_newuserdata(L: *mut lua_State, sz: usize) -> *mut c_void {
    lua_newuserdatatagged(L, sz, 0)
 }

+#[inline(always)]
+pub unsafe fn lua_newuserdata_t<T>(L: *mut lua_State) -> *mut T {
+    unsafe extern "C-unwind" fn destructor<T>(ud: *mut c_void) {
+        ptr::drop_in_place(ud as *mut T);
+    }
+
+    lua_newuserdatadtor(L, mem::size_of::<T>(), destructor::<T>) as *mut T
+}
+
 // TODO: lua_strlen

 #[inline(always)]
@@ -356,6 +384,11 @@ 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_isbuffer(L: *mut lua_State, n: c_int) -> c_int {
+    (lua_type(L, n) == LUA_TBUFFER) 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
@@ -373,27 +406,31 @@ pub unsafe fn lua_pushliteral(L: *mut lua_State, s: &'static str) {
    lua_pushlstring_(L, c_str.as_ptr(), c_str.as_bytes().len())
 }

+#[inline(always)]
 pub unsafe fn lua_pushcfunction(L: *mut lua_State, f: lua_CFunction) {
    lua_pushcclosurek(L, f, ptr::null(), 0, None)
 }

+#[inline(always)]
 pub unsafe fn lua_pushcfunctiond(L: *mut lua_State, f: lua_CFunction, debugname: *const c_char) {
    lua_pushcclosurek(L, f, debugname, 0, None)
 }

+#[inline(always)]
 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,
-) {
+#[inline(always)]
+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_pushlightuserdata(L: *mut lua_State, p: *mut c_void) {
+    lua_pushlightuserdatatagged(L, p, 0)
+}
+
 #[inline(always)]
 pub unsafe fn lua_setglobal(L: *mut lua_State, var: *const c_char) {
    lua_setfield(L, LUA_GLOBALSINDEX, var)
@@ -417,9 +454,9 @@ pub unsafe fn lua_tostring(L: *mut lua_State, i: c_int) -> *const c_char {
 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_Hook = unsafe extern "C-unwind" fn(L: *mut lua_State, ar: *mut lua_Debug);

-pub type lua_Coverage = unsafe extern "C" fn(
+pub type lua_Coverage = unsafe extern "C-unwind" fn(
    context: *mut c_void,
    function: *const c_char,
    linedefined: c_int,
@@ -428,14 +465,9 @@ pub type lua_Coverage = unsafe extern "C" fn(
    size: usize,
 );

-extern "C" {
+extern "C-unwind" {
    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_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;
@@ -443,19 +475,9 @@ extern "C" {
    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,
-    ) -> c_int;
+    pub fn lua_breakpoint(L: *mut lua_State, funcindex: c_int, line: c_int, enabled: c_int) -> c_int;

-    pub fn lua_getcoverage(
-        L: *mut lua_State,
-        funcindex: c_int,
-        context: *mut c_void,
-        callback: lua_Coverage,
-    );
+    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;
 }
@@ -481,30 +503,36 @@ pub struct lua_Debug {
 //

 #[repr(C)]
+#[non_exhaustive]
 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)>,
+    pub interrupt: Option<unsafe extern "C-unwind" 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)>,
+    pub panic: Option<unsafe extern "C-unwind" 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)>,
+    pub userthread: Option<unsafe extern "C-unwind" 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>,
+    pub useratom: Option<unsafe extern "C-unwind" 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)>,
+    pub debugbreak: Option<unsafe extern "C-unwind" 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)>,
+    pub debugstep: Option<unsafe extern "C-unwind" 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)>,
+    pub debuginterrupt: Option<unsafe extern "C-unwind" 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)>,
+    pub debugprotectederror: Option<unsafe extern "C-unwind" fn(L: *mut lua_State)>,
 }

 extern "C" {
    pub fn lua_callbacks(L: *mut lua_State) -> *mut lua_Callbacks;
 }
+
+// Functions from customization lib
+extern "C" {
+    pub fn luau_setfflag(name: *const c_char, value: c_int) -> c_int;
+}
@@ -1,20 +1,39 @@
 //! Contains definitions from `luacode.h`.

 use std::os::raw::{c_char, c_int, c_void};
-use std::slice;
+use std::{ptr, slice};

 #[repr(C)]
+#[non_exhaustive]
 pub struct lua_CompileOptions {
    pub optimizationLevel: c_int,
    pub debugLevel: c_int,
+    pub typeInfoLevel: c_int,
    pub coverageLevel: c_int,
    pub vectorLib: *const c_char,
    pub vectorCtor: *const c_char,
    pub vectorType: *const c_char,
    pub mutableGlobals: *const *const c_char,
+    pub userdataTypes: *const *const c_char,
 }

-extern "C" {
+impl Default for lua_CompileOptions {
+    fn default() -> Self {
+        Self {
+            optimizationLevel: 1,
+            debugLevel: 1,
+            typeInfoLevel: 0,
+            coverageLevel: 0,
+            vectorLib: ptr::null(),
+            vectorCtor: ptr::null(),
+            vectorType: ptr::null(),
+            mutableGlobals: ptr::null(),
+            userdataTypes: ptr::null(),
+        }
+    }
+}
+
+extern "C-unwind" {
    #[link_name = "luau_compile"]
    pub fn luau_compile_(
        source: *const c_char,
@@ -22,7 +41,9 @@ extern "C" {
        options: *mut lua_CompileOptions,
        outsize: *mut usize,
    ) -> *mut c_char;
+}

+extern "C" {
    fn free(p: *mut c_void);
 }

@@ -34,6 +55,7 @@ pub unsafe fn luau_compile(source: &[u8], mut options: lua_CompileOptions) -> Ve
        &mut options,
        &mut outsize,
    );
+    assert!(!data_ptr.is_null(), "luau_compile failed");
    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,11 @@
+//! Contains definitions from `luacodegen.h`.
+
+use std::os::raw::c_int;
+
+use super::lua::lua_State;
+
+extern "C-unwind" {
+    pub fn luau_codegen_supported() -> c_int;
+    pub fn luau_codegen_create(state: *mut lua_State);
+    pub fn luau_codegen_compile(state: *mut lua_State, idx: c_int);
+}
@@ -9,17 +9,19 @@ 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_BUFFERLIBNAME: &str = "buffer";
 pub const LUA_UTF8LIBNAME: &str = "utf8";
 pub const LUA_MATHLIBNAME: &str = "math";
 pub const LUA_DBLIBNAME: &str = "debug";

-extern "C" {
+extern "C-unwind" {
    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_buffer(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;
@@ -4,10 +4,12 @@ pub use compat::*;
 pub use lauxlib::*;
 pub use lua::*;
 pub use luacode::*;
+pub use luacodegen::*;
 pub use lualib::*;

 pub mod compat;
 pub mod lauxlib;
 pub mod lua;
 pub mod luacode;
+pub mod luacodegen;
 pub mod lualib;
@@ -0,0 +1,6 @@
+#[allow(unused_macros)]
+macro_rules! cstr {
+    ($s:expr) => {
+        concat!($s, "\0") as *const str as *const [::std::os::raw::c_char] as *const ::std::os::raw::c_char
+    };
+}
@@ -1,8 +1,8 @@
 [package]
 name = "mlua_derive"
-version = "0.8.0"
+version = "0.9.3"
 authors = ["Aleksandr Orlenko <zxteam@pm.me>"]
-edition = "2018"
+edition = "2021"
 description = "Procedural macros for the mlua crate."
 repository = "https://github.com/khvzak/mlua"
 keywords = ["lua", "mlua"]
@@ -18,7 +18,7 @@ macros = ["proc-macro-error", "itertools", "regex", "once_cell"]
 quote = "1.0"
 proc-macro2 = { version = "1.0", features = ["span-locations"] }
 proc-macro-error = { version = "1.0", optional = true }
-syn = { version = "1.0", features = ["full"] }
-itertools = { version = "0.10", optional = true }
+syn = { version = "2.0", features = ["full"] }
+itertools = { version = "0.12", optional = true }
 regex = { version = "1.4", optional = true }
 once_cell = { version = "1.0", optional = true }
@@ -0,0 +1,31 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, DeriveInput};
+
+pub fn from_lua(input: TokenStream) -> TokenStream {
+    let DeriveInput { ident, generics, .. } = parse_macro_input!(input as DeriveInput);
+
+    let ident_str = ident.to_string();
+    let (impl_generics, ty_generics, _) = generics.split_for_impl();
+    let where_clause = match &generics.where_clause {
+        Some(where_clause) => quote! { #where_clause, Self: 'static + Clone },
+        None => quote! { where Self: 'static + Clone },
+    };
+
+    quote! {
+      impl #impl_generics ::mlua::FromLua for #ident #ty_generics #where_clause {
+        #[inline]
+        fn from_lua(value: ::mlua::Value, _: &::mlua::Lua) -> ::mlua::Result<Self> {
+          match value {
+            ::mlua::Value::UserData(ud) => Ok(ud.borrow::<Self>()?.clone()),
+            _ => Err(::mlua::Error::FromLuaConversionError {
+                from: value.type_name(),
+                to: #ident_str,
+                message: None,
+            }),
+          }
+        }
+      }
+    }
+    .into()
+}
@@ -1,7 +1,8 @@
 use proc_macro::TokenStream;
 use proc_macro2::{Ident, Span};
 use quote::quote;
-use syn::{parse_macro_input, AttributeArgs, Error, ItemFn};
+use syn::meta::ParseNestedMeta;
+use syn::{parse_macro_input, ItemFn, LitStr, Result};

 #[cfg(feature = "macros")]
 use {
@@ -9,30 +10,63 @@ use {
    proc_macro_error::proc_macro_error,
 };

+#[derive(Default)]
+struct ModuleAttributes {
+    name: Option<Ident>,
+    skip_memory_check: bool,
+}
+
+impl ModuleAttributes {
+    fn parse(&mut self, meta: ParseNestedMeta) -> Result<()> {
+        if meta.path.is_ident("name") {
+            match meta.value() {
+                Ok(value) => {
+                    self.name = Some(value.parse::<LitStr>()?.parse()?);
+                }
+                Err(_) => {
+                    return Err(meta.error("`name` attribute must have a value"));
+                }
+            }
+        } else if meta.path.is_ident("skip_memory_check") {
+            if meta.value().is_ok() {
+                return Err(meta.error("`skip_memory_check` attribute have no values"));
+            }
+            self.skip_memory_check = true;
+        } else {
+            return Err(meta.error("unsupported module attribute"));
+        }
+        Ok(())
+    }
+}
+
 #[proc_macro_attribute]
 pub fn lua_module(attr: TokenStream, item: TokenStream) -> TokenStream {
-    let args = parse_macro_input!(attr as AttributeArgs);
-    let func = parse_macro_input!(item as ItemFn);
-
-    if !args.is_empty() {
-        let err = Error::new(Span::call_site(), "the macro does not support arguments")
-            .to_compile_error();
-        return err.into();
+    let mut args = ModuleAttributes::default();
+    if !attr.is_empty() {
+        let args_parser = syn::meta::parser(|meta| args.parse(meta));
+        parse_macro_input!(attr with args_parser);
    }

-    let func_name = func.sig.ident.clone();
-    let ext_entrypoint_name = Ident::new(&format!("luaopen_{}", func_name), Span::call_site());
+    let func = parse_macro_input!(item as ItemFn);
+    let func_name = &func.sig.ident;
+    let module_name = args.name.unwrap_or_else(|| func_name.clone());
+    let ext_entrypoint_name = Ident::new(&format!("luaopen_{module_name}"), Span::call_site());
+    let skip_memory_check = if args.skip_memory_check {
+        quote! { lua.skip_memory_check(true); }
+    } else {
+        quote! {}
+    };

    let wrapped = quote! {
-        ::mlua::require_module_feature!();
+        mlua::require_module_feature!();

        #func

        #[no_mangle]
-        unsafe extern "C" fn #ext_entrypoint_name(state: *mut ::mlua::lua_State) -> ::std::os::raw::c_int {
-            ::mlua::Lua::init_from_ptr(state)
-                .entrypoint1(#func_name)
-                .expect("cannot initialize module")
+        unsafe extern "C-unwind" fn #ext_entrypoint_name(state: *mut mlua::lua_State) -> ::std::os::raw::c_int {
+            let lua = mlua::Lua::init_from_ptr(state);
+            #skip_memory_check
+            lua.entrypoint1(state, #func_name)
        }
    };

@@ -61,30 +95,21 @@ pub fn chunk(input: TokenStream) -> TokenStream {
    });

    let wrapped_code = quote! {{
-        use ::mlua::{AsChunk, ChunkMode, Lua, Result, Value};
+        use mlua::{AsChunk, ChunkMode, Lua, Result, Table};
        use ::std::borrow::Cow;
+        use ::std::cell::Cell;
        use ::std::io::Result as IoResult;
-        use ::std::marker::PhantomData;
-        use ::std::sync::Mutex;

-        fn annotate<'a, F: FnOnce(&'a Lua) -> Result<Value<'a>>>(f: F) -> F { f }
+        struct InnerChunk<F: FnOnce(&Lua) -> Result<Table>>(Cell<Option<F>>);

-        struct InnerChunk<'a, F: FnOnce(&'a Lua) -> Result<Value<'a>>>(Mutex<Option<F>>, PhantomData<&'a ()>);
-
-        impl<'lua, F> AsChunk<'lua> for InnerChunk<'lua, F>
+        impl<F> AsChunk<'static> for InnerChunk<F>
        where
-            F: FnOnce(&'lua Lua) -> Result<Value<'lua>>,
+            F: FnOnce(&Lua) -> Result<Table>,
        {
-            fn source(&self) -> IoResult<Cow<[u8]>> {
-                Ok(Cow::Borrowed((#source).as_bytes()))
-            }
-
-            fn env(&self, lua: &'lua Lua) -> Result<Option<Value<'lua>>> {
+            fn environment(&self, lua: &Lua) -> Result<Option<Table>> {
                if #caps_len > 0 {
-                    if let Ok(mut make_env) = self.0.lock() {
-                        if let Some(make_env) = make_env.take() {
-                            return make_env(lua).map(Some);
-                        }
+                    if let Some(make_env) = self.0.take() {
+                        return make_env(lua).map(Some);
                    }
                }
                Ok(None)
@@ -93,9 +118,13 @@ pub fn chunk(input: TokenStream) -> TokenStream {
            fn mode(&self) -> Option<ChunkMode> {
                Some(ChunkMode::Text)
            }
+
+            fn source(self) -> IoResult<Cow<'static, [u8]>> {
+                Ok(Cow::Borrowed((#source).as_bytes()))
+            }
        }

-        let make_env = annotate(move |lua: &Lua| -> Result<Value> {
+        let make_env = move |lua: &Lua| -> Result<Table> {
            let globals = lua.globals();
            let env = lua.create_table()?;
            let meta = lua.create_table()?;
@@ -106,16 +135,24 @@ pub fn chunk(input: TokenStream) -> TokenStream {
            #(#caps)*

            env.set_metatable(Some(meta));
-            Ok(Value::Table(env))
-        });
+            Ok(env)
+        };

-        &InnerChunk(Mutex::new(Some(make_env)), PhantomData)
+        InnerChunk(Cell::new(Some(make_env)))
    }};

    wrapped_code.into()
 }

+#[cfg(feature = "macros")]
+#[proc_macro_derive(FromLua)]
+pub fn from_lua(input: TokenStream) -> TokenStream {
+    from_lua::from_lua(input)
+}
+
 #[cfg(feature = "macros")]
 mod chunk;
 #[cfg(feature = "macros")]
+mod from_lua;
+#[cfg(feature = "macros")]
 mod token;
@@ -1,9 +1,6 @@
-use std::{
-    cmp::{Eq, PartialEq},
-    fmt::{self, Display, Formatter},
-    iter::IntoIterator,
-    vec::IntoIter,
-};
+use std::cmp::{Eq, PartialEq};
+use std::fmt::{self, Display, Formatter};
+use std::vec::IntoIter;

 use itertools::Itertools;
 use once_cell::sync::Lazy;
@@ -48,10 +45,7 @@ fn span_pos(span: &Span) -> (Pos, Pos) {
        return fallback_span_pos(span);
    }

-    (
-        Pos::new(start.line, start.column),
-        Pos::new(end.line, end.column),
-    )
+    (Pos::new(start.line, start.column), Pos::new(end.line, end.column))
 }

 fn parse_pos(span: &Span) -> Option<(usize, usize)> {
@@ -59,7 +53,7 @@ fn parse_pos(span: &Span) -> Option<(usize, usize)> {

    static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"bytes\(([0-9]+)\.\.([0-9]+)\)").unwrap());

-    match RE.captures(&format!("{:?}", span)) {
+    match RE.captures(&format!("{span:?}")) {
        Some(caps) => match (caps.get(1), caps.get(2)) {
            (Some(start), Some(end)) => Some((
                match start.as_str().parse() {
@@ -80,9 +74,7 @@ fn parse_pos(span: &Span) -> Option<(usize, usize)> {
 fn fallback_span_pos(span: &Span) -> (Pos, Pos) {
    let (start, end) = match parse_pos(span) {
        Some(v) => v,
-        None => proc_macro_error::abort_call_site!(
-            "Cannot retrieve span information; please use nightly"
-        ),
+        None => proc_macro_error::abort_call_site!("Cannot retrieve span information; please use nightly"),
    };
    (Pos::new(1, start), Pos::new(1, end))
 }
@@ -0,0 +1,4 @@
+imports_granularity = "Module"
+max_width = 110
+comment_width = 100
+wrap_comments = true
@@ -5,23 +5,17 @@ use std::io::Result as IoResult;
 use std::path::{Path, PathBuf};
 use std::string::String as StdString;

-use crate::error::{Error, Result};
-use crate::ffi;
+use crate::error::{Error, ErrorContext, Result};
 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};
+use crate::state::{Lua, WeakLua};
+use crate::table::Table;
+use crate::value::{FromLuaMulti, IntoLua, IntoLuaMulti};

 /// 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) -> IoResult<Cow<[u8]>>;
-
+pub trait AsChunk<'a> {
    /// Returns optional chunk name
    fn name(&self) -> Option<StdString> {
        None
@@ -30,7 +24,8 @@ pub trait AsChunk<'lua> {
    /// 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>>> {
+    fn environment(&self, lua: &Lua) -> Result<Option<Table>> {
+        let _lua = lua; // suppress warning
        Ok(None)
    }

@@ -38,62 +33,77 @@ pub trait AsChunk<'lua> {
    fn mode(&self) -> Option<ChunkMode> {
        None
    }
+
+    /// Returns chunk data (can be text or binary)
+    fn source(self) -> IoResult<Cow<'a, [u8]>>;
 }

-impl<'lua> AsChunk<'lua> for str {
-    fn source(&self) -> IoResult<Cow<[u8]>> {
+impl<'a> AsChunk<'a> for &'a str {
+    fn source(self) -> IoResult<Cow<'a, [u8]>> {
        Ok(Cow::Borrowed(self.as_ref()))
    }
 }

-impl<'lua> AsChunk<'lua> for StdString {
-    fn source(&self) -> IoResult<Cow<[u8]>> {
+impl AsChunk<'static> for StdString {
+    fn source(self) -> IoResult<Cow<'static, [u8]>> {
+        Ok(Cow::Owned(self.into_bytes()))
+    }
+}
+
+impl<'a> AsChunk<'a> for &'a StdString {
+    fn source(self) -> IoResult<Cow<'a, [u8]>> {
+        Ok(Cow::Borrowed(self.as_bytes()))
+    }
+}
+
+impl<'a> AsChunk<'a> for &'a [u8] {
+    fn source(self) -> IoResult<Cow<'a, [u8]>> {
+        Ok(Cow::Borrowed(self))
+    }
+}
+
+impl AsChunk<'static> for Vec<u8> {
+    fn source(self) -> IoResult<Cow<'static, [u8]>> {
+        Ok(Cow::Owned(self))
+    }
+}
+
+impl<'a> AsChunk<'a> for &'a Vec<u8> {
+    fn source(self) -> IoResult<Cow<'a, [u8]>> {
        Ok(Cow::Borrowed(self.as_ref()))
    }
 }

-impl<'lua> AsChunk<'lua> for [u8] {
-    fn source(&self) -> IoResult<Cow<[u8]>> {
-        Ok(Cow::Borrowed(self))
-    }
-}
-
-impl<'lua> AsChunk<'lua> for Vec<u8> {
-    fn source(&self) -> IoResult<Cow<[u8]>> {
-        Ok(Cow::Borrowed(self))
-    }
-}
-
-impl<'lua> AsChunk<'lua> for Path {
-    fn source(&self) -> IoResult<Cow<[u8]>> {
-        std::fs::read(self).map(Cow::Owned)
-    }
-
+impl AsChunk<'static> for &Path {
    fn name(&self) -> Option<StdString> {
        Some(format!("@{}", self.display()))
    }
-}

-impl<'lua> AsChunk<'lua> for PathBuf {
-    fn source(&self) -> IoResult<Cow<[u8]>> {
+    fn source(self) -> IoResult<Cow<'static, [u8]>> {
        std::fs::read(self).map(Cow::Owned)
    }
+}

+impl AsChunk<'static> for PathBuf {
    fn name(&self) -> Option<StdString> {
        Some(format!("@{}", self.display()))
    }
+
+    fn source(self) -> IoResult<Cow<'static, [u8]>> {
+        std::fs::read(self).map(Cow::Owned)
+    }
 }

 /// 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: IoResult<Cow<'a, [u8]>>,
-    pub(crate) name: Option<StdString>,
-    pub(crate) env: Result<Option<Value<'lua>>>,
+pub struct Chunk<'a> {
+    pub(crate) lua: WeakLua,
+    pub(crate) name: StdString,
+    pub(crate) env: Result<Option<Table>>,
    pub(crate) mode: Option<ChunkMode>,
+    pub(crate) source: IoResult<Cow<'a, [u8]>>,
    #[cfg(feature = "luau")]
    pub(crate) compiler: Option<Compiler>,
 }
@@ -112,32 +122,38 @@ pub enum ChunkMode {
 pub struct Compiler {
    optimization_level: u8,
    debug_level: u8,
+    type_info_level: u8,
    coverage_level: u8,
    vector_lib: Option<String>,
    vector_ctor: Option<String>,
+    vector_type: Option<String>,
    mutable_globals: Vec<String>,
+    userdata_types: Vec<String>,
 }

 #[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,
-            vector_lib: None,
-            vector_ctor: None,
-            mutable_globals: Vec::new(),
-        }
+        Self::new()
    }
 }

 #[cfg(any(feature = "luau", doc))]
 impl Compiler {
    /// Creates Luau compiler instance with default options
-    pub fn new() -> Self {
-        Compiler::default()
+    pub const fn new() -> Self {
+        // Defaults are taken from luacode.h
+        Compiler {
+            optimization_level: 1,
+            debug_level: 1,
+            type_info_level: 0,
+            coverage_level: 0,
+            vector_lib: None,
+            vector_ctor: None,
+            vector_type: None,
+            mutable_globals: Vec::new(),
+            userdata_types: Vec::new(),
+        }
    }

    /// Sets Luau compiler optimization level.
@@ -146,7 +162,8 @@ impl Compiler {
    /// * 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 {
+    #[must_use]
+    pub const fn set_optimization_level(mut self, level: u8) -> Self {
        self.optimization_level = level;
        self
    }
@@ -157,42 +174,71 @@ impl Compiler {
    /// * 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 {
+    #[must_use]
+    pub const fn set_debug_level(mut self, level: u8) -> Self {
        self.debug_level = level;
        self
    }

+    /// Sets Luau type information level used to guide native code generation decisions.
+    ///
+    /// Possible values:
+    /// * 0 - generate for native modules (default)
+    /// * 1 - generate for all modules
+    pub const fn set_type_info_level(mut self, level: u8) -> Self {
+        self.type_info_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 {
+    #[must_use]
+    pub const fn set_coverage_level(mut self, level: u8) -> Self {
        self.coverage_level = level;
        self
    }

    #[doc(hidden)]
-    pub fn set_vector_lib(mut self, lib: Option<String>) -> Self {
-        self.vector_lib = lib;
+    #[must_use]
+    pub fn set_vector_lib(mut self, lib: impl Into<String>) -> Self {
+        self.vector_lib = Some(lib.into());
        self
    }

    #[doc(hidden)]
-    pub fn set_vector_ctor(mut self, ctor: Option<String>) -> Self {
-        self.vector_ctor = ctor;
+    #[must_use]
+    pub fn set_vector_ctor(mut self, ctor: impl Into<String>) -> Self {
+        self.vector_ctor = Some(ctor.into());
+        self
+    }
+
+    #[doc(hidden)]
+    #[must_use]
+    pub fn set_vector_type(mut self, r#type: impl Into<String>) -> Self {
+        self.vector_type = Some(r#type.into());
        self
    }

    /// Sets a list of globals that are mutable.
    ///
    /// It disables the import optimization for fields accessed through these.
+    #[must_use]
    pub fn set_mutable_globals(mut self, globals: Vec<String>) -> Self {
        self.mutable_globals = globals;
        self
    }

+    /// Sets a list of userdata types that will be included in the type information.
+    #[must_use]
+    pub fn set_userdata_types(mut self, types: Vec<String>) -> Self {
+        self.userdata_types = types;
+        self
+    }
+
    /// Compiles the `source` into bytecode.
    pub fn compile(&self, source: impl AsRef<[u8]>) -> Vec<u8> {
        use std::os::raw::c_int;
@@ -204,51 +250,57 @@ impl Compiler {
        let vector_ctor = self.vector_ctor.clone();
        let vector_ctor = vector_ctor.and_then(|ctor| CString::new(ctor).ok());
        let vector_ctor = vector_ctor.as_ref();
+        let vector_type = self.vector_type.clone();
+        let vector_type = vector_type.and_then(|t| CString::new(t).ok());
+        let vector_type = vector_type.as_ref();

-        let mutable_globals = self
-            .mutable_globals
-            .iter()
-            .map(|name| CString::new(name.clone()).ok())
-            .collect::<Option<Vec<_>>>()
-            .unwrap_or_default();
-        let mut mutable_globals = mutable_globals
-            .iter()
-            .map(|s| s.as_ptr())
-            .collect::<Vec<_>>();
-        let mut mutable_globals_ptr = ptr::null_mut();
-        if !mutable_globals.is_empty() {
-            mutable_globals.push(ptr::null());
-            mutable_globals_ptr = mutable_globals.as_mut_ptr();
+        macro_rules! vec2cstring_ptr {
+            ($name:ident, $name_ptr:ident) => {
+                let $name = self
+                    .$name
+                    .iter()
+                    .map(|name| CString::new(name.clone()).ok())
+                    .collect::<Option<Vec<_>>>()
+                    .unwrap_or_default();
+                let mut $name = $name.iter().map(|s| s.as_ptr()).collect::<Vec<_>>();
+                let mut $name_ptr = ptr::null();
+                if !$name.is_empty() {
+                    $name.push(ptr::null());
+                    $name_ptr = $name.as_ptr();
+                }
+            };
        }

+        vec2cstring_ptr!(mutable_globals, mutable_globals_ptr);
+        vec2cstring_ptr!(userdata_types, userdata_types_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: vector_lib.map_or(ptr::null(), |s| s.as_ptr()),
-                vectorCtor: vector_ctor.map_or(ptr::null(), |s| s.as_ptr()),
-                vectorType: ptr::null(),
-                mutableGlobals: mutable_globals_ptr,
-            };
+            let mut options = ffi::lua_CompileOptions::default();
+            options.optimizationLevel = self.optimization_level as c_int;
+            options.debugLevel = self.debug_level as c_int;
+            options.typeInfoLevel = self.type_info_level as c_int;
+            options.coverageLevel = self.coverage_level as c_int;
+            options.vectorLib = vector_lib.map_or(ptr::null(), |s| s.as_ptr());
+            options.vectorCtor = vector_ctor.map_or(ptr::null(), |s| s.as_ptr());
+            options.vectorType = vector_type.map_or(ptr::null(), |s| s.as_ptr());
+            options.mutableGlobals = mutable_globals_ptr;
+            options.userdataTypes = userdata_types_ptr;
            ffi::luau_compile(source.as_ref(), options)
        }
    }
 }

-impl<'lua, 'a> Chunk<'lua, 'a> {
+impl<'a> Chunk<'a> {
    /// Sets the name of this chunk, which results in more informative error traces.
-    pub fn set_name(mut self, name: impl AsRef<str>) -> Result<Self> {
-        self.name = Some(name.as_ref().to_string());
-        // Do extra validation
-        let _ = self.convert_name()?;
-        Ok(self)
+    pub fn set_name(mut self, name: impl Into<String>) -> Self {
+        self.name = name.into();
+        self
    }

-    /// Sets the first upvalue (`_ENV`) of the loaded chunk to the given value.
+    /// Sets the environment 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.
+    /// In Lua >=5.2 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.
@@ -256,10 +308,14 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
    /// 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<Self> {
-        // Prefer to propagate errors here and wrap to `Ok`
-        self.env = Ok(Some(env.to_lua(self.lua)?));
-        Ok(self)
+    pub fn set_environment<V: IntoLua>(mut self, env: V) -> Self {
+        let lua = self.lua.lock();
+        let lua = lua.lua();
+        self.env = env
+            .into_lua(lua)
+            .and_then(|val| lua.unpack(val))
+            .context("bad environment value");
+        self
    }

    /// Sets whether the chunk is text or binary (autodetected by default).
@@ -287,7 +343,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
    ///
    /// This is equivalent to calling the chunk function with no arguments and no return values.
    pub fn exec(self) -> Result<()> {
-        self.call(())?;
+        self.call::<_, ()>(())?;
        Ok(())
    }

@@ -300,11 +356,8 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
    /// [`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(())
+    pub async fn exec_async(self) -> Result<()> {
+        self.call_async(()).await
    }

    /// Evaluate the chunk as either an expression or block.
@@ -312,7 +365,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
    /// 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> {
+    pub fn eval<R: FromLuaMulti>(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
@@ -335,24 +388,23 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
    /// [`eval`]: #method.eval
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn eval_async<'fut, R>(self) -> LocalBoxFuture<'fut, Result<R>>
+    pub async fn eval_async<R>(self) -> Result<R>
    where
-        'lua: 'fut,
-        R: FromLuaMulti<'lua> + 'fut,
+        R: FromLuaMulti,
    {
        if self.detect_mode() == ChunkMode::Binary {
-            self.call_async(())
+            self.call_async(()).await
        } else if let Ok(function) = self.to_expression() {
-            function.call_async(())
+            function.call_async(()).await
        } else {
-            self.call_async(())
+            self.call_async(()).await
        }
    }

    /// 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> {
+    pub fn call<A: IntoLuaMulti, R: FromLuaMulti>(self, args: A) -> Result<R> {
        self.into_function()?.call(args)
    }

@@ -365,32 +417,29 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
    /// [`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>>
+    pub async fn call_async<A, R>(self, args: A) -> Result<R>
    where
-        'lua: 'fut,
-        A: ToLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut,
+        A: IntoLuaMulti,
+        R: FromLuaMulti,
    {
-        match self.into_function() {
-            Ok(func) => func.call_async(args),
-            Err(e) => Box::pin(future::err(e)),
-        }
+        self.into_function()?.call_async(args).await
    }

    /// Load this chunk into a regular `Function`.
    ///
    /// This simply compiles the chunk without actually executing it.
    #[cfg_attr(not(feature = "luau"), allow(unused_mut))]
-    pub fn into_function(mut self) -> Result<Function<'lua>> {
+    pub fn into_function(mut self) -> Result<Function> {
        #[cfg(feature = "luau")]
        if self.compiler.is_some() {
            // We don't need to compile source if no compiler set
            self.compile();
        }

-        let name = self.convert_name()?;
+        let name = Self::convert_name(self.name)?;
        self.lua
-            .load_chunk(self.source?.as_ref(), name.as_deref(), self.env?, self.mode)
+            .lock()
+            .load_chunk(Some(&name), self.env?, self.mode, self.source?.as_ref())
    }

    /// Compiles the chunk and changes mode to binary.
@@ -401,15 +450,12 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
            if self.detect_mode() == ChunkMode::Text {
                #[cfg(feature = "luau")]
                {
-                    let data = self
-                        .compiler
-                        .get_or_insert_with(Default::default)
-                        .compile(source);
+                    let data = self.compiler.get_or_insert_with(Default::default).compile(source);
                    self.source = Ok(Cow::Owned(data));
                    self.mode = Some(ChunkMode::Binary);
                }
                #[cfg(not(feature = "luau"))]
-                if let Ok(func) = self.lua.load_chunk(source.as_ref(), None, None, None) {
+                if let Ok(func) = self.lua.lock().load_chunk(None, None, None, source.as_ref()) {
                    let data = func.dump(false);
                    self.source = Ok(Cow::Owned(data));
                    self.mode = Some(ChunkMode::Binary);
@@ -428,7 +474,8 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
        let mut text_source = None;
        if let Ok(ref source) = self.source {
            if self.detect_mode() == ChunkMode::Text {
-                if let Some(cache) = self.lua.app_data_ref::<ChunksCache>() {
+                let lua = self.lua.lock();
+                if let Some(cache) = lua.app_data_ref::<ChunksCache>() {
                    if let Some(data) = cache.0.get(source.as_ref()) {
                        self.source = Ok(Cow::Owned(data.clone()));
                        self.mode = Some(ChunkMode::Binary);
@@ -444,13 +491,14 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
            self.compile();
            if let Ok(ref binary_source) = self.source {
                if self.detect_mode() == ChunkMode::Binary {
-                    if let Some(mut cache) = self.lua.app_data_mut::<ChunksCache>() {
+                    let lua = self.lua.lock();
+                    if let Some(mut cache) = lua.app_data_mut::<ChunksCache>() {
                        cache.0.insert(text_source, binary_source.as_ref().to_vec());
                    } else {
                        let mut cache = ChunksCache(HashMap::new());
                        cache.0.insert(text_source, binary_source.as_ref().to_vec());
-                        self.lua.set_app_data(cache);
-                    }
+                        let _ = lua.try_set_app_data(cache);
+                    };
                }
            }
        }
@@ -458,10 +506,10 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
        self
    }

-    fn to_expression(&self) -> Result<Function<'lua>> {
+    fn to_expression(&self) -> Result<Function> {
        // We assume that mode is Text
        let source = self.source.as_ref();
-        let source = source.map_err(|err| Error::RuntimeError(err.to_string()))?;
+        let source = source.map_err(Error::runtime)?;
        let source = Self::expression_source(source);
        // We don't need to compile source if no compiler options set
        #[cfg(feature = "luau")]
@@ -471,9 +519,10 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
            .map(|c| c.compile(&source))
            .unwrap_or(source);

-        let name = self.convert_name()?;
+        let name = Self::convert_name(self.name.clone())?;
        self.lua
-            .load_chunk(&source, name.as_deref(), self.env.clone()?, None)
+            .lock()
+            .load_chunk(Some(&name), self.env.clone()?, None, &source)
    }

    fn detect_mode(&self) -> ChunkMode {
@@ -494,12 +543,8 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
        }
    }

-    fn convert_name(&self) -> Result<Option<CString>> {
-        self.name
-            .clone()
-            .map(CString::new)
-            .transpose()
-            .map_err(|err| Error::RuntimeError(format!("invalid name: {err}")))
+    fn convert_name(name: String) -> Result<CString> {
+        CString::new(name).map_err(|err| Error::runtime(format!("invalid name: {err}")))
    }

    fn expression_source(source: &[u8]) -> Vec<u8> {
@@ -1,69 +1,106 @@
-#![allow(clippy::wrong_self_convention)]
-
 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::os::raw::c_int;
 use std::string::String as StdString;
+use std::{slice, str};

 use bstr::{BStr, BString};
 use num_traits::cast;

 use crate::error::{Error, Result};
 use crate::function::Function;
-use crate::lua::Lua;
+use crate::state::{Lua, RawLua};
 use crate::string::String;
 use crate::table::Table;
 use crate::thread::Thread;
-use crate::types::{LightUserData, MaybeSend};
+use crate::types::{LightUserData, MaybeSend, RegistryKey};
 use crate::userdata::{AnyUserData, UserData};
-use crate::value::{FromLua, Nil, ToLua, Value};
+use crate::value::{FromLua, IntoLua, Nil, Value};

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

-impl<'lua> FromLua<'lua> for Value<'lua> {
+impl IntoLua for &Value {
    #[inline]
-    fn from_lua(lua_value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
+    fn into_lua(self, _: &Lua) -> Result<Value> {
+        Ok(self.clone())
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        lua.push_value(self)
+    }
+}
+
+impl FromLua for Value {
+    #[inline]
+    fn from_lua(lua_value: Value, _: &Lua) -> Result<Self> {
        Ok(lua_value)
    }
 }

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

-impl<'lua> FromLua<'lua> for String<'lua> {
+impl IntoLua for &String {
    #[inline]
-    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<String<'lua>> {
+    fn into_lua(self, _: &Lua) -> Result<Value> {
+        Ok(Value::String(self.clone()))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        lua.push_ref(&self.0);
+        Ok(())
+    }
+}
+
+impl FromLua for String {
+    #[inline]
+    fn from_lua(value: Value, lua: &Lua) -> Result<String> {
        let ty = value.type_name();
        lua.coerce_string(value)?
            .ok_or_else(|| Error::FromLuaConversionError {
                from: ty,
-                to: "String",
+                to: "string",
                message: Some("expected string or number".to_string()),
            })
    }
 }

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

-impl<'lua> FromLua<'lua> for Table<'lua> {
+impl IntoLua for &Table {
    #[inline]
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Table<'lua>> {
+    fn into_lua(self, _: &Lua) -> Result<Value> {
+        Ok(Value::Table(self.clone()))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        lua.push_ref(&self.0);
+        Ok(())
+    }
+}
+
+impl FromLua for Table {
+    #[inline]
+    fn from_lua(value: Value, _: &Lua) -> Result<Table> {
        match value {
            Value::Table(table) => Ok(table),
            _ => Err(Error::FromLuaConversionError {
@@ -75,16 +112,29 @@ impl<'lua> FromLua<'lua> for Table<'lua> {
    }
 }

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

-impl<'lua> FromLua<'lua> for Function<'lua> {
+impl IntoLua for &Function {
    #[inline]
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Function<'lua>> {
+    fn into_lua(self, _: &Lua) -> Result<Value> {
+        Ok(Value::Function(self.clone()))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        lua.push_ref(&self.0);
+        Ok(())
+    }
+}
+
+impl FromLua for Function {
+    #[inline]
+    fn from_lua(value: Value, _: &Lua) -> Result<Function> {
        match value {
            Value::Function(table) => Ok(table),
            _ => Err(Error::FromLuaConversionError {
@@ -96,16 +146,29 @@ impl<'lua> FromLua<'lua> for Function<'lua> {
    }
 }

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

-impl<'lua> FromLua<'lua> for Thread<'lua> {
+impl IntoLua for &Thread {
    #[inline]
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Thread<'lua>> {
+    fn into_lua(self, _: &Lua) -> Result<Value> {
+        Ok(Value::Thread(self.clone()))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        lua.push_ref(&self.0);
+        Ok(())
+    }
+}
+
+impl FromLua for Thread {
+    #[inline]
+    fn from_lua(value: Value, _: &Lua) -> Result<Thread> {
        match value {
            Value::Thread(t) => Ok(t),
            _ => Err(Error::FromLuaConversionError {
@@ -117,16 +180,29 @@ impl<'lua> FromLua<'lua> for Thread<'lua> {
    }
 }

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

-impl<'lua> FromLua<'lua> for AnyUserData<'lua> {
+impl IntoLua for &AnyUserData {
    #[inline]
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<AnyUserData<'lua>> {
+    fn into_lua(self, _: &Lua) -> Result<Value> {
+        Ok(Value::UserData(self.clone()))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        lua.push_ref(&self.0);
+        Ok(())
+    }
+}
+
+impl FromLua for AnyUserData {
+    #[inline]
+    fn from_lua(value: Value, _: &Lua) -> Result<AnyUserData> {
        match value {
            Value::UserData(ud) => Ok(ud),
            _ => Err(Error::FromLuaConversionError {
@@ -138,40 +214,26 @@ impl<'lua> FromLua<'lua> for AnyUserData<'lua> {
    }
 }

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

-impl<'lua, T: 'static + UserData + Clone> FromLua<'lua> for T {
+impl IntoLua for Error {
    #[inline]
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<T> {
-        match value {
-            Value::UserData(ud) => Ok(ud.borrow::<T>()?.clone()),
-            _ => Err(Error::FromLuaConversionError {
-                from: value.type_name(),
-                to: "userdata",
-                message: None,
-            }),
-        }
+    fn into_lua(self, _: &Lua) -> Result<Value> {
+        Ok(Value::Error(Box::new(self)))
    }
 }

-impl<'lua> ToLua<'lua> for Error {
+impl FromLua 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> {
+    fn from_lua(value: Value, lua: &Lua) -> Result<Error> {
        match value {
-            Value::Error(err) => Ok(err),
-            val => Ok(Error::RuntimeError(
+            Value::Error(err) => Ok(*err),
+            val => Ok(Error::runtime(
                lua.coerce_string(val)?
                    .and_then(|s| Some(s.to_str().ok()?.to_owned()))
                    .unwrap_or_else(|| "<unprintable error>".to_owned()),
@@ -180,34 +242,85 @@ impl<'lua> FromLua<'lua> for Error {
    }
 }

-impl<'lua> ToLua<'lua> for bool {
+impl IntoLua for RegistryKey {
    #[inline]
-    fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
-        Ok(Value::Boolean(self))
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        lua.registry_value(&self)
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        <&RegistryKey>::push_into_stack(&self, lua)
    }
 }

-impl<'lua> FromLua<'lua> for bool {
+impl IntoLua for &RegistryKey {
    #[inline]
-    fn from_lua(v: Value<'lua>, _: &'lua Lua) -> Result<Self> {
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        lua.registry_value(self)
+    }
+
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        if !lua.owns_registry_value(self) {
+            return Err(Error::MismatchedRegistryKey);
+        }
+
+        match self.id() {
+            ffi::LUA_REFNIL => ffi::lua_pushnil(lua.state()),
+            id => {
+                ffi::lua_rawgeti(lua.state(), ffi::LUA_REGISTRYINDEX, id as _);
+            }
+        }
+        Ok(())
+    }
+}
+
+impl FromLua for RegistryKey {
+    #[inline]
+    fn from_lua(value: Value, lua: &Lua) -> Result<RegistryKey> {
+        lua.create_registry_value(value)
+    }
+}
+
+impl IntoLua for bool {
+    #[inline]
+    fn into_lua(self, _: &Lua) -> Result<Value> {
+        Ok(Value::Boolean(self))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        ffi::lua_pushboolean(lua.state(), self as c_int);
+        Ok(())
+    }
+}
+
+impl FromLua for bool {
+    #[inline]
+    fn from_lua(v: Value, _: &Lua) -> Result<Self> {
        match v {
            Value::Nil => Ok(false),
            Value::Boolean(b) => Ok(b),
            _ => Ok(true),
        }
    }
+
+    #[inline]
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
+        Ok(ffi::lua_toboolean(lua.state(), idx) != 0)
+    }
 }

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

-impl<'lua> FromLua<'lua> for LightUserData {
+impl FromLua for LightUserData {
    #[inline]
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
+    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
        match value {
            Value::LightUserData(ud) => Ok(ud),
            _ => Err(Error::FromLuaConversionError {
@@ -219,16 +332,44 @@ impl<'lua> FromLua<'lua> for LightUserData {
    }
 }

-impl<'lua> ToLua<'lua> for StdString {
+#[cfg(feature = "luau")]
+impl IntoLua for crate::types::Vector {
    #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-        Ok(Value::String(lua.create_string(&self)?))
+    fn into_lua(self, _: &Lua) -> Result<Value> {
+        Ok(Value::Vector(self))
    }
 }

-impl<'lua> FromLua<'lua> for StdString {
+#[cfg(feature = "luau")]
+impl FromLua for crate::types::Vector {
    #[inline]
-    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
+    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
+        match value {
+            Value::Vector(v) => Ok(v),
+            _ => Err(Error::FromLuaConversionError {
+                from: value.type_name(),
+                to: "vector",
+                message: None,
+            }),
+        }
+    }
+}
+
+impl IntoLua for StdString {
+    #[inline]
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        Ok(Value::String(lua.create_string(self)?))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        push_bytes_into_stack(self, lua)
+    }
+}
+
+impl FromLua for StdString {
+    #[inline]
+    fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
        let ty = value.type_name();
        Ok(lua
            .coerce_string(value)?
@@ -240,32 +381,56 @@ impl<'lua> FromLua<'lua> for StdString {
            .to_str()?
            .to_owned())
    }
-}

-impl<'lua> ToLua<'lua> for &str {
    #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-        Ok(Value::String(lua.create_string(self)?))
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
+        let state = lua.state();
+        if ffi::lua_type(state, idx) == ffi::LUA_TSTRING {
+            let mut size = 0;
+            let data = ffi::lua_tolstring(state, idx, &mut size);
+            let bytes = slice::from_raw_parts(data as *const u8, size);
+            return str::from_utf8(bytes)
+                .map(|s| s.to_owned())
+                .map_err(|e| Error::FromLuaConversionError {
+                    from: "string",
+                    to: "String",
+                    message: Some(e.to_string()),
+                });
+        }
+        // Fallback to default
+        Self::from_lua(lua.stack_value(idx), lua.lua())
    }
 }

-impl<'lua> ToLua<'lua> for Cow<'_, str> {
+impl IntoLua for &str {
    #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        Ok(Value::String(lua.create_string(self)?))
+    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        push_bytes_into_stack(self, lua)
+    }
+}
+
+impl IntoLua for Cow<'_, str> {
+    #[inline]
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
        Ok(Value::String(lua.create_string(self.as_bytes())?))
    }
 }

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

-impl<'lua> FromLua<'lua> for Box<str> {
+impl FromLua for Box<str> {
    #[inline]
-    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
+    fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
        let ty = value.type_name();
        Ok(lua
            .coerce_string(value)?
@@ -280,16 +445,16 @@ impl<'lua> FromLua<'lua> for Box<str> {
    }
 }

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

-impl<'lua> FromLua<'lua> for CString {
+impl FromLua for CString {
    #[inline]
-    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
+    fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
        let ty = value.type_name();
        let string = lua
            .coerce_string(value)?
@@ -299,7 +464,7 @@ impl<'lua> FromLua<'lua> for CString {
                message: Some("expected string or number".to_string()),
            })?;

-        match CStr::from_bytes_with_nul(string.as_bytes_with_nul()) {
+        match CStr::from_bytes_with_nul(&string.as_bytes_with_nul()) {
            Ok(s) => Ok(s.into()),
            Err(_) => Err(Error::FromLuaConversionError {
                from: ty,
@@ -310,56 +475,102 @@ impl<'lua> FromLua<'lua> for CString {
    }
 }

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

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

-impl<'lua> ToLua<'lua> for BString {
+impl IntoLua for BString {
    #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-        Ok(Value::String(lua.create_string(&self)?))
-    }
-}
-
-impl<'lua> FromLua<'lua> for BString {
-    #[inline]
-    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
-        let ty = value.type_name();
-        Ok(BString::from(
-            lua.coerce_string(value)?
-                .ok_or_else(|| Error::FromLuaConversionError {
-                    from: ty,
-                    to: "String",
-                    message: Some("expected string or number".to_string()),
-                })?
-                .as_bytes()
-                .to_vec(),
-        ))
-    }
-}
-
-impl<'lua> ToLua<'lua> for &BStr {
-    #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
        Ok(Value::String(lua.create_string(self)?))
    }
 }

+impl FromLua for BString {
+    fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
+        let ty = value.type_name();
+        match value {
+            Value::String(s) => Ok((*s.as_bytes()).into()),
+            #[cfg(feature = "luau")]
+            Value::UserData(ud) if ud.1 == crate::types::SubtypeId::Buffer => unsafe {
+                let lua = ud.0.lua.lock();
+                let mut size = 0usize;
+                let buf = ffi::lua_tobuffer(lua.ref_thread(), ud.0.index, &mut size);
+                mlua_assert!(!buf.is_null(), "invalid Luau buffer");
+                Ok(slice::from_raw_parts(buf as *const u8, size).into())
+            },
+            _ => Ok((*lua
+                .coerce_string(value)?
+                .ok_or_else(|| Error::FromLuaConversionError {
+                    from: ty,
+                    to: "BString",
+                    message: Some("expected string or number".to_string()),
+                })?
+                .as_bytes())
+            .into()),
+        }
+    }
+
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
+        let state = lua.state();
+        match ffi::lua_type(state, idx) {
+            ffi::LUA_TSTRING => {
+                let mut size = 0;
+                let data = ffi::lua_tolstring(state, idx, &mut size);
+                Ok(slice::from_raw_parts(data as *const u8, size).into())
+            }
+            #[cfg(feature = "luau")]
+            ffi::LUA_TBUFFER => {
+                let mut size = 0;
+                let buf = ffi::lua_tobuffer(state, idx, &mut size);
+                mlua_assert!(!buf.is_null(), "invalid Luau buffer");
+                Ok(slice::from_raw_parts(buf as *const u8, size).into())
+            }
+            _ => {
+                // Fallback to default
+                Self::from_lua(lua.stack_value(idx), lua.lua())
+            }
+        }
+    }
+}
+
+impl IntoLua for &BStr {
+    #[inline]
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        Ok(Value::String(lua.create_string(self)?))
+    }
+}
+
+#[inline]
+unsafe fn push_bytes_into_stack<T>(this: T, lua: &RawLua) -> Result<()>
+where
+    T: IntoLua + AsRef<[u8]>,
+{
+    let bytes = this.as_ref();
+    if lua.unlikely_memory_error() && bytes.len() < (1 << 30) {
+        // Fast path: push directly into the Lua stack.
+        ffi::lua_pushlstring(lua.state(), bytes.as_ptr() as *const _, bytes.len());
+        return Ok(());
+    }
+    // Fallback to default
+    lua.push_value(&T::into_lua(this, lua.lua())?)
+}
+
 macro_rules! lua_convert_int {
    ($x:ty) => {
-        impl<'lua> ToLua<'lua> for $x {
+        impl IntoLua for $x {
            #[inline]
-            fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+            fn into_lua(self, _: &Lua) -> Result<Value> {
                cast(self)
                    .map(Value::Integer)
                    .or_else(|| cast(self).map(Value::Number))
@@ -370,11 +581,20 @@ macro_rules! lua_convert_int {
                        message: Some("out of range".to_owned()),
                    })
            }
+
+            #[inline]
+            unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+                match cast(self) {
+                    Some(i) => ffi::lua_pushinteger(lua.state(), i),
+                    None => ffi::lua_pushnumber(lua.state(), self as ffi::lua_Number),
+                }
+                Ok(())
+            }
        }

-        impl<'lua> FromLua<'lua> for $x {
+        impl FromLua for $x {
            #[inline]
-            fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
+            fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
                let ty = value.type_name();
                (match value {
                    Value::Integer(i) => cast(i),
@@ -383,15 +603,16 @@ macro_rules! lua_convert_int {
                        if let Some(i) = lua.coerce_integer(value.clone())? {
                            cast(i)
                        } else {
-                            cast(lua.coerce_number(value)?.ok_or_else(|| {
-                                Error::FromLuaConversionError {
-                                    from: ty,
-                                    to: stringify!($x),
-                                    message: Some(
-                                        "expected number or string coercible to number".to_string(),
-                                    ),
-                                }
-                            })?)
+                            cast(
+                                lua.coerce_number(value)?
+                                    .ok_or_else(|| Error::FromLuaConversionError {
+                                        from: ty,
+                                        to: stringify!($x),
+                                        message: Some(
+                                            "expected number or string coercible to number".to_string(),
+                                        ),
+                                    })?,
+                            )
                        }
                    }
                })
@@ -420,9 +641,9 @@ lua_convert_int!(usize);

 macro_rules! lua_convert_float {
    ($x:ty) => {
-        impl<'lua> ToLua<'lua> for $x {
+        impl IntoLua for $x {
            #[inline]
-            fn to_lua(self, _: &'lua Lua) -> Result<Value<'lua>> {
+            fn into_lua(self, _: &Lua) -> Result<Value> {
                cast(self)
                    .ok_or_else(|| Error::ToLuaConversionError {
                        from: stringify!($x),
@@ -433,9 +654,9 @@ macro_rules! lua_convert_float {
            }
        }

-        impl<'lua> FromLua<'lua> for $x {
+        impl FromLua for $x {
            #[inline]
-            fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
+            fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
                let ty = value.type_name();
                lua.coerce_number(value)?
                    .ok_or_else(|| Error::FromLuaConversionError {
@@ -458,51 +679,50 @@ macro_rules! lua_convert_float {
 lua_convert_float!(f32);
 lua_convert_float!(f64);

-impl<'lua, T> ToLua<'lua> for &[T]
+impl<T> IntoLua for &[T]
 where
-    T: Clone + ToLua<'lua>,
+    T: IntoLua + Clone,
 {
    #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-        Ok(Value::Table(
-            lua.create_sequence_from(self.iter().cloned())?,
-        ))
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        Ok(Value::Table(lua.create_sequence_from(self.iter().cloned())?))
    }
 }

-impl<'lua, T, const N: usize> ToLua<'lua> for [T; N]
+impl<T, const N: usize> IntoLua for [T; N]
 where
-    T: ToLua<'lua>,
+    T: IntoLua,
 {
    #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
        Ok(Value::Table(lua.create_sequence_from(self)?))
    }
 }

-impl<'lua, T, const N: usize> FromLua<'lua> for [T; N]
+impl<T, const N: usize> FromLua for [T; N]
 where
-    T: FromLua<'lua>,
+    T: FromLua,
 {
    #[inline]
-    fn from_lua(value: Value<'lua>, _lua: &'lua Lua) -> Result<Self> {
+    fn from_lua(value: Value, _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"
-            )),
+            #[rustfmt::skip]
+            Value::Vector(v) if N == crate::types::Vector::SIZE => unsafe {
+                use std::{mem, ptr};
+                let mut arr: [mem::MaybeUninit<T>; N] = mem::MaybeUninit::uninit().assume_init();
+                ptr::write(arr[0].as_mut_ptr() , T::from_lua(Value::Number(v.x() as _), _lua)?);
+                ptr::write(arr[1].as_mut_ptr(), T::from_lua(Value::Number(v.y() as _), _lua)?);
+                ptr::write(arr[2].as_mut_ptr(), T::from_lua(Value::Number(v.z() as _), _lua)?);
+                #[cfg(feature = "luau-vector4")]
+                ptr::write(arr[3].as_mut_ptr(), T::from_lua(Value::Number(v.w() as _), _lua)?);
+                Ok(mem::transmute_copy(&arr))
+            },
            Value::Table(table) => {
                let vec = table.sequence_values().collect::<Result<Vec<_>>>()?;
                vec.try_into()
                    .map_err(|vec: Vec<T>| Error::FromLuaConversionError {
-                        from: "Table",
+                        from: "table",
                        to: "Array",
                        message: Some(format!("expected table of length {}, got {}", N, vec.len())),
                    })
@@ -516,37 +736,31 @@ where
    }
 }

-impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Box<[T]> {
+impl<T: IntoLua> IntoLua for Box<[T]> {
    #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
        Ok(Value::Table(lua.create_sequence_from(self.into_vec())?))
    }
 }

-impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Box<[T]> {
+impl<T: FromLua> FromLua for Box<[T]> {
    #[inline]
-    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
+    fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
        Ok(Vec::<T>::from_lua(value, lua)?.into_boxed_slice())
    }
 }

-impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Vec<T> {
+impl<T: IntoLua> IntoLua for Vec<T> {
    #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
        Ok(Value::Table(lua.create_sequence_from(self)?))
    }
 }

-impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Vec<T> {
+impl<T: FromLua> FromLua for Vec<T> {
    #[inline]
-    fn from_lua(value: Value<'lua>, _lua: &'lua Lua) -> Result<Self> {
+    fn from_lua(value: Value, _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(),
@@ -557,20 +771,16 @@ impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Vec<T> {
    }
 }

-impl<'lua, K: Eq + Hash + ToLua<'lua>, V: ToLua<'lua>, S: BuildHasher> ToLua<'lua>
-    for HashMap<K, V, S>
-{
+impl<K: Eq + Hash + IntoLua, V: IntoLua, S: BuildHasher> IntoLua for HashMap<K, V, S> {
    #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
        Ok(Value::Table(lua.create_table_from(self)?))
    }
 }

-impl<'lua, K: Eq + Hash + FromLua<'lua>, V: FromLua<'lua>, S: BuildHasher + Default> FromLua<'lua>
-    for HashMap<K, V, S>
-{
+impl<K: Eq + Hash + FromLua, V: FromLua, S: BuildHasher + Default> FromLua for HashMap<K, V, S> {
    #[inline]
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
+    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
        if let Value::Table(table) = value {
            table.pairs().collect()
        } else {
@@ -583,16 +793,16 @@ impl<'lua, K: Eq + Hash + FromLua<'lua>, V: FromLua<'lua>, S: BuildHasher + Defa
    }
 }

-impl<'lua, K: Ord + ToLua<'lua>, V: ToLua<'lua>> ToLua<'lua> for BTreeMap<K, V> {
+impl<K: Ord + IntoLua, V: IntoLua> IntoLua for BTreeMap<K, V> {
    #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
        Ok(Value::Table(lua.create_table_from(self)?))
    }
 }

-impl<'lua, K: Ord + FromLua<'lua>, V: FromLua<'lua>> FromLua<'lua> for BTreeMap<K, V> {
+impl<K: Ord + FromLua, V: FromLua> FromLua for BTreeMap<K, V> {
    #[inline]
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
+    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
        if let Value::Table(table) = value {
            table.pairs().collect()
        } else {
@@ -605,24 +815,21 @@ impl<'lua, K: Ord + FromLua<'lua>, V: FromLua<'lua>> FromLua<'lua> for BTreeMap<
    }
 }

-impl<'lua, T: Eq + Hash + ToLua<'lua>, S: BuildHasher> ToLua<'lua> for HashSet<T, S> {
+impl<T: Eq + Hash + IntoLua, S: BuildHasher> IntoLua for HashSet<T, S> {
    #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-        Ok(Value::Table(lua.create_table_from(
-            self.into_iter().map(|val| (val, true)),
-        )?))
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        Ok(Value::Table(
+            lua.create_table_from(self.into_iter().map(|val| (val, true)))?,
+        ))
    }
 }

-impl<'lua, T: Eq + Hash + FromLua<'lua>, S: BuildHasher + Default> FromLua<'lua> for HashSet<T, S> {
+impl<T: Eq + Hash + FromLua, S: BuildHasher + Default> FromLua for HashSet<T, S> {
    #[inline]
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
+    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
        match value {
-            Value::Table(table) if table.len()? > 0 => table.sequence_values().collect(),
-            Value::Table(table) => table
-                .pairs::<T, Value<'lua>>()
-                .map(|res| res.map(|(k, _)| k))
-                .collect(),
+            Value::Table(table) if table.raw_len() > 0 => table.sequence_values().collect(),
+            Value::Table(table) => table.pairs::<T, Value>().map(|res| res.map(|(k, _)| k)).collect(),
            _ => Err(Error::FromLuaConversionError {
                from: value.type_name(),
                to: "HashSet",
@@ -632,24 +839,21 @@ impl<'lua, T: Eq + Hash + FromLua<'lua>, S: BuildHasher + Default> FromLua<'lua>
    }
 }

-impl<'lua, T: Ord + ToLua<'lua>> ToLua<'lua> for BTreeSet<T> {
+impl<T: Ord + IntoLua> IntoLua for BTreeSet<T> {
    #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
-        Ok(Value::Table(lua.create_table_from(
-            self.into_iter().map(|val| (val, true)),
-        )?))
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        Ok(Value::Table(
+            lua.create_table_from(self.into_iter().map(|val| (val, true)))?,
+        ))
    }
 }

-impl<'lua, T: Ord + FromLua<'lua>> FromLua<'lua> for BTreeSet<T> {
+impl<T: Ord + FromLua> FromLua for BTreeSet<T> {
    #[inline]
-    fn from_lua(value: Value<'lua>, _: &'lua Lua) -> Result<Self> {
+    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
        match value {
-            Value::Table(table) if table.len()? > 0 => table.sequence_values().collect(),
-            Value::Table(table) => table
-                .pairs::<T, Value<'lua>>()
-                .map(|res| res.map(|(k, _)| k))
-                .collect(),
+            Value::Table(table) if table.raw_len() > 0 => table.sequence_values().collect(),
+            Value::Table(table) => table.pairs::<T, Value>().map(|res| res.map(|(k, _)| k)).collect(),
            _ => Err(Error::FromLuaConversionError {
                from: value.type_name(),
                to: "BTreeSet",
@@ -659,22 +863,40 @@ impl<'lua, T: Ord + FromLua<'lua>> FromLua<'lua> for BTreeSet<T> {
    }
 }

-impl<'lua, T: ToLua<'lua>> ToLua<'lua> for Option<T> {
+impl<T: IntoLua> IntoLua for Option<T> {
    #[inline]
-    fn to_lua(self, lua: &'lua Lua) -> Result<Value<'lua>> {
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
        match self {
-            Some(val) => val.to_lua(lua),
+            Some(val) => val.into_lua(lua),
            None => Ok(Nil),
        }
    }
+
+    #[inline]
+    unsafe fn push_into_stack(self, lua: &RawLua) -> Result<()> {
+        match self {
+            Some(val) => val.push_into_stack(lua)?,
+            None => ffi::lua_pushnil(lua.state()),
+        }
+        Ok(())
+    }
 }

-impl<'lua, T: FromLua<'lua>> FromLua<'lua> for Option<T> {
+impl<T: FromLua> FromLua for Option<T> {
    #[inline]
-    fn from_lua(value: Value<'lua>, lua: &'lua Lua) -> Result<Self> {
+    fn from_lua(value: Value, lua: &Lua) -> Result<Self> {
        match value {
            Nil => Ok(None),
            value => Ok(Some(T::from_lua(value, lua)?)),
        }
    }
+
+    #[inline]
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
+        if ffi::lua_isnil(lua.state(), idx) != 0 {
+            Ok(None)
+        } else {
+            Ok(Some(T::from_stack(idx, lua)?))
+        }
+    }
 }
@@ -1,5 +1,3 @@
-#![allow(clippy::wrong_self_convention)]
-
 use std::error::Error as StdError;
 use std::fmt;
 use std::io::Error as IoError;
@@ -9,6 +7,8 @@ use std::str::Utf8Error;
 use std::string::String as StdString;
 use std::sync::Arc;

+use crate::private::Sealed;
+
 /// Error type returned by `mlua` methods.
 #[derive(Debug, Clone)]
 #[non_exhaustive]
@@ -47,11 +47,6 @@ pub enum Error {
    /// This error can only happen when Lua state was not created by us and does not have the
    /// custom allocator attached.
    MemoryLimitNotAvailable,
-    /// Main thread is not available.
-    ///
-    /// This error can only happen in Lua5.1/LuaJIT module mode, when module loaded within a coroutine.
-    /// These Lua versions does not have `LUA_RIDX_MAINTHREAD` registry key.
-    MainThreadNotAvailable,
    /// A mutable callback has triggered Lua code that has called the same mutable callback again.
    ///
    /// This is an error because a mutable callback can only be borrowed mutably once.
@@ -69,8 +64,22 @@ pub enum Error {
    /// called with a huge number of arguments, or a rust callback returns a huge number of return
    /// values.
    StackError,
-    /// Too many arguments to `Function::bind`
+    /// Too many arguments to `Function::bind`.
    BindError,
+    /// Bad argument received from Lua (usually when calling a function).
+    ///
+    /// This error can help to identify the argument that caused the error
+    /// (which is stored in the corresponding field).
+    BadArgument {
+        /// Function that was called.
+        to: Option<StdString>,
+        /// Argument position (usually starts from 1).
+        pos: usize,
+        /// Argument name.
+        name: Option<StdString>,
+        /// Underlying error returned when converting argument to a Lua value.
+        cause: Arc<Error>,
+    },
    /// A Rust value could not be converted to a Lua value.
    ToLuaConversionError {
        /// Name of the Rust type that could not be converted.
@@ -92,7 +101,7 @@ pub enum Error {
    /// [`Thread::resume`] was called on an inactive coroutine.
    ///
    /// A coroutine is inactive if its main function has returned or if an error has occurred inside
-    /// the coroutine.
+    /// the coroutine. Already running coroutines are also marked as inactive (unresumable).
    ///
    /// [`Thread::status`] can be used to check if the coroutine can be resumed without causing this
    /// error.
@@ -116,7 +125,7 @@ pub enum Error {
    ///
    /// [`AnyUserData`]: crate::AnyUserData
    UserDataDestructed,
-    /// An [`AnyUserData`] immutable borrow failed because it is already borrowed mutably.
+    /// An [`AnyUserData`] immutable borrow failed.
    ///
    /// This error can occur when a method on a [`UserData`] type calls back into Lua, which then
    /// tries to call a method on the same [`UserData`] type. Consider restructuring your API to
@@ -125,7 +134,7 @@ pub enum Error {
    /// [`AnyUserData`]: crate::AnyUserData
    /// [`UserData`]: crate::UserData
    UserDataBorrowError,
-    /// An [`AnyUserData`] mutable borrow failed because it is already borrowed.
+    /// An [`AnyUserData`] mutable borrow failed.
    ///
    /// This error can occur when a method on a [`UserData`] type calls back into Lua, which then
    /// tries to call a method on the same [`UserData`] type. Consider restructuring your API to
@@ -142,8 +151,11 @@ pub enum Error {
    ///
    /// [`MetaMethod`]: crate::MetaMethod
    MetaMethodTypeError {
+        /// Name of the metamethod.
        method: StdString,
+        /// Passed value type.
        type_name: &'static str,
+        /// A string containing more detailed error information.
        message: Option<StdString>,
    },
    /// A [`RegistryKey`] produced from a different Lua state was used.
@@ -178,6 +190,13 @@ pub enum Error {
    /// error. The Rust code that originally invoked the Lua code then receives a `CallbackError`,
    /// from which the original error (and a stack traceback) can be recovered.
    ExternalError(Arc<dyn StdError + Send + Sync>),
+    /// An error with additional context.
+    WithContext {
+        /// A string containing additional context.
+        context: StdString,
+        /// Underlying error.
+        cause: Arc<Error>,
+    },
 }

 /// A specialized `Result` type used by `mlua`'s API.
@@ -187,24 +206,21 @@ pub type Result<T> = StdResult<T, Error>;
 impl fmt::Display for Error {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        match *self {
-            Error::SyntaxError { ref message, .. } => write!(fmt, "syntax error: {}", message),
-            Error::RuntimeError(ref msg) => write!(fmt, "runtime error: {}", msg),
+            Error::SyntaxError { ref message, .. } => write!(fmt, "syntax error: {message}"),
+            Error::RuntimeError(ref msg) => write!(fmt, "runtime error: {msg}"),
            Error::MemoryError(ref msg) => {
-                write!(fmt, "memory error: {}", msg)
+                write!(fmt, "memory error: {msg}")
            }
            #[cfg(any(feature = "lua53", feature = "lua52"))]
            Error::GarbageCollectorError(ref msg) => {
-                write!(fmt, "garbage collector error: {}", msg)
+                write!(fmt, "garbage collector error: {msg}")
            }
            Error::SafetyError(ref msg) => {
-                write!(fmt, "safety error: {}", msg)
+                write!(fmt, "safety error: {msg}")
            },
            Error::MemoryLimitNotAvailable => {
                write!(fmt, "setting memory limit is not available")
            }
-            Error::MainThreadNotAvailable => {
-                write!(fmt, "main thread is not available in Lua 5.1")
-            }
            Error::RecursiveMutCallback => write!(fmt, "mutable callback called recursively"),
            Error::CallbackDestructed => write!(
                fmt,
@@ -218,44 +234,55 @@ impl fmt::Display for Error {
                fmt,
                "too many arguments to Function::bind"
            ),
+            Error::BadArgument { ref to, pos, ref name, ref cause } => {
+                if let Some(name) = name {
+                    write!(fmt, "bad argument `{name}`")?;
+                } else {
+                    write!(fmt, "bad argument #{pos}")?;
+                }
+                if let Some(to) = to {
+                    write!(fmt, " to `{to}`")?;
+                }
+                write!(fmt, ": {cause}")
+            },
            Error::ToLuaConversionError { from, to, ref message } => {
-                write!(fmt, "error converting {} to Lua {}", from, to)?;
+                write!(fmt, "error converting {from} to Lua {to}")?;
                match *message {
                    None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({})", message),
+                    Some(ref message) => write!(fmt, " ({message})"),
                }
            }
            Error::FromLuaConversionError { from, to, ref message } => {
-                write!(fmt, "error converting Lua {} to {}", from, to)?;
+                write!(fmt, "error converting Lua {from} to {to}")?;
                match *message {
                    None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({})", message),
+                    Some(ref message) => write!(fmt, " ({message})"),
                }
            }
            Error::CoroutineInactive => write!(fmt, "cannot resume inactive coroutine"),
            Error::UserDataTypeMismatch => write!(fmt, "userdata is not expected type"),
            Error::UserDataDestructed => write!(fmt, "userdata has been destructed"),
-            Error::UserDataBorrowError => write!(fmt, "userdata already mutably borrowed"),
-            Error::UserDataBorrowMutError => write!(fmt, "userdata already borrowed"),
-            Error::MetaMethodRestricted(ref method) => write!(fmt, "metamethod {} is restricted", method),
+            Error::UserDataBorrowError => write!(fmt, "error borrowing userdata"),
+            Error::UserDataBorrowMutError => write!(fmt, "error mutably borrowing userdata"),
+            Error::MetaMethodRestricted(ref method) => write!(fmt, "metamethod {method} is restricted"),
            Error::MetaMethodTypeError { ref method, type_name, ref message } => {
-                write!(fmt, "metamethod {} has unsupported type {}", method, type_name)?;
+                write!(fmt, "metamethod {method} has unsupported type {type_name}")?;
                match *message {
                    None => Ok(()),
-                    Some(ref message) => write!(fmt, " ({})", message),
+                    Some(ref message) => write!(fmt, " ({message})"),
                }
            }
            Error::MismatchedRegistryKey => {
                write!(fmt, "RegistryKey used from different Lua state")
            }
            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);
                }
+                writeln!(fmt, "{cause}")?;
                if let Some(full_traceback) = full_traceback {
                    let traceback = traceback.trim_start_matches("stack traceback:");
                    let traceback = traceback.trim_start().trim_end();
@@ -269,20 +296,24 @@ impl fmt::Display for Error {
                } else {
                    writeln!(fmt, "{}", traceback.trim_end())?;
                }
-                write!(fmt, "caused by: {}", cause)
+                Ok(())
            }
            Error::PreviouslyResumedPanic => {
                write!(fmt, "previously resumed panic returned again")
            }
            #[cfg(feature = "serialize")]
            Error::SerializeError(ref err) => {
-                write!(fmt, "serialize error: {}", err)
+                write!(fmt, "serialize error: {err}")
            },
            #[cfg(feature = "serialize")]
            Error::DeserializeError(ref err) => {
-                write!(fmt, "deserialize error: {}", err)
+                write!(fmt, "deserialize error: {err}")
            },
-            Error::ExternalError(ref err) => write!(fmt, "{}", err),
+            Error::ExternalError(ref err) => write!(fmt, "{err}"),
+            Error::WithContext { ref context, ref cause } => {
+                writeln!(fmt, "{context}")?;
+                write!(fmt, "{cause}")
+            }
        }
    }
 }
@@ -293,56 +324,151 @@ impl StdError for Error {
            // 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.
+            // Given that we include source to fmt::Display implementation for `CallbackError`, this call
+            // returns nothing.
            Error::CallbackError { .. } => None,
            Error::ExternalError(ref err) => err.source(),
+            Error::WithContext { ref cause, .. } => match cause.as_ref() {
+                Error::ExternalError(err) => err.source(),
+                _ => None,
+            },
            _ => None,
        }
    }
 }

 impl Error {
-    pub fn external<T: Into<Box<dyn StdError + Send + Sync>>>(err: T) -> Error {
+    /// Creates a new `RuntimeError` with the given message.
+    #[inline]
+    pub fn runtime<S: fmt::Display>(message: S) -> Self {
+        Error::RuntimeError(message.to_string())
+    }
+
+    /// Wraps an external error object.
+    #[inline]
+    pub fn external<T: Into<Box<dyn StdError + Send + Sync>>>(err: T) -> Self {
        Error::ExternalError(err.into().into())
    }
+
+    /// Attempts to downcast the external error object to a concrete type by reference.
+    pub fn downcast_ref<T>(&self) -> Option<&T>
+    where
+        T: StdError + 'static,
+    {
+        match self {
+            Error::ExternalError(err) => err.downcast_ref(),
+            Error::WithContext { cause, .. } => match cause.as_ref() {
+                Error::ExternalError(err) => err.downcast_ref(),
+                _ => None,
+            },
+            _ => None,
+        }
+    }
+
+    pub(crate) fn bad_self_argument(to: &str, cause: Error) -> Self {
+        Error::BadArgument {
+            to: Some(to.to_string()),
+            pos: 1,
+            name: Some("self".to_string()),
+            cause: Arc::new(cause),
+        }
+    }
+
+    pub(crate) fn from_lua_conversion<'a>(
+        from: &'static str,
+        to: &'static str,
+        message: impl Into<Option<&'a str>>,
+    ) -> Self {
+        Error::FromLuaConversionError {
+            from,
+            to,
+            message: message.into().map(|s| s.into()),
+        }
+    }
 }

+/// Trait for converting [`std::error::Error`] into Lua [`Error`].
 pub trait ExternalError {
-    fn to_lua_err(self) -> Error;
+    fn into_lua_err(self) -> Error;
 }

 impl<E: Into<Box<dyn StdError + Send + Sync>>> ExternalError for E {
-    fn to_lua_err(self) -> Error {
+    fn into_lua_err(self) -> Error {
        Error::external(self)
    }
 }

+/// Trait for converting [`std::result::Result`] into Lua [`Result`].
 pub trait ExternalResult<T> {
-    fn to_lua_err(self) -> Result<T>;
+    fn into_lua_err(self) -> Result<T>;
 }

 impl<T, E> ExternalResult<T> for StdResult<T, E>
 where
    E: ExternalError,
 {
-    fn to_lua_err(self) -> Result<T> {
-        self.map_err(|e| e.to_lua_err())
+    fn into_lua_err(self) -> Result<T> {
+        self.map_err(|e| e.into_lua_err())
    }
 }

-impl std::convert::From<AddrParseError> for Error {
+/// Provides the `context` method for [`Error`] and `Result<T, Error>`.
+pub trait ErrorContext: Sealed {
+    /// Wraps the error value with additional context.
+    fn context<C: fmt::Display>(self, context: C) -> Self;
+
+    /// Wrap the error value with additional context that is evaluated lazily
+    /// only once an error does occur.
+    fn with_context<C: fmt::Display>(self, f: impl FnOnce(&Error) -> C) -> Self;
+}
+
+impl ErrorContext for Error {
+    fn context<C: fmt::Display>(self, context: C) -> Self {
+        let context = context.to_string();
+        match self {
+            Error::WithContext { cause, .. } => Error::WithContext { context, cause },
+            _ => Error::WithContext {
+                context,
+                cause: Arc::new(self),
+            },
+        }
+    }
+
+    fn with_context<C: fmt::Display>(self, f: impl FnOnce(&Error) -> C) -> Self {
+        let context = f(&self).to_string();
+        match self {
+            Error::WithContext { cause, .. } => Error::WithContext { context, cause },
+            _ => Error::WithContext {
+                context,
+                cause: Arc::new(self),
+            },
+        }
+    }
+}
+
+impl<T> ErrorContext for StdResult<T, Error> {
+    fn context<C: fmt::Display>(self, context: C) -> Self {
+        self.map_err(|err| err.context(context))
+    }
+
+    fn with_context<C: fmt::Display>(self, f: impl FnOnce(&Error) -> C) -> Self {
+        self.map_err(|err| err.with_context(f))
+    }
+}
+
+impl From<AddrParseError> for Error {
    fn from(err: AddrParseError) -> Self {
        Error::external(err)
    }
 }

-impl std::convert::From<IoError> for Error {
+impl From<IoError> for Error {
    fn from(err: IoError) -> Self {
        Error::external(err)
    }
 }

-impl std::convert::From<Utf8Error> for Error {
+impl From<Utf8Error> for Error {
    fn from(err: Utf8Error) -> Self {
        Error::external(err)
    }
@@ -1,33 +1,50 @@
-use std::mem;
+use std::cell::RefCell;
 use std::os::raw::{c_int, c_void};
-use std::ptr;
-use std::slice;
+use std::{mem, ptr, slice};

 use crate::error::{Error, Result};
-use crate::ffi;
-use crate::types::LuaRef;
+use crate::state::Lua;
+use crate::table::Table;
+use crate::types::{Callback, MaybeSend, ValueRef};
 use crate::util::{
-    assert_stack, check_stack, error_traceback, pop_error, ptr_to_cstr_bytes, StackGuard,
+    assert_stack, check_stack, linenumber_to_usize, pop_error, ptr_to_lossy_str, ptr_to_str, StackGuard,
 };
-use crate::value::{FromLuaMulti, ToLuaMulti};
+use crate::value::{FromLuaMulti, IntoLua, IntoLuaMulti, Value};

 #[cfg(feature = "async")]
-use {futures_core::future::LocalBoxFuture, futures_util::future};
+use {
+    crate::types::AsyncCallback,
+    std::future::{self, Future},
+};

 /// Handle to an internal Lua function.
 #[derive(Clone, Debug)]
-pub struct Function<'lua>(pub(crate) LuaRef<'lua>);
+pub struct Function(pub(crate) ValueRef);

+/// Contains information about a function.
+///
+/// Please refer to the [`Lua Debug Interface`] for more information.
+///
+/// [`Lua Debug Interface`]: https://www.lua.org/manual/5.4/manual.html#4.7
 #[derive(Clone, Debug)]
 pub struct FunctionInfo {
-    pub name: Option<Vec<u8>>,
-    pub name_what: Option<Vec<u8>>,
-    pub what: Option<Vec<u8>>,
-    pub source: Option<Vec<u8>>,
-    pub short_src: Option<Vec<u8>>,
-    pub line_defined: i32,
-    #[cfg(not(feature = "luau"))]
-    pub last_line_defined: i32,
+    /// A (reasonable) name of the function (`None` if the name cannot be found).
+    pub name: Option<String>,
+    /// Explains the `name` field (can be `global`/`local`/`method`/`field`/`upvalue`/etc).
+    ///
+    /// Always `None` for Luau.
+    pub name_what: Option<&'static str>,
+    /// A string `Lua` if the function is a Lua function, `C` if it is a C function, `main` if it is
+    /// the main part of a chunk.
+    pub what: &'static str,
+    /// Source of the chunk that created the function.
+    pub source: Option<String>,
+    /// A "printable" version of `source`, to be used in error messages.
+    pub short_src: Option<String>,
+    /// The line number where the definition of the function starts.
+    pub line_defined: Option<usize>,
+    /// The line number where the definition of the function ends (not set by Luau).
+    pub last_line_defined: Option<usize>,
 }

 /// Luau function coverage snapshot.
@@ -35,13 +52,13 @@ pub struct FunctionInfo {
 #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct CoverageInfo {
-    pub function: Option<std::string::String>,
+    pub function: Option<String>,
    pub line_defined: i32,
    pub depth: i32,
    pub hits: Vec<i32>,
 }

-impl<'lua> Function<'lua> {
+impl Function {
    /// Calls the function, passing `args` as function arguments.
    ///
    /// The function's return values are converted to the generic type `R`.
@@ -82,36 +99,28 @@ impl<'lua> Function<'lua> {
    /// # Ok(())
    /// # }
    /// ```
-    pub fn call<A: ToLuaMulti<'lua>, R: FromLuaMulti<'lua>>(&self, args: A) -> Result<R> {
-        let lua = self.0.lua;
+    pub fn call<A: IntoLuaMulti, R: FromLuaMulti>(&self, args: A) -> Result<R> {
+        let lua = self.0.lua.lock();
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 2)?;

-        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, nargs + 3)?;
-
-            ffi::lua_pushcfunction(lua.state, error_traceback);
-            let stack_start = ffi::lua_gettop(lua.state);
+            // Push error handler
+            lua.push_error_traceback();
+            let stack_start = ffi::lua_gettop(state);
+            // Push function and the arguments
            lua.push_ref(&self.0);
-            for arg in args.drain_all() {
-                lua.push_value(arg)?;
-            }
-            let ret = ffi::lua_pcall(lua.state, nargs, ffi::LUA_MULTRET, stack_start);
+            let nargs = args.push_into_stack_multi(&lua)?;
+            // Call the function
+            let ret = ffi::lua_pcall(state, nargs, ffi::LUA_MULTRET, stack_start);
            if ret != ffi::LUA_OK {
-                return Err(pop_error(lua.state, ret));
+                return Err(pop_error(state, ret));
            }
-            let nresults = ffi::lua_gettop(lua.state) - stack_start;
-            let mut results = args; // Reuse MultiValue container
-            assert_stack(lua.state, 2);
-            for _ in 0..nresults {
-                results.push_front(lua.pop_value());
-            }
-            ffi::lua_pop(lua.state, 1);
-            results
-        };
-        R::from_lua_multi(results, lua)
+            // Get the results
+            let nresults = ffi::lua_gettop(state) - stack_start;
+            R::from_stack_multi(nresults, &lua)
+        }
    }

    /// Returns a future that, when polled, calls `self`, passing `args` as function arguments,
@@ -125,14 +134,13 @@ impl<'lua> Function<'lua> {
    ///
    /// ```
    /// use std::time::Duration;
-    /// use futures_timer::Delay;
    /// # use mlua::{Lua, Result};
    /// # #[tokio::main]
    /// # async fn main() -> Result<()> {
    /// # let lua = Lua::new();
    ///
    /// let sleep = lua.create_async_function(move |_lua, n: u64| async move {
-    ///     Delay::new(Duration::from_millis(n)).await;
+    ///     tokio::time::sleep(Duration::from_millis(n)).await;
    ///     Ok(())
    /// })?;
    ///
@@ -145,21 +153,20 @@ impl<'lua> Function<'lua> {
    /// [`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>>
+    pub fn call_async<A, R>(&self, args: A) -> impl Future<Output = Result<R>>
    where
-        'lua: 'fut,
-        A: ToLuaMulti<'lua>,
-        R: FromLuaMulti<'lua> + 'fut,
+        A: IntoLuaMulti,
+        R: FromLuaMulti,
    {
-        let lua = self.0.lua;
-        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)),
-        }
+        let lua = self.0.lua.lock();
+        let thread_res = unsafe {
+            lua.create_recycled_thread(self).map(|th| {
+                let mut th = th.into_async(args);
+                th.set_recyclable(true);
+                th
+            })
+        };
+        async move { thread_res?.await }
    }

    /// Returns a function that, when called, calls `self`, passing `args` as the first set of
@@ -189,8 +196,8 @@ impl<'lua> Function<'lua> {
    /// # Ok(())
    /// # }
    /// ```
-    pub fn bind<A: ToLuaMulti<'lua>>(&self, args: A) -> Result<Function<'lua>> {
-        unsafe extern "C" fn args_wrapper_impl(state: *mut ffi::lua_State) -> c_int {
+    pub fn bind<A: IntoLuaMulti>(&self, args: A) -> Result<Function> {
+        unsafe extern "C-unwind" fn args_wrapper_impl(state: *mut ffi::lua_State) -> c_int {
            let nargs = ffi::lua_gettop(state);
            let nbinds = ffi::lua_tointeger(state, ffi::lua_upvalueindex(1)) as c_int;
            ffi::luaL_checkstack(state, nbinds, ptr::null());
@@ -205,9 +212,10 @@ impl<'lua> Function<'lua> {
            nargs + nbinds
        }

-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
+        let state = lua.state();

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

        if nargs == 0 {
@@ -219,20 +227,21 @@ impl<'lua> Function<'lua> {
        }

        let args_wrapper = unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, nargs + 3)?;
+            let _sg = StackGuard::new(state);
+            check_stack(state, nargs + 3)?;

-            ffi::lua_pushinteger(lua.state, nargs as ffi::lua_Integer);
-            for arg in args {
+            ffi::lua_pushinteger(state, nargs as ffi::lua_Integer);
+            for arg in &args {
                lua.push_value(arg)?;
            }
-            protect_lua!(lua.state, nargs + 1, 1, fn(state) {
+            protect_lua!(state, nargs + 1, 1, fn(state) {
                ffi::lua_pushcclosure(state, args_wrapper_impl, ffi::lua_gettop(state));
            })?;

            Function(lua.pop_ref())
        };

+        let lua = lua.lua();
        lua.load(
            r#"
            local func, args_wrapper = ...
@@ -242,8 +251,92 @@ impl<'lua> Function<'lua> {
            "#,
        )
        .try_cache()
-        .set_name("_mlua_bind")?
-        .call((self.clone(), args_wrapper))
+        .set_name("__mlua_bind")
+        .call((self, args_wrapper))
+    }
+
+    /// Returns the environment of the Lua function.
+    ///
+    /// By default Lua functions shares a global environment.
+    ///
+    /// This function always returns `None` for Rust/C functions.
+    pub fn environment(&self) -> Option<Table> {
+        let lua = self.0.lua.lock();
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 1);
+
+            lua.push_ref(&self.0);
+            if ffi::lua_iscfunction(state, -1) != 0 {
+                return None;
+            }
+
+            #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+            ffi::lua_getfenv(state, -1);
+            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            for i in 1..=255 {
+                // Traverse upvalues until we find the _ENV one
+                match ffi::lua_getupvalue(state, -1, i) {
+                    s if s.is_null() => break,
+                    s if std::ffi::CStr::from_ptr(s as _).to_bytes() == b"_ENV" => break,
+                    _ => ffi::lua_pop(state, 1),
+                }
+            }
+
+            if ffi::lua_type(state, -1) != ffi::LUA_TTABLE {
+                return None;
+            }
+            Some(Table(lua.pop_ref()))
+        }
+    }
+
+    /// Sets the environment of the Lua function.
+    ///
+    /// The environment is a table that is used as the global environment for the function.
+    /// Returns `true` if environment successfully changed, `false` otherwise.
+    ///
+    /// This function does nothing for Rust/C functions.
+    pub fn set_environment(&self, env: Table) -> Result<bool> {
+        let lua = self.0.lua.lock();
+        let state = lua.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            check_stack(state, 2)?;
+
+            lua.push_ref(&self.0);
+            if ffi::lua_iscfunction(state, -1) != 0 {
+                return Ok(false);
+            }
+
+            #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+            {
+                lua.push_ref(&env.0);
+                ffi::lua_setfenv(state, -2);
+            }
+            #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+            for i in 1..=255 {
+                match ffi::lua_getupvalue(state, -1, i) {
+                    s if s.is_null() => return Ok(false),
+                    s if std::ffi::CStr::from_ptr(s as _).to_bytes() == b"_ENV" => {
+                        ffi::lua_pop(state, 1);
+                        // Create an anonymous function with the new environment
+                        let f_with_env = lua
+                            .lua()
+                            .load("return _ENV")
+                            .set_environment(env)
+                            .try_cache()
+                            .into_function()?;
+                        lua.push_ref(&f_with_env.0);
+                        ffi::lua_upvaluejoin(state, -2, i, -1, 1);
+                        break;
+                    }
+                    _ => ffi::lua_pop(state, 1),
+                }
+            }
+
+            Ok(true)
+        }
    }

    /// Returns information about the function.
@@ -252,34 +345,40 @@ impl<'lua> Function<'lua> {
    ///
    /// [`lua_getinfo`]: https://www.lua.org/manual/5.4/manual.html#lua_getinfo
    pub fn info(&self) -> FunctionInfo {
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
+        let state = lua.state();
        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 1);
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 1);

            let mut ar: ffi::lua_Debug = mem::zeroed();
            lua.push_ref(&self.0);
            #[cfg(not(feature = "luau"))]
-            let res = ffi::lua_getinfo(lua.state, cstr!(">Sn"), &mut ar);
+            let res = ffi::lua_getinfo(state, cstr!(">Sn"), &mut ar);
            #[cfg(feature = "luau")]
-            let res = ffi::lua_getinfo(lua.state, -1, cstr!("sn"), &mut ar);
+            let res = ffi::lua_getinfo(state, -1, cstr!("sn"), &mut ar);
            mlua_assert!(res != 0, "lua_getinfo failed with `>Sn`");

            FunctionInfo {
-                name: ptr_to_cstr_bytes(ar.name).map(|s| s.to_vec()),
+                name: ptr_to_lossy_str(ar.name).map(|s| s.into_owned()),
                #[cfg(not(feature = "luau"))]
-                name_what: ptr_to_cstr_bytes(ar.namewhat).map(|s| s.to_vec()),
+                name_what: match ptr_to_str(ar.namewhat) {
+                    Some("") => None,
+                    val => val,
+                },
                #[cfg(feature = "luau")]
                name_what: None,
-                what: ptr_to_cstr_bytes(ar.what).map(|s| s.to_vec()),
-                source: ptr_to_cstr_bytes(ar.source).map(|s| s.to_vec()),
+                what: ptr_to_str(ar.what).unwrap_or("main"),
+                source: ptr_to_lossy_str(ar.source).map(|s| s.into_owned()),
                #[cfg(not(feature = "luau"))]
-                short_src: ptr_to_cstr_bytes(ar.short_src.as_ptr()).map(|s| s.to_vec()),
+                short_src: ptr_to_lossy_str(ar.short_src.as_ptr()).map(|s| s.into_owned()),
                #[cfg(feature = "luau")]
-                short_src: ptr_to_cstr_bytes(ar.short_src).map(|s| s.to_vec()),
-                line_defined: ar.linedefined,
+                short_src: ptr_to_lossy_str(ar.short_src).map(|s| s.into_owned()),
+                line_defined: linenumber_to_usize(ar.linedefined),
                #[cfg(not(feature = "luau"))]
-                last_line_defined: ar.lastlinedefined,
+                last_line_defined: linenumber_to_usize(ar.lastlinedefined),
+                #[cfg(feature = "luau")]
+                last_line_defined: None,
            }
        }
    }
@@ -295,7 +394,7 @@ impl<'lua> Function<'lua> {
    #[cfg(not(feature = "luau"))]
    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
    pub fn dump(&self, strip: bool) -> Vec<u8> {
-        unsafe extern "C" fn writer(
+        unsafe extern "C-unwind" fn writer(
            _state: *mut ffi::lua_State,
            buf: *const c_void,
            buf_len: usize,
@@ -307,16 +406,17 @@ impl<'lua> Function<'lua> {
            0
        }

-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
+        let state = lua.state();
        let mut data: Vec<u8> = Vec::new();
        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 1);
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 1);

            lua.push_ref(&self.0);
            let data_ptr = &mut data as *mut Vec<u8> as *mut c_void;
-            ffi::lua_dump(lua.state, writer, data_ptr, strip as i32);
-            ffi::lua_pop(lua.state, 1);
+            ffi::lua_dump(state, writer, data_ptr, strip as i32);
+            ffi::lua_pop(state, 1);
        }

        data
@@ -324,15 +424,15 @@ impl<'lua> Function<'lua> {

    /// Retrieves recorded coverage information about this Lua function including inner calls.
    ///
-    /// This function takes a callback as an argument and calls it providing [`CoverageInfo`] snapshot
-    /// per each executed inner function.
+    /// This function takes a callback as an argument and calls it providing [`CoverageInfo`]
+    /// snapshot per each executed inner function.
    ///
    /// Recording of coverage information is controlled by [`Compiler::set_coverage_level`] option.
    ///
    /// Requires `feature = "luau"`
    ///
    /// [`Compiler::set_coverage_level`]: crate::chunk::Compiler::set_coverage_level
-    #[cfg(any(feature = "luau", docsrs))]
+    #[cfg(any(feature = "luau", doc))]
    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
    pub fn coverage<F>(&self, mut func: F)
    where
@@ -341,7 +441,7 @@ impl<'lua> Function<'lua> {
        use std::ffi::CStr;
        use std::os::raw::c_char;

-        unsafe extern "C" fn callback<F: FnMut(CoverageInfo)>(
+        unsafe extern "C-unwind" fn callback<F: FnMut(CoverageInfo)>(
            data: *mut c_void,
            function: *const c_char,
            line_defined: c_int,
@@ -363,20 +463,139 @@ impl<'lua> Function<'lua> {
            });
        }

-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
+        let state = lua.state();
        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 1);
+            let _sg = StackGuard::new(state);
+            assert_stack(state, 1);

            lua.push_ref(&self.0);
            let func_ptr = &mut func as *mut F as *mut c_void;
-            ffi::lua_getcoverage(lua.state, -1, func_ptr, callback::<F>);
+            ffi::lua_getcoverage(state, -1, func_ptr, callback::<F>);
+        }
+    }
+
+    /// Converts this function to a generic C pointer.
+    ///
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        self.0.to_pointer()
+    }
+
+    /// Creates a deep clone of the Lua function.
+    ///
+    /// Copies the function prototype and all its upvalues to the
+    /// newly created function.
+    ///
+    /// This function returns shallow clone (same handle) for Rust/C functions.
+    /// Requires `feature = "luau"`
+    #[cfg(feature = "luau")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub fn deep_clone(&self) -> Self {
+        let lua = self.0.lua.lock();
+        let ref_thread = lua.ref_thread();
+        unsafe {
+            if ffi::lua_iscfunction(ref_thread, self.0.index) != 0 {
+                return self.clone();
+            }
+
+            ffi::lua_clonefunction(ref_thread, self.0.index);
+            Function(lua.pop_ref_thread())
        }
    }
 }

-impl<'lua> PartialEq for Function<'lua> {
+impl PartialEq for Function {
    fn eq(&self, other: &Self) -> bool {
        self.0 == other.0
    }
 }
+
+pub(crate) struct WrappedFunction(pub(crate) Callback<'static>);
+
+#[cfg(feature = "async")]
+pub(crate) struct WrappedAsyncFunction(pub(crate) AsyncCallback<'static>);
+
+impl Function {
+    /// Wraps a Rust function or closure, returning an opaque type that implements [`IntoLua`]
+    /// trait.
+    #[inline]
+    pub fn wrap<A, R, F>(func: F) -> impl IntoLua
+    where
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+        F: Fn(&Lua, A) -> Result<R> + MaybeSend + 'static,
+    {
+        WrappedFunction(Box::new(move |lua, nargs| unsafe {
+            let args = A::from_stack_args(nargs, 1, None, lua)?;
+            func(lua.lua(), args)?.push_into_stack_multi(lua)
+        }))
+    }
+
+    /// Wraps a Rust mutable closure, returning an opaque type that implements [`IntoLua`] trait.
+    #[inline]
+    pub fn wrap_mut<A, R, F>(func: F) -> impl IntoLua
+    where
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+        F: FnMut(&Lua, A) -> Result<R> + MaybeSend + 'static,
+    {
+        let func = RefCell::new(func);
+        WrappedFunction(Box::new(move |lua, nargs| unsafe {
+            let mut func = func.try_borrow_mut().map_err(|_| Error::RecursiveMutCallback)?;
+            let args = A::from_stack_args(nargs, 1, None, lua)?;
+            func(lua.lua(), args)?.push_into_stack_multi(lua)
+        }))
+    }
+
+    /// Wraps a Rust async function or closure, returning an opaque type that implements [`IntoLua`]
+    /// trait.
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    pub fn wrap_async<A, R, F, FR>(func: F) -> impl IntoLua
+    where
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+        F: Fn(&Lua, A) -> FR + MaybeSend + 'static,
+        FR: Future<Output = Result<R>> + 'static,
+    {
+        WrappedAsyncFunction(Box::new(move |rawlua, args| unsafe {
+            let lua = rawlua.lua();
+            let args = match A::from_lua_args(args, 1, None, lua) {
+                Ok(args) => args,
+                Err(e) => return Box::pin(future::ready(Err(e))),
+            };
+            let fut = func(lua, args);
+            let weak = rawlua.weak().clone();
+            Box::pin(async move { fut.await?.push_into_stack_multi(&weak.lock()) })
+        }))
+    }
+}
+
+impl IntoLua for WrappedFunction {
+    #[inline]
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        lua.lock().create_callback(self.0).map(Value::Function)
+    }
+}
+
+#[cfg(feature = "async")]
+impl IntoLua for WrappedAsyncFunction {
+    #[inline]
+    fn into_lua(self, lua: &Lua) -> Result<Value> {
+        lua.lock().create_async_callback(self.0).map(Value::Function)
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_any!(Function: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(Function: Send, Sync);
+}
@@ -1,11 +1,15 @@
+use std::borrow::Cow;
 use std::cell::UnsafeCell;
+use std::ops::Deref;
 #[cfg(not(feature = "luau"))]
 use std::ops::{BitOr, BitOrAssign};
 use std::os::raw::c_int;

-use crate::ffi::{self, lua_Debug};
-use crate::lua::Lua;
-use crate::util::ptr_to_cstr_bytes;
+use ffi::lua_Debug;
+
+use crate::state::RawLua;
+use crate::types::ReentrantMutexGuard;
+use crate::util::{linenumber_to_usize, ptr_to_lossy_str, ptr_to_str};

 /// Contains information about currently executing Lua code.
 ///
@@ -16,25 +20,44 @@ use crate::util::ptr_to_cstr_bytes;
 ///
 /// [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,
+pub struct Debug<'a> {
+    lua: EitherLua<'a>,
    ar: ActivationRecord,
    #[cfg(feature = "luau")]
    level: c_int,
 }

-impl<'lua> Debug<'lua> {
+enum EitherLua<'a> {
+    Owned(ReentrantMutexGuard<'a, RawLua>),
    #[cfg(not(feature = "luau"))]
-    pub(crate) fn new(lua: &'lua Lua, ar: *mut lua_Debug) -> Self {
+    Borrowed(&'a RawLua),
+}
+
+impl Deref for EitherLua<'_> {
+    type Target = RawLua;
+
+    fn deref(&self) -> &Self::Target {
+        match self {
+            EitherLua::Owned(guard) => guard,
+            #[cfg(not(feature = "luau"))]
+            EitherLua::Borrowed(lua) => lua,
+        }
+    }
+}
+
+impl<'a> Debug<'a> {
+    // We assume the lock is held when this function is called.
+    #[cfg(not(feature = "luau"))]
+    pub(crate) fn new(lua: &'a RawLua, ar: *mut lua_Debug) -> Self {
        Debug {
-            lua,
+            lua: EitherLua::Borrowed(lua),
            ar: ActivationRecord::Borrowed(ar),
        }
    }

-    pub(crate) fn new_owned(lua: &'lua Lua, _level: c_int, ar: lua_Debug) -> Self {
+    pub(crate) fn new_owned(guard: ReentrantMutexGuard<'a, RawLua>, _level: c_int, ar: lua_Debug) -> Self {
        Debug {
-            lua,
+            lua: EitherLua::Owned(guard),
            ar: ActivationRecord::Owned(UnsafeCell::new(ar)),
            #[cfg(feature = "luau")]
            level: _level,
@@ -67,19 +90,22 @@ impl<'lua> Debug<'lua> {
        unsafe {
            #[cfg(not(feature = "luau"))]
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, cstr!("n"), self.ar.get()) != 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,
+                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("n"), self.ar.get()) != 0,
                "lua_getinfo failed with `n`"
            );

            DebugNames {
-                name: ptr_to_cstr_bytes((*self.ar.get()).name),
+                name: ptr_to_lossy_str((*self.ar.get()).name),
                #[cfg(not(feature = "luau"))]
-                name_what: ptr_to_cstr_bytes((*self.ar.get()).namewhat),
+                name_what: match ptr_to_str((*self.ar.get()).namewhat) {
+                    Some("") => None,
+                    val => val,
+                },
                #[cfg(feature = "luau")]
                name_what: None,
            }
@@ -91,25 +117,27 @@ impl<'lua> Debug<'lua> {
        unsafe {
            #[cfg(not(feature = "luau"))]
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, cstr!("S"), self.ar.get()) != 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,
+                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("s"), self.ar.get()) != 0,
                "lua_getinfo failed with `s`"
            );

            DebugSource {
-                source: ptr_to_cstr_bytes((*self.ar.get()).source),
+                source: ptr_to_lossy_str((*self.ar.get()).source),
                #[cfg(not(feature = "luau"))]
-                short_src: ptr_to_cstr_bytes((*self.ar.get()).short_src.as_ptr()),
+                short_src: ptr_to_lossy_str((*self.ar.get()).short_src.as_ptr()),
                #[cfg(feature = "luau")]
-                short_src: ptr_to_cstr_bytes((*self.ar.get()).short_src),
-                line_defined: (*self.ar.get()).linedefined,
+                short_src: ptr_to_lossy_str((*self.ar.get()).short_src),
+                line_defined: linenumber_to_usize((*self.ar.get()).linedefined),
                #[cfg(not(feature = "luau"))]
-                last_line_defined: (*self.ar.get()).lastlinedefined,
-                what: ptr_to_cstr_bytes((*self.ar.get()).what),
+                last_line_defined: linenumber_to_usize((*self.ar.get()).lastlinedefined),
+                #[cfg(feature = "luau")]
+                last_line_defined: None,
+                what: ptr_to_str((*self.ar.get()).what).unwrap_or("main"),
            }
        }
    }
@@ -119,12 +147,12 @@ impl<'lua> Debug<'lua> {
        unsafe {
            #[cfg(not(feature = "luau"))]
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, cstr!("l"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.lua.state(), cstr!("l"), self.ar.get()) != 0,
                "lua_getinfo failed with `l`"
            );
            #[cfg(feature = "luau")]
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, self.level, cstr!("l"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.lua.state(), self.level, cstr!("l"), self.ar.get()) != 0,
                "lua_getinfo failed with `l`"
            );

@@ -139,7 +167,7 @@ impl<'lua> Debug<'lua> {
    pub fn is_tail_call(&self) -> bool {
        unsafe {
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, cstr!("t"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.lua.state(), cstr!("t"), self.ar.get()) != 0,
                "lua_getinfo failed with `t`"
            );
            (*self.ar.get()).currentline != 0
@@ -151,20 +179,20 @@ impl<'lua> Debug<'lua> {
        unsafe {
            #[cfg(not(feature = "luau"))]
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, cstr!("u"), self.ar.get()) != 0,
+                ffi::lua_getinfo(self.lua.state(), cstr!("u"), self.ar.get()) != 0,
                "lua_getinfo failed with `u`"
            );
            #[cfg(feature = "luau")]
            mlua_assert!(
-                ffi::lua_getinfo(self.lua.state, self.level, cstr!("a"), self.ar.get()) != 0,
+                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,
+                num_ups: (*self.ar.get()).nups as _,
                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
-                num_params: (*self.ar.get()).nparams as i32,
+                num_params: (*self.ar.get()).nparams as _,
                #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
                is_vararg: (*self.ar.get()).isvararg != 0,
            };
@@ -209,38 +237,37 @@ pub enum DebugEvent {

 #[derive(Clone, Debug)]
 pub struct DebugNames<'a> {
-    pub name: Option<&'a [u8]>,
-    pub name_what: Option<&'a [u8]>,
+    /// A (reasonable) name of the function (`None` if the name cannot be found).
+    pub name: Option<Cow<'a, str>>,
+    /// Explains the `name` field (can be `global`/`local`/`method`/`field`/`upvalue`/etc).
+    ///
+    /// Always `None` for Luau.
+    pub name_what: Option<&'static str>,
 }

 #[derive(Clone, Debug)]
 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]>,
+    /// Source of the chunk that created the function.
+    pub source: Option<Cow<'a, str>>,
+    /// A "printable" version of `source`, to be used in error messages.
+    pub short_src: Option<Cow<'a, str>>,
+    /// The line number where the definition of the function starts.
+    pub line_defined: Option<usize>,
+    /// The line number where the definition of the function ends (not set by Luau).
+    pub last_line_defined: Option<usize>,
+    /// A string `Lua` if the function is a Lua function, `C` if it is a C function, `main` if it is
+    /// the main part of a chunk.
+    pub what: &'static str,
 }

 #[derive(Copy, Clone, Debug)]
 pub struct DebugStack {
    pub num_ups: i32,
    /// Requires `feature = "lua54/lua53/lua52/luau"`
-    #[cfg(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "luau"
-    ))]
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau"))]
    pub num_params: i32,
    /// Requires `feature = "lua54/lua53/lua52/luau"`
-    #[cfg(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "luau"
-    ))]
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau"))]
    pub is_vararg: bool,
 }

@@ -266,48 +293,59 @@ pub struct HookTriggers {

 #[cfg(not(feature = "luau"))]
 impl HookTriggers {
-    /// Returns a new instance of `HookTriggers` with [`on_calls`] trigger set.
+    /// An instance of `HookTriggers` with `on_calls` trigger set.
+    pub const ON_CALLS: Self = HookTriggers::new().on_calls();
+
+    /// An instance of `HookTriggers` with `on_returns` trigger set.
+    pub const ON_RETURNS: Self = HookTriggers::new().on_returns();
+
+    /// An instance of `HookTriggers` with `every_line` trigger set.
+    pub const EVERY_LINE: Self = HookTriggers::new().every_line();
+
+    /// Returns a new instance of `HookTriggers` with all triggers disabled.
+    pub const fn new() -> Self {
+        HookTriggers {
+            on_calls: false,
+            on_returns: false,
+            every_line: false,
+            every_nth_instruction: None,
+        }
+    }
+
+    /// Returns an instance of `HookTriggers` with [`on_calls`] trigger set.
    ///
    /// [`on_calls`]: #structfield.on_calls
-    pub fn on_calls() -> Self {
-        HookTriggers {
-            on_calls: true,
-            ..Default::default()
-        }
+    pub const fn on_calls(mut self) -> Self {
+        self.on_calls = true;
+        self
    }

-    /// Returns a new instance of `HookTriggers` with [`on_returns`] trigger set.
+    /// Returns an instance of `HookTriggers` with [`on_returns`] trigger set.
    ///
    /// [`on_returns`]: #structfield.on_returns
-    pub fn on_returns() -> Self {
-        HookTriggers {
-            on_returns: true,
-            ..Default::default()
-        }
+    pub const fn on_returns(mut self) -> Self {
+        self.on_returns = true;
+        self
    }

-    /// Returns a new instance of `HookTriggers` with [`every_line`] trigger set.
+    /// Returns an instance of `HookTriggers` with [`every_line`] trigger set.
    ///
    /// [`every_line`]: #structfield.every_line
-    pub fn every_line() -> Self {
-        HookTriggers {
-            every_line: true,
-            ..Default::default()
-        }
+    pub const fn every_line(mut self) -> Self {
+        self.every_line = true;
+        self
    }

-    /// Returns a new instance of `HookTriggers` with [`every_nth_instruction`] trigger set.
+    /// Returns an 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()
-        }
+    pub const fn every_nth_instruction(mut self, n: u32) -> Self {
+        self.every_nth_instruction = Some(n);
+        self
    }

    // Compute the mask to pass to `lua_sethook`.
-    pub(crate) fn mask(&self) -> c_int {
+    pub(crate) const fn mask(&self) -> c_int {
        let mut mask: c_int = 0;
        if self.on_calls {
            mask |= ffi::LUA_MASKCALL
@@ -326,8 +364,11 @@ impl HookTriggers {

    // Returns the `count` parameter to pass to `lua_sethook`, if applicable. Otherwise, zero is
    // returned.
-    pub(crate) fn count(&self) -> c_int {
-        self.every_nth_instruction.unwrap_or(0) as c_int
+    pub(crate) const fn count(&self) -> c_int {
+        match self.every_nth_instruction {
+            Some(n) => n as c_int,
+            None => 0,
+        }
    }
 }

@@ -10,10 +10,10 @@
 //!
 //! # Converting data
 //!
-//! The [`ToLua`] and [`FromLua`] traits allow conversion from Rust types to Lua values and vice
+//! The [`IntoLua`] and [`FromLua`] traits allow conversion from Rust types to Lua values and vice
 //! versa. They are implemented for many data structures found in Rust's standard library.
 //!
-//! For more general conversions, the [`ToLuaMulti`] and [`FromLuaMulti`] traits allow converting
+//! For more general conversions, the [`IntoLuaMulti`] and [`FromLuaMulti`] traits allow converting
 //! between Rust types and *any number* of Lua values.
 //!
 //! Most code in `mlua` is generic over implementors of those traits, so in most places the normal
@@ -27,9 +27,9 @@
 //!
 //! # Serde support
 //!
-//! The [`LuaSerdeExt`] trait implemented for [`Lua`] allows conversion from Rust types to Lua values
-//! and vice versa using serde. Any user defined data type that implements [`serde::Serialize`] or
-//! [`serde::Deserialize`] can be converted.
+//! The [`LuaSerdeExt`] trait implemented for [`Lua`] allows conversion from Rust types to Lua
+//! values and vice versa using serde. Any user defined data type that implements
+//! [`serde::Serialize`] or [`serde::Deserialize`] can be converted.
 //! For convenience, additional functionality to handle `NULL` values and arrays is provided.
 //!
 //! The [`Value`] enum implements [`serde::Serialize`] trait to support serializing Lua values
@@ -40,23 +40,23 @@
 //! # Async/await support
 //!
 //! The [`create_async_function`] allows creating non-blocking functions that returns [`Future`].
-//! Lua code with async capabilities can be executed by [`call_async`] family of functions or polling
-//! [`AsyncThread`] using any runtime (eg. Tokio).
+//! Lua code with async capabilities can be executed by [`call_async`] family of functions or
+//! polling [`AsyncThread`] using any runtime (eg. Tokio).
 //!
 //! Requires `feature = "async"`.
 //!
 //! # `Send` requirement
-//! By default `mlua` is `!Send`. This can be changed by enabling `feature = "send"` that adds `Send` requirement
-//! to [`Function`]s and [`UserData`].
+//! By default `mlua` is `!Send`. This can be changed by enabling `feature = "send"` that adds
+//! `Send` requirement to [`Function`]s and [`UserData`].
 //!
 //! [Lua programming language]: https://www.lua.org/
 //! [`Lua`]: crate::Lua
 //! [executing]: crate::Chunk::exec
 //! [evaluating]: crate::Chunk::eval
 //! [globals]: crate::Lua::globals
-//! [`ToLua`]: crate::ToLua
+//! [`IntoLua`]: crate::IntoLua
 //! [`FromLua`]: crate::FromLua
-//! [`ToLuaMulti`]: crate::ToLuaMulti
+//! [`IntoLuaMulti`]: crate::IntoLuaMulti
 //! [`FromLuaMulti`]: crate::FromLuaMulti
 //! [`Function`]: crate::Function
 //! [`UserData`]: crate::UserData
@@ -73,7 +73,7 @@

 // Deny warnings inside doc tests / examples. When this isn't present, rustdoc doesn't show *any*
 // warnings at all.
-#![doc(test(attr(deny(warnings))))]
+#![doc(test(attr(warn(warnings))))] // FIXME: Remove this when rust-lang/rust#123748 is fixed
 #![cfg_attr(docsrs, feature(doc_cfg))]

 #[macro_use]
@@ -82,66 +82,68 @@ mod macros;
 mod chunk;
 mod conversion;
 mod error;
-mod ffi;
 mod function;
 mod hook;
-mod lua;
 #[cfg(feature = "luau")]
 mod luau;
+mod memory;
 mod multi;
-mod scope;
+// mod scope;
+mod state;
 mod stdlib;
 mod string;
 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 ffi::{self, lua_CFunction, lua_State};

 pub use crate::chunk::{AsChunk, Chunk, ChunkMode};
-pub use crate::error::{Error, ExternalError, ExternalResult, Result};
+pub use crate::error::{Error, ErrorContext, ExternalError, ExternalResult, Result};
 pub use crate::function::{Function, FunctionInfo};
 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::state::{GCMode, Lua, LuaOptions};
+// pub use crate::scope::Scope;
 pub use crate::stdlib::StdLib;
-pub use crate::string::String;
+pub use crate::string::{BorrowedBytes, BorrowedStr, String};
 pub use crate::table::{Table, TableExt, TablePairs, TableSequence};
 pub use crate::thread::{Thread, ThreadStatus};
-pub use crate::types::{Integer, LightUserData, Number, RegistryKey};
+pub use crate::types::{AppDataRef, AppDataRefMut, Integer, LightUserData, Number, RegistryKey};
 pub use crate::userdata::{
-    AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMetatable, UserDataMethods,
+    AnyUserData, AnyUserDataExt, MetaMethod, UserData, UserDataFields, UserDataMetatable, UserDataMethods,
+    UserDataRef, UserDataRefMut, UserDataRegistry,
 };
-pub use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti, Value};
+pub use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Nil, 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, function::CoverageInfo, types::VmState};
+pub use crate::{
+    chunk::Compiler,
+    function::CoverageInfo,
+    types::{Vector, VmState},
+};

 #[cfg(feature = "async")]
 pub use crate::thread::AsyncThread;

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

 #[cfg(feature = "serialize")]
 #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
 pub mod serde;

-#[cfg(any(feature = "mlua_derive"))]
+#[cfg(feature = "mlua_derive")]
 #[allow(unused_imports)]
 #[macro_use]
 extern crate mlua_derive;
@@ -151,7 +153,7 @@ extern crate mlua_derive;
 /// This macro allows to write Lua code directly in Rust code.
 ///
 /// Rust variables can be referenced from Lua using `$` prefix, as shown in the example below.
-/// User's Rust types needs to implement [`UserData`] or [`ToLua`] traits.
+/// User's Rust types needs to implement [`UserData`] or [`IntoLua`] traits.
 ///
 /// Captured variables are **moved** into the chunk.
 ///
@@ -186,8 +188,8 @@ extern crate mlua_derive;
 ///
 /// Other minor limitations:
 ///
-/// - Certain escape codes in string literals don't work.
-///   (Specifically: `\a`, `\b`, `\f`, `\v`, `\123` (octal escape codes), `\u`, and `\U`).
+/// - Certain escape codes in string literals don't work. (Specifically: `\a`, `\b`, `\f`, `\v`,
+///   `\123` (octal escape codes), `\u`, and `\U`).
 ///
 ///   These are accepted: : `\\`, `\n`, `\t`, `\r`, `\xAB` (hex escape codes), and `\0`.
 ///
@@ -197,11 +199,19 @@ extern crate mlua_derive;
 ///
 /// [`AsChunk`]: crate::AsChunk
 /// [`UserData`]: crate::UserData
-/// [`ToLua`]: crate::ToLua
-#[cfg(any(feature = "macros"))]
+/// [`IntoLua`]: crate::IntoLua
+#[cfg(feature = "macros")]
 #[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
 pub use mlua_derive::chunk;

+/// Derive [`FromLua`] for a Rust type.
+///
+/// Current implementation generate code that takes [`UserData`] value, borrow it (of the Rust type)
+/// and clone.
+#[cfg(feature = "macros")]
+#[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
+pub use mlua_derive::FromLua;
+
 /// Registers Lua module entrypoint.
 ///
 /// You can register multiple entrypoints as required.
@@ -219,6 +229,42 @@ pub use mlua_derive::chunk;
 ///
 /// Internally in the code above the compiler defines C function `luaopen_my_module`.
 ///
+/// You can also pass options to the attribute:
+///
+/// * name - name of the module, defaults to the name of the function
+///
+/// ```ignore
+/// #[mlua::lua_module(name = "alt_module")]
+/// fn my_module(lua: &Lua) -> Result<Table> {
+///     ...
+/// }
+/// ```
+///
+/// * skip_memory_check - skip memory allocation checks for some operations.
+///
+/// In module mode, mlua runs in unknown environment and cannot say are there any memory
+/// limits or not. As result, some operations that require memory allocation runs in
+/// protected mode. Setting this attribute will improve performance of such operations
+/// with risk of having uncaught exceptions and memory leaks.
+///
+/// ```ignore
+/// #[mlua::lua_module(skip_memory_check)]
+/// fn my_module(lua: &Lua) -> Result<Table> {
+///     ...
+/// }
+/// ```
 #[cfg(any(feature = "module", docsrs))]
 #[cfg_attr(docsrs, doc(cfg(feature = "module")))]
 pub use mlua_derive::lua_module;
+
+pub(crate) mod private {
+    use super::*;
+
+    pub trait Sealed {}
+
+    impl Sealed for Error {}
+    impl<T> Sealed for std::result::Result<T, Error> {}
+    impl Sealed for Lua {}
+    impl Sealed for Table {}
+    impl Sealed for AnyUserData {}
+}
@@ -1,130 +0,0 @@
-use std::ffi::CStr;
-use std::os::raw::{c_float, c_int};
-
-use crate::chunk::ChunkMode;
-use crate::error::{Error, Result};
-use crate::ffi;
-use crate::lua::Lua;
-use crate::table::Table;
-use crate::util::{check_stack, StackGuard};
-use crate::value::Value;
-
-// Since Luau has some missing standard function, we re-implement them here
-
-impl Lua {
-    pub(crate) unsafe fn prepare_luau_state(&self) -> Result<()> {
-        let globals = self.globals();
-
-        globals.raw_set(
-            "collectgarbage",
-            self.create_c_function(lua_collectgarbage)?,
-        )?;
-        globals.raw_set("require", self.create_function(lua_require)?)?;
-        globals.raw_set("vector", self.create_c_function(lua_vector)?)?;
-
-        // Set `_VERSION` global to include version number
-        // The environment variable `LUAU_VERSION` set by the build script
-        if let Some(version) = option_env!("LUAU_VERSION") {
-            globals.raw_set("_VERSION", format!("Luau {version}"))?;
-        }
-
-        Ok(())
-    }
-}
-
-unsafe extern "C" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_int {
-    let option = ffi::luaL_optstring(state, 1, cstr!("collect"));
-    let option = CStr::from_ptr(option);
-    let arg = ffi::luaL_optinteger(state, 2, 0);
-    match option.to_str() {
-        Ok("collect") => {
-            ffi::lua_gc(state, ffi::LUA_GCCOLLECT, 0);
-            0
-        }
-        Ok("stop") => {
-            ffi::lua_gc(state, ffi::LUA_GCSTOP, 0);
-            0
-        }
-        Ok("restart") => {
-            ffi::lua_gc(state, ffi::LUA_GCRESTART, 0);
-            0
-        }
-        Ok("count") => {
-            let kbytes = ffi::lua_gc(state, ffi::LUA_GCCOUNT, 0) as ffi::lua_Number;
-            let kbytes_rem = ffi::lua_gc(state, ffi::LUA_GCCOUNTB, 0) as ffi::lua_Number;
-            ffi::lua_pushnumber(state, kbytes + kbytes_rem / 1024.0);
-            1
-        }
-        Ok("step") => {
-            let res = ffi::lua_gc(state, ffi::LUA_GCSTEP, arg);
-            ffi::lua_pushboolean(state, res);
-            1
-        }
-        Ok("isrunning") => {
-            let res = ffi::lua_gc(state, ffi::LUA_GCISRUNNING, 0);
-            ffi::lua_pushboolean(state, res);
-            1
-        }
-        _ => ffi::luaL_error(state, cstr!("collectgarbage called with invalid option")),
-    }
-}
-
-fn lua_require(lua: &Lua, name: Option<std::string::String>) -> Result<Value> {
-    let name = name.ok_or_else(|| Error::RuntimeError("invalid module name".into()))?;
-
-    // Find module in the cache
-    let loaded = unsafe {
-        let _sg = StackGuard::new(lua.state);
-        check_stack(lua.state, 2)?;
-        protect_lua!(lua.state, 0, 1, fn(state) {
-            ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, cstr!("_LOADED"));
-        })?;
-        Table(lua.pop_ref())
-    };
-    if let Some(v) = loaded.raw_get(name.clone())? {
-        return Ok(v);
-    }
-
-    // Load file from filesystem
-    let mut search_path = std::env::var("LUAU_PATH").unwrap_or_default();
-    if search_path.is_empty() {
-        search_path = "?.luau;?.lua".into();
-    }
-
-    let (mut source, mut source_name) = (None, String::new());
-    for path in search_path.split(';') {
-        let file_path = path.replacen('?', &name, 1);
-        if let Ok(buf) = std::fs::read(&file_path) {
-            source = Some(buf);
-            source_name = file_path;
-            break;
-        }
-    }
-    let source = source.ok_or_else(|| Error::RuntimeError(format!("cannot find '{}'", name)))?;
-
-    let value = lua
-        .load(&source)
-        .set_name(&format!("={}", source_name))?
-        .set_mode(ChunkMode::Text)
-        .call::<_, Value>(())?;
-
-    // Save in the cache
-    loaded.raw_set(
-        name,
-        match value.clone() {
-            Value::Nil => Value::Boolean(true),
-            v => v,
-        },
-    )?;
-
-    Ok(value)
-}
-
-// Luau vector datatype constructor
-unsafe extern "C" fn lua_vector(state: *mut ffi::lua_State) -> c_int {
-    let x = ffi::luaL_checknumber(state, 1) as c_float;
-    let y = ffi::luaL_checknumber(state, 2) as c_float;
-    let z = ffi::luaL_checknumber(state, 3) as c_float;
-    ffi::lua_pushvector(state, x, y, z);
-    1
-}
@@ -0,0 +1,85 @@
+use std::ffi::CStr;
+use std::os::raw::{c_float, c_int};
+
+use crate::error::Result;
+use crate::state::Lua;
+
+// Since Luau has some missing standard functions, we re-implement them here
+
+impl Lua {
+    pub(crate) unsafe fn configure_luau(&self) -> Result<()> {
+        let globals = self.globals();
+
+        globals.raw_set("collectgarbage", self.create_c_function(lua_collectgarbage)?)?;
+        globals.raw_set("vector", self.create_c_function(lua_vector)?)?;
+
+        // Set `_VERSION` global to include version number
+        // The environment variable `LUAU_VERSION` set by the build script
+        if let Some(version) = ffi::luau_version() {
+            globals.raw_set("_VERSION", format!("Luau {version}"))?;
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn disable_c_modules(&self) -> Result<()> {
+        package::disable_dylibs(self);
+        Ok(())
+    }
+}
+
+unsafe extern "C-unwind" fn lua_collectgarbage(state: *mut ffi::lua_State) -> c_int {
+    let option = ffi::luaL_optstring(state, 1, cstr!("collect"));
+    let option = CStr::from_ptr(option);
+    let arg = ffi::luaL_optinteger(state, 2, 0);
+    match option.to_str() {
+        Ok("collect") => {
+            ffi::lua_gc(state, ffi::LUA_GCCOLLECT, 0);
+            0
+        }
+        Ok("stop") => {
+            ffi::lua_gc(state, ffi::LUA_GCSTOP, 0);
+            0
+        }
+        Ok("restart") => {
+            ffi::lua_gc(state, ffi::LUA_GCRESTART, 0);
+            0
+        }
+        Ok("count") => {
+            let kbytes = ffi::lua_gc(state, ffi::LUA_GCCOUNT, 0) as ffi::lua_Number;
+            let kbytes_rem = ffi::lua_gc(state, ffi::LUA_GCCOUNTB, 0) as ffi::lua_Number;
+            ffi::lua_pushnumber(state, kbytes + kbytes_rem / 1024.0);
+            1
+        }
+        Ok("step") => {
+            let res = ffi::lua_gc(state, ffi::LUA_GCSTEP, arg);
+            ffi::lua_pushboolean(state, res);
+            1
+        }
+        Ok("isrunning") => {
+            let res = ffi::lua_gc(state, ffi::LUA_GCISRUNNING, 0);
+            ffi::lua_pushboolean(state, res);
+            1
+        }
+        _ => ffi::luaL_error(state, cstr!("collectgarbage called with invalid option")),
+    }
+}
+
+// Luau vector datatype constructor
+unsafe extern "C-unwind" fn lua_vector(state: *mut ffi::lua_State) -> c_int {
+    let x = ffi::luaL_checknumber(state, 1) as c_float;
+    let y = ffi::luaL_checknumber(state, 2) as c_float;
+    let z = ffi::luaL_checknumber(state, 3) as c_float;
+    #[cfg(feature = "luau-vector4")]
+    let w = ffi::luaL_checknumber(state, 4) as c_float;
+
+    #[cfg(not(feature = "luau-vector4"))]
+    ffi::lua_pushvector(state, x, y, z);
+    #[cfg(feature = "luau-vector4")]
+    ffi::lua_pushvector(state, x, y, z, w);
+    1
+}
+
+pub(crate) use package::register_package_module;
+
+mod package;
@@ -0,0 +1,268 @@
+use std::ffi::CStr;
+use std::fmt::Write;
+use std::os::raw::c_int;
+use std::path::{PathBuf, MAIN_SEPARATOR_STR};
+use std::string::String as StdString;
+use std::{env, fs};
+
+use crate::chunk::ChunkMode;
+use crate::error::Result;
+use crate::state::Lua;
+use crate::table::Table;
+use crate::types::RegistryKey;
+use crate::value::{IntoLua, Value};
+
+#[cfg(unix)]
+use {libloading::Library, rustc_hash::FxHashMap};
+
+//
+// Luau package module
+//
+
+#[cfg(unix)]
+const TARGET_MLUA_LUAU_ABI_VERSION: u32 = 1;
+
+#[cfg(all(unix, feature = "module"))]
+#[no_mangle]
+#[used]
+pub static MLUA_LUAU_ABI_VERSION: u32 = TARGET_MLUA_LUAU_ABI_VERSION;
+
+// We keep reference to the `package` table in registry under this key
+struct PackageKey(RegistryKey);
+
+// We keep reference to the loaded dylibs in application data
+#[cfg(unix)]
+struct LoadedDylibs(FxHashMap<PathBuf, Library>);
+
+#[cfg(unix)]
+impl std::ops::Deref for LoadedDylibs {
+    type Target = FxHashMap<PathBuf, Library>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+#[cfg(unix)]
+impl std::ops::DerefMut for LoadedDylibs {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+pub(crate) fn register_package_module(lua: &Lua) -> Result<()> {
+    // Create the package table and store it in app_data for later use (bypassing globals lookup)
+    let package = lua.create_table()?;
+    lua.set_app_data(PackageKey(lua.create_registry_value(&package)?));
+
+    // Set `package.path`
+    let mut search_path = env::var("LUAU_PATH")
+        .or_else(|_| env::var("LUA_PATH"))
+        .unwrap_or_default();
+    if search_path.is_empty() {
+        search_path = "?.luau;?.lua".to_string();
+    }
+    package.raw_set("path", search_path)?;
+
+    // Set `package.cpath`
+    #[cfg(unix)]
+    {
+        let mut search_cpath = env::var("LUAU_CPATH")
+            .or_else(|_| env::var("LUA_CPATH"))
+            .unwrap_or_default();
+        if search_cpath.is_empty() {
+            if cfg!(any(target_os = "macos", target_os = "ios")) {
+                search_cpath = "?.dylib".to_string();
+            } else {
+                search_cpath = "?.so".to_string();
+            }
+        }
+        package.raw_set("cpath", search_cpath)?;
+    }
+
+    // Set `package.loaded` (table with a list of loaded modules)
+    let loaded = lua.create_table()?;
+    package.raw_set("loaded", &loaded)?;
+    lua.set_named_registry_value("_LOADED", loaded)?;
+
+    // Set `package.loaders`
+    let loaders = lua.create_sequence_from([lua.create_function(lua_loader)?])?;
+    package.raw_set("loaders", &loaders)?;
+    #[cfg(unix)]
+    {
+        loaders.push(lua.create_function(dylib_loader)?)?;
+        lua.set_app_data(LoadedDylibs(FxHashMap::default()));
+    }
+    lua.set_named_registry_value("_LOADERS", loaders)?;
+
+    // Register the module and `require` function in globals
+    let globals = lua.globals();
+    globals.raw_set("package", package)?;
+    globals.raw_set("require", unsafe { lua.create_c_function(lua_require)? })?;
+
+    Ok(())
+}
+
+#[allow(unused_variables)]
+pub(crate) fn disable_dylibs(lua: &Lua) {
+    // Presence of `LoadedDylibs` in app data is used as a flag
+    // to check whether binary modules are enabled
+    #[cfg(unix)]
+    lua.remove_app_data::<LoadedDylibs>();
+}
+
+unsafe extern "C-unwind" fn lua_require(state: *mut ffi::lua_State) -> c_int {
+    ffi::lua_settop(state, 1);
+    let name = ffi::luaL_checkstring(state, 1);
+    ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, cstr!("_LOADED")); // _LOADED is at index 2
+    if ffi::lua_rawgetfield(state, 2, name) != ffi::LUA_TNIL {
+        return 1; // module is already loaded
+    }
+    ffi::lua_pop(state, 1); // remove nil
+
+    // load the module
+    let err_buf = ffi::lua_newuserdata_t::<StdString>(state);
+    err_buf.write(StdString::new());
+    ffi::luaL_getsubtable(state, ffi::LUA_REGISTRYINDEX, cstr!("_LOADERS")); // _LOADERS is at index 3
+    for i in 1.. {
+        if ffi::lua_rawgeti(state, -1, i) == ffi::LUA_TNIL {
+            // no more loaders?
+            if (*err_buf).is_empty() {
+                ffi::luaL_error(state, cstr!("module '%s' not found"), name);
+            } else {
+                let bytes = (*err_buf).as_bytes();
+                let extra = ffi::lua_pushlstring(state, bytes.as_ptr() as *const _, bytes.len());
+                ffi::luaL_error(state, cstr!("module '%s' not found:%s"), name, extra);
+            }
+        }
+        ffi::lua_pushvalue(state, 1); // name arg
+        ffi::lua_call(state, 1, 2); // call loader
+        match ffi::lua_type(state, -2) {
+            ffi::LUA_TFUNCTION => break, // loader found
+            ffi::LUA_TSTRING => {
+                // error message
+                let msg = ffi::lua_tostring(state, -2);
+                let msg = CStr::from_ptr(msg).to_string_lossy();
+                _ = write!(&mut *err_buf, "\n\t{msg}");
+            }
+            _ => {}
+        }
+        ffi::lua_pop(state, 2); // remove both results
+    }
+    ffi::lua_pushvalue(state, 1); // name is 1st argument to module loader
+    ffi::lua_rotate(state, -2, 1); // loader data <-> name
+
+    // stack: ...; loader function; module name; loader data
+    ffi::lua_call(state, 2, 1);
+    // stack: ...; result from loader function
+    if ffi::lua_isnil(state, -1) != 0 {
+        ffi::lua_pop(state, 1);
+        ffi::lua_pushboolean(state, 1); // use true as result
+    }
+    ffi::lua_pushvalue(state, -1); // make copy of entrypoint result
+    ffi::lua_setfield(state, 2, name); /* _LOADED[name] = returned value */
+    1
+}
+
+/// Searches for the given `name` in the given `path`.
+///
+/// `path` is a string containing a sequence of templates separated by semicolons.
+fn package_searchpath(name: &str, search_path: &str, try_prefix: bool) -> Option<PathBuf> {
+    let mut names = vec![name.replace('.', MAIN_SEPARATOR_STR)];
+    if try_prefix && name.contains('.') {
+        let prefix = name.split_once('.').map(|(prefix, _)| prefix).unwrap();
+        names.push(prefix.to_string());
+    }
+    for path in search_path.split(';') {
+        for name in &names {
+            let file_path = PathBuf::from(path.replace('?', name));
+            if let Ok(true) = fs::metadata(&file_path).map(|m| m.is_file()) {
+                return Some(file_path);
+            }
+        }
+    }
+    None
+}
+
+//
+// Module loaders
+//
+
+/// Tries to load a lua (text) file
+fn lua_loader(lua: &Lua, modname: StdString) -> Result<Value> {
+    let package = {
+        let key = lua.app_data_ref::<PackageKey>().unwrap();
+        lua.registry_value::<Table>(&key.0)
+    }?;
+    let search_path = package.get::<_, StdString>("path").unwrap_or_default();
+
+    if let Some(file_path) = package_searchpath(&modname, &search_path, false) {
+        match fs::read(&file_path) {
+            Ok(buf) => {
+                return lua
+                    .load(&buf)
+                    .set_name(&format!("={}", file_path.display()))
+                    .set_mode(ChunkMode::Text)
+                    .into_function()
+                    .map(Value::Function);
+            }
+            Err(err) => {
+                return format!("cannot open '{}': {err}", file_path.display()).into_lua(lua);
+            }
+        }
+    }
+
+    Ok(Value::Nil)
+}
+
+/// Tries to load a dynamic library
+#[cfg(unix)]
+fn dylib_loader(lua: &Lua, modname: StdString) -> Result<Value> {
+    let package = {
+        let key = lua.app_data_ref::<PackageKey>().unwrap();
+        lua.registry_value::<Table>(&key.0)
+    }?;
+    let search_cpath = package.get::<_, StdString>("cpath").unwrap_or_default();
+
+    let find_symbol = |lib: &Library| unsafe {
+        if let Ok(entry) = lib.get::<ffi::lua_CFunction>(format!("luaopen_{modname}\0").as_bytes()) {
+            return lua.create_c_function(*entry).map(Value::Function);
+        }
+        // Try all in one mode
+        if let Ok(entry) =
+            lib.get::<ffi::lua_CFunction>(format!("luaopen_{}\0", modname.replace('.', "_")).as_bytes())
+        {
+            return lua.create_c_function(*entry).map(Value::Function);
+        }
+        "cannot find module entrypoint".into_lua(lua)
+    };
+
+    if let Some(file_path) = package_searchpath(&modname, &search_cpath, true) {
+        let file_path = file_path.canonicalize()?;
+        // Load the library and check for symbol
+        unsafe {
+            let mut loaded_dylibs = match lua.app_data_mut::<LoadedDylibs>() {
+                Some(loaded_dylibs) => loaded_dylibs,
+                None => return "dynamic libraries are disabled in safe mode".into_lua(lua),
+            };
+            // Check if it's already loaded
+            if let Some(lib) = loaded_dylibs.get(&file_path) {
+                return find_symbol(lib);
+            }
+            if let Ok(lib) = Library::new(&file_path) {
+                // Check version
+                let mod_version = lib.get::<*const u32>(b"MLUA_LUAU_ABI_VERSION");
+                let mod_version = mod_version.map(|v| **v).unwrap_or_default();
+                if mod_version != TARGET_MLUA_LUAU_ABI_VERSION {
+                    let err = format!("wrong module ABI version (expected {TARGET_MLUA_LUAU_ABI_VERSION}, got {mod_version})");
+                    return err.into_lua(lua);
+                }
+                let symbol = find_symbol(&lib);
+                loaded_dylibs.insert(file_path, lib);
+                return symbol;
+            }
+        }
+    }
+
+    Ok(Value::Nil)
+}
@@ -10,8 +10,7 @@ macro_rules! bug_msg {

 macro_rules! cstr {
    ($s:expr) => {
-        concat!($s, "\0") as *const str as *const [::std::os::raw::c_char]
-            as *const ::std::os::raw::c_char
+        concat!($s, "\0") as *const str as *const [::std::os::raw::c_char] as *const ::std::os::raw::c_char
    };
 }

@@ -101,9 +100,15 @@ macro_rules! protect_lua {
    };

    ($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 {
+        use ::std::os::raw::c_int;
+        unsafe extern "C-unwind" fn do_call($state_inner: *mut ffi::lua_State) -> c_int {
            $code;
-            $nresults
+            let nresults = $nresults;
+            if nresults == ::ffi::LUA_MULTRET {
+                ffi::lua_gettop($state_inner)
+            } else {
+                nresults
+            }
        }

        crate::util::protect_lua_call($state, $nargs, do_call)
@@ -0,0 +1,147 @@
+use std::alloc::{self, Layout};
+use std::os::raw::c_void;
+use std::ptr;
+
+pub(crate) static ALLOCATOR: ffi::lua_Alloc = allocator;
+
+#[repr(C)]
+#[derive(Default)]
+pub(crate) struct MemoryState {
+    used_memory: isize,
+    memory_limit: isize,
+    // Can be set to temporary ignore the memory limit.
+    // This is used when calling `lua_pushcfunction` for lua5.1/jit/luau.
+    ignore_limit: bool,
+    // Indicates that the memory limit was reached on the last allocation.
+    #[cfg(feature = "luau")]
+    limit_reached: bool,
+}
+
+impl MemoryState {
+    #[inline]
+    pub(crate) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
+        let mut mem_state = ptr::null_mut();
+        #[cfg(feature = "luau")]
+        {
+            ffi::lua_getallocf(state, &mut mem_state);
+            mlua_assert!(!mem_state.is_null(), "Luau state has no allocator userdata");
+        }
+        #[cfg(not(feature = "luau"))]
+        if ffi::lua_getallocf(state, &mut mem_state) != ALLOCATOR {
+            mem_state = ptr::null_mut();
+        }
+        mem_state as *mut MemoryState
+    }
+
+    #[inline]
+    pub(crate) fn used_memory(&self) -> usize {
+        self.used_memory as usize
+    }
+
+    #[inline]
+    pub(crate) fn memory_limit(&self) -> usize {
+        self.memory_limit as usize
+    }
+
+    #[inline]
+    pub(crate) fn set_memory_limit(&mut self, limit: usize) -> usize {
+        let prev_limit = self.memory_limit;
+        self.memory_limit = limit as isize;
+        prev_limit as usize
+    }
+
+    // This function is used primarily for calling `lua_pushcfunction` in lua5.1/jit/luau
+    // to bypass the memory limit (if set).
+    #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+    #[inline]
+    pub(crate) unsafe fn relax_limit_with(state: *mut ffi::lua_State, f: impl FnOnce()) {
+        let mem_state = Self::get(state);
+        if !mem_state.is_null() {
+            (*mem_state).ignore_limit = true;
+            f();
+            (*mem_state).ignore_limit = false;
+        } else {
+            f();
+        }
+    }
+
+    // Does nothing apart from calling `f()`, we don't need to bypass any limits
+    #[cfg(any(feature = "lua52", feature = "lua53", feature = "lua54"))]
+    #[inline]
+    pub(crate) unsafe fn relax_limit_with(_state: *mut ffi::lua_State, f: impl FnOnce()) {
+        f();
+    }
+
+    // Returns `true` if the memory limit was reached on the last memory operation
+    #[cfg(feature = "luau")]
+    #[inline]
+    pub(crate) unsafe fn limit_reached(state: *mut ffi::lua_State) -> bool {
+        (*Self::get(state)).limit_reached
+    }
+}
+
+unsafe extern "C-unwind" fn allocator(
+    extra: *mut c_void,
+    ptr: *mut c_void,
+    osize: usize,
+    nsize: usize,
+) -> *mut c_void {
+    let mem_state = &mut *(extra as *mut MemoryState);
+    #[cfg(feature = "luau")]
+    {
+        // Reset the flag
+        mem_state.limit_reached = false;
+    }
+
+    if nsize == 0 {
+        // Free memory
+        if !ptr.is_null() {
+            let layout = Layout::from_size_align_unchecked(osize, ffi::SYS_MIN_ALIGN);
+            alloc::dealloc(ptr as *mut u8, layout);
+            mem_state.used_memory -= osize as isize;
+        }
+        return ptr::null_mut();
+    }
+
+    // Do not allocate more than isize::MAX
+    if nsize > isize::MAX as usize {
+        return ptr::null_mut();
+    }
+
+    // Are we fit to the memory limits?
+    let mut mem_diff = nsize as isize;
+    if !ptr.is_null() {
+        mem_diff -= osize as isize;
+    }
+    let mem_limit = mem_state.memory_limit;
+    let new_used_memory = mem_state.used_memory + mem_diff;
+    if mem_limit > 0 && new_used_memory > mem_limit && !mem_state.ignore_limit {
+        #[cfg(feature = "luau")]
+        {
+            mem_state.limit_reached = true;
+        }
+        return ptr::null_mut();
+    }
+    mem_state.used_memory += mem_diff;
+
+    if ptr.is_null() {
+        // Allocate new memory
+        let new_layout = match Layout::from_size_align(nsize, ffi::SYS_MIN_ALIGN) {
+            Ok(layout) => layout,
+            Err(_) => return ptr::null_mut(),
+        };
+        let new_ptr = alloc::alloc(new_layout) as *mut c_void;
+        if new_ptr.is_null() {
+            alloc::handle_alloc_error(new_layout);
+        }
+        return new_ptr;
+    }
+
+    // Reallocate memory
+    let old_layout = Layout::from_size_align_unchecked(osize, ffi::SYS_MIN_ALIGN);
+    let new_ptr = alloc::realloc(ptr as *mut u8, old_layout, nsize) as *mut c_void;
+    if new_ptr.is_null() {
+        alloc::handle_alloc_error(old_layout);
+    }
+    new_ptr
+}
@@ -1,58 +1,104 @@
-#![allow(clippy::wrong_self_convention)]
-
 use std::iter::FromIterator;
 use std::ops::{Deref, DerefMut};
+use std::os::raw::c_int;
 use std::result::Result as StdResult;

 use crate::error::Result;
-use crate::lua::Lua;
-use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti};
+use crate::state::{Lua, RawLua};
+use crate::util::check_stack;
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Nil};

 /// Result is convertible to `MultiValue` following the common Lua idiom of returning the result
 /// 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> {
+impl<T: IntoLua, E: IntoLua> IntoLuaMulti for StdResult<T, E> {
    #[inline]
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut result = MultiValue::new_or_cached(lua);
+    fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
        match self {
-            Ok(v) => result.push_front(v.to_lua(lua)?),
-            Err(e) => {
-                result.push_front(e.to_lua(lua)?);
-                result.push_front(Nil);
-            }
+            Ok(val) => (val,).into_lua_multi(lua),
+            Err(err) => (Nil, err).into_lua_multi(lua),
+        }
+    }
+
+    #[inline]
+    unsafe fn push_into_stack_multi(self, lua: &RawLua) -> Result<c_int> {
+        match self {
+            Ok(val) => (val,).push_into_stack_multi(lua),
+            Err(err) => (Nil, err).push_into_stack_multi(lua),
        }
-        Ok(result)
    }
 }

-impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for T {
+impl<E: IntoLua> IntoLuaMulti for StdResult<(), E> {
    #[inline]
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut v = MultiValue::new_or_cached(lua);
-        v.push_front(self.to_lua(lua)?);
+    fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
+        match self {
+            Ok(_) => Ok(MultiValue::new()),
+            Err(err) => (Nil, err).into_lua_multi(lua),
+        }
+    }
+
+    #[inline]
+    unsafe fn push_into_stack_multi(self, lua: &RawLua) -> Result<c_int> {
+        match self {
+            Ok(_) => Ok(0),
+            Err(err) => (Nil, err).push_into_stack_multi(lua),
+        }
+    }
+}
+
+impl<T: IntoLua> IntoLuaMulti for T {
+    #[inline]
+    fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
+        let mut v = MultiValue::with_lua_and_capacity(lua, 1);
+        v.push_back(self.into_lua(lua)?);
        Ok(v)
    }
-}

-impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for T {
    #[inline]
-    fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
-        let res = T::from_lua(values.pop_front().unwrap_or(Nil), lua);
-        lua.cache_multivalue(values);
-        res
+    unsafe fn push_into_stack_multi(self, lua: &RawLua) -> Result<c_int> {
+        self.push_into_stack(lua)?;
+        Ok(1)
    }
 }

-impl<'lua> ToLuaMulti<'lua> for MultiValue<'lua> {
+impl<T: FromLua> FromLuaMulti for T {
    #[inline]
-    fn to_lua_multi(self, _: &'lua Lua) -> Result<MultiValue<'lua>> {
+    fn from_lua_multi(mut values: MultiValue, lua: &Lua) -> Result<Self> {
+        T::from_lua(values.pop_front().unwrap_or(Nil), lua)
+    }
+
+    #[inline]
+    fn from_lua_args(mut args: MultiValue, i: usize, to: Option<&str>, lua: &Lua) -> Result<Self> {
+        T::from_lua_arg(args.pop_front().unwrap_or(Nil), i, to, lua)
+    }
+
+    #[inline]
+    unsafe fn from_stack_multi(nvals: c_int, lua: &RawLua) -> Result<Self> {
+        if nvals == 0 {
+            return T::from_lua(Nil, lua.lua());
+        }
+        T::from_stack(-nvals, lua)
+    }
+
+    #[inline]
+    unsafe fn from_stack_args(nargs: c_int, i: usize, to: Option<&str>, lua: &RawLua) -> Result<Self> {
+        if nargs == 0 {
+            return T::from_lua_arg(Nil, i, to, lua.lua());
+        }
+        T::from_stack_arg(-nargs, i, to, lua)
+    }
+}
+
+impl IntoLuaMulti for MultiValue {
+    #[inline]
+    fn into_lua_multi(self, _: &Lua) -> Result<MultiValue> {
        Ok(self)
    }
 }

-impl<'lua> FromLuaMulti<'lua> for MultiValue<'lua> {
+impl FromLuaMulti for MultiValue {
    #[inline]
-    fn from_lua_multi(values: MultiValue<'lua>, _: &'lua Lua) -> Result<Self> {
+    fn from_lua_multi(values: MultiValue, _: &Lua) -> Result<Self> {
        Ok(values)
    }
 }
@@ -128,74 +174,141 @@ impl<T> DerefMut for Variadic<T> {
    }
 }

-impl<'lua, T: ToLua<'lua>> ToLuaMulti<'lua> for Variadic<T> {
+impl<T: IntoLua> IntoLuaMulti for Variadic<T> {
    #[inline]
-    fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-        let mut values = MultiValue::new_or_cached(lua);
-        values.refill(self.0.into_iter().map(|e| e.to_lua(lua)))?;
+    fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
+        let mut values = MultiValue::with_lua_and_capacity(lua, self.0.len());
+        values.extend_from_values(self.0.into_iter().map(|val| val.into_lua(lua)))?;
        Ok(values)
    }
 }

-impl<'lua, T: FromLua<'lua>> FromLuaMulti<'lua> for Variadic<T> {
+impl<T: FromLua> FromLuaMulti for Variadic<T> {
    #[inline]
-    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))
+    fn from_lua_multi(mut values: MultiValue, lua: &Lua) -> Result<Self> {
+        values
+            .drain(..)
+            .map(|val| T::from_lua(val, lua))
            .collect::<Result<Vec<T>>>()
-            .map(Variadic);
-        lua.cache_multivalue(values);
-        res
+            .map(Variadic)
    }
 }

 macro_rules! impl_tuple {
    () => (
-        impl<'lua> ToLuaMulti<'lua> for () {
+        impl IntoLuaMulti for () {
            #[inline]
-            fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
-                Ok(MultiValue::new_or_cached(lua))
+            fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
+                Ok(MultiValue::with_lua_and_capacity(lua, 0))
+            }
+
+            #[inline]
+            unsafe fn push_into_stack_multi(self, _lua: &RawLua) -> Result<c_int> {
+                Ok(0)
            }
        }

-        impl<'lua> FromLuaMulti<'lua> for () {
+        impl FromLuaMulti for () {
            #[inline]
-            fn from_lua_multi(values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
-                lua.cache_multivalue(values);
+            fn from_lua_multi(_values: MultiValue, _lua: &Lua) -> Result<Self> {
+                Ok(())
+            }
+
+            #[inline]
+            unsafe fn from_stack_multi(nvals: c_int, lua: &RawLua) -> Result<Self> {
+                if nvals > 0 {
+                    ffi::lua_pop(lua.state(), nvals);
+                }
                Ok(())
            }
        }
    );

    ($last:ident $($name:ident)*) => (
-        impl<'lua, $($name,)* $last> ToLuaMulti<'lua> for ($($name,)* $last,)
-            where $($name: ToLua<'lua>,)*
-                  $last: ToLuaMulti<'lua>
+        impl<$($name,)* $last> IntoLuaMulti for ($($name,)* $last,)
+            where $($name: IntoLua,)*
+                  $last: IntoLuaMulti
        {
-            #[allow(unused_mut)]
-            #[allow(non_snake_case)]
+            #[allow(unused_mut, non_snake_case)]
            #[inline]
-            fn to_lua_multi(self, lua: &'lua Lua) -> Result<MultiValue<'lua>> {
+            fn into_lua_multi(self, lua: &Lua) -> Result<MultiValue> {
                let ($($name,)* $last,) = self;

-                let mut results = $last.to_lua_multi(lua)?;
-                push_reverse!(results, $($name.to_lua(lua)?,)*);
+                let mut results = $last.into_lua_multi(lua)?;
+                push_reverse!(results, $($name.into_lua(lua)?,)*);
                Ok(results)
            }
+
+            #[allow(non_snake_case)]
+            #[inline]
+            unsafe fn push_into_stack_multi(self, lua: &RawLua) -> Result<c_int> {
+                let ($($name,)* $last,) = self;
+                let mut nresults = 0;
+                $(
+                    _ = $name;
+                    nresults += 1;
+                )*
+                check_stack(lua.state(), nresults + 1)?;
+                $(
+                    $name.push_into_stack(lua)?;
+                )*
+                nresults += $last.push_into_stack_multi(lua)?;
+                Ok(nresults)
+            }
        }

-        impl<'lua, $($name,)* $last> FromLuaMulti<'lua> for ($($name,)* $last,)
-            where $($name: FromLua<'lua>,)*
-                  $last: FromLuaMulti<'lua>
+        impl<$($name,)* $last> FromLuaMulti for ($($name,)* $last,)
+            where $($name: FromLua,)*
+                  $last: FromLuaMulti
        {
-            #[allow(unused_mut)]
-            #[allow(non_snake_case)]
+            #[allow(unused_mut, non_snake_case)]
            #[inline]
-            fn from_lua_multi(mut values: MultiValue<'lua>, lua: &'lua Lua) -> Result<Self> {
-                $(let $name = values.pop_front().unwrap_or(Nil);)*
+            fn from_lua_multi(mut values: MultiValue, lua: &Lua) -> Result<Self> {
+                $(let $name = FromLua::from_lua(values.pop_front().unwrap_or(Nil), lua)?;)*
                let $last = FromLuaMulti::from_lua_multi(values, lua)?;
-                Ok(($(FromLua::from_lua($name, lua)?,)* $last,))
+                Ok(($($name,)* $last,))
+            }
+
+            #[allow(unused_mut, non_snake_case)]
+            #[inline]
+            fn from_lua_args(mut args: MultiValue, mut i: usize, to: Option<&str>, lua: &Lua) -> Result<Self> {
+                $(
+                    let $name = FromLua::from_lua_arg(args.pop_front().unwrap_or(Nil), i, to, lua)?;
+                    i += 1;
+                )*
+                let $last = FromLuaMulti::from_lua_args(args, i, to, lua)?;
+                Ok(($($name,)* $last,))
+            }
+
+            #[allow(unused_mut, non_snake_case)]
+            #[inline]
+            unsafe fn from_stack_multi(mut nvals: c_int, lua: &RawLua) -> Result<Self> {
+                $(
+                    let $name = if nvals > 0 {
+                        nvals -= 1;
+                        FromLua::from_stack(-(nvals + 1), lua)
+                    } else {
+                        FromLua::from_lua(Nil, lua.lua())
+                    }?;
+                )*
+                let $last = FromLuaMulti::from_stack_multi(nvals, lua)?;
+                Ok(($($name,)* $last,))
+            }
+
+            #[allow(unused_mut, non_snake_case)]
+            #[inline]
+            unsafe fn from_stack_args(mut nargs: c_int, mut i: usize, to: Option<&str>, lua: &RawLua) -> Result<Self> {
+                $(
+                    let $name = if nargs > 0 {
+                        nargs -= 1;
+                        FromLua::from_stack_arg(-(nargs + 1), i, to, lua)
+                    } else {
+                        FromLua::from_lua_arg(Nil, i, to, lua.lua())
+                    }?;
+                    i += 1;
+                )*
+                let $last = FromLuaMulti::from_stack_args(nargs, i, to, lua)?;
+                Ok(($($name,)* $last,))
            }
        }
    );
@@ -2,17 +2,17 @@

 #[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, FunctionInfo as LuaFunctionInfo, GCMode as LuaGCMode,
-    Integer as LuaInteger, LightUserData as LuaLightUserData, Lua, LuaOptions,
+    AnyUserData as LuaAnyUserData, AnyUserDataExt as LuaAnyUserDataExt, Chunk as LuaChunk, Error as LuaError,
+    ErrorContext as LuaErrorContext, ExternalError as LuaExternalError, ExternalResult as LuaExternalResult,
+    FromLua, FromLuaMulti, Function as LuaFunction, FunctionInfo as LuaFunctionInfo, GCMode as LuaGCMode,
+    Integer as LuaInteger, IntoLua, IntoLuaMulti, LightUserData as LuaLightUserData, Lua, LuaOptions,
    MetaMethod as LuaMetaMethod, MultiValue as LuaMultiValue, Nil as LuaNil, Number as LuaNumber,
    RegistryKey as LuaRegistryKey, 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,
+    TableSequence as LuaTableSequence, Thread as LuaThread, ThreadStatus as LuaThreadStatus,
+    UserData as LuaUserData, UserDataFields as LuaUserDataFields, UserDataMetatable as LuaUserDataMetatable,
+    UserDataMethods as LuaUserDataMethods, UserDataRef as LuaUserDataRef,
+    UserDataRefMut as LuaUserDataRefMut, UserDataRegistry as LuaUserDataRegistry, Value as LuaValue,
 };

 #[cfg(not(feature = "luau"))]
@@ -21,7 +21,7 @@ pub use crate::HookTriggers as LuaHookTriggers;

 #[cfg(feature = "luau")]
 #[doc(no_inline)]
-pub use crate::{CoverageInfo as LuaCoverageInfo, VmState as LuaVmState};
+pub use crate::{CoverageInfo as LuaCoverageInfo, Vector as LuaVector, VmState as LuaVmState};

 #[cfg(feature = "async")]
 #[doc(no_inline)]
@@ -30,6 +30,5 @@ pub use crate::AsyncThread as LuaAsyncThread;
 #[cfg(feature = "serialize")]
 #[doc(no_inline)]
 pub use crate::{
-    DeserializeOptions as LuaDeserializeOptions, LuaSerdeExt,
-    SerializeOptions as LuaSerializeOptions,
+    DeserializeOptions as LuaDeserializeOptions, LuaSerdeExt, SerializeOptions as LuaSerializeOptions,
 };
@@ -1,7 +1,7 @@
 use std::cell::RefCell;
-use std::convert::TryInto;
 use std::os::raw::c_void;
 use std::rc::Rc;
+use std::result::Result as StdResult;
 use std::string::String as StdString;

 use rustc_hash::FxHashSet;
@@ -9,12 +9,13 @@ use serde::de::{self, IntoDeserializer};

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

 /// A struct for deserializing Lua values into Rust values.
 #[derive(Debug)]
-pub struct Deserializer<'lua> {
-    value: Value<'lua>,
+pub struct Deserializer {
+    value: Value,
    options: Options,
    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
 }
@@ -23,14 +24,14 @@ pub struct Deserializer<'lua> {
 #[derive(Debug, Clone, Copy)]
 #[non_exhaustive]
 pub struct Options {
-    /// If true, an attempt to serialize types such as [`Thread`], [`UserData`], [`LightUserData`]
+    /// If true, an attempt to serialize types such as [`Function`], [`Thread`], [`LightUserData`]
    /// and [`Error`] will cause an error.
    /// Otherwise these types skipped when iterating or serialized as unit type.
    ///
    /// Default: **true**
    ///
+    /// [`Function`]: crate::Function
    /// [`Thread`]: crate::Thread
-    /// [`UserData`]: crate::UserData
    /// [`LightUserData`]: crate::LightUserData
    /// [`Error`]: crate::Error
    pub deny_unsupported_types: bool,
@@ -41,6 +42,11 @@ pub struct Options {
    ///
    /// Default: **true**
    pub deny_recursive_tables: bool,
+
+    /// If true, keys in tables will be iterated in sorted order.
+    ///
+    /// Default: **false**
+    pub sort_keys: bool,
 }

 impl Default for Options {
@@ -55,6 +61,7 @@ impl Options {
        Options {
            deny_unsupported_types: true,
            deny_recursive_tables: true,
+            sort_keys: false,
        }
    }

@@ -75,16 +82,25 @@ impl Options {
        self.deny_recursive_tables = enabled;
        self
    }
+
+    /// Sets [`sort_keys`] option.
+    ///
+    /// [`sort_keys`]: #structfield.sort_keys
+    #[must_use]
+    pub const fn sort_keys(mut self, enabled: bool) -> Self {
+        self.sort_keys = enabled;
+        self
+    }
 }

-impl<'lua> Deserializer<'lua> {
+impl Deserializer {
    /// Creates a new Lua Deserializer for the `Value`.
-    pub fn new(value: Value<'lua>) -> Self {
+    pub fn new(value: Value) -> Self {
        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 {
+    pub fn new_with_options(value: Value, options: Options) -> Self {
        Deserializer {
            value,
            options,
@@ -92,11 +108,7 @@ impl<'lua> Deserializer<'lua> {
        }
    }

-    fn from_parts(
-        value: Value<'lua>,
-        options: Options,
-        visited: Rc<RefCell<FxHashSet<*const c_void>>>,
-    ) -> Self {
+    fn from_parts(value: Value, options: Options, visited: Rc<RefCell<FxHashSet<*const c_void>>>) -> Self {
        Deserializer {
            value,
            options,
@@ -105,7 +117,7 @@ impl<'lua> Deserializer<'lua> {
    }
 }

-impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
+impl<'de> serde::Deserializer<'de> for Deserializer {
    type Error = Error;

    #[inline]
@@ -117,30 +129,38 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
            Value::Nil => visitor.visit_unit(),
            Value::Boolean(b) => visitor.visit_bool(b),
            #[allow(clippy::useless_conversion)]
-            Value::Integer(i) => {
-                visitor.visit_i64(i.try_into().expect("cannot convert lua_Integer to i64"))
-            }
+            Value::Integer(i) => visitor.visit_i64(i.into()),
            #[allow(clippy::useless_conversion)]
            Value::Number(n) => visitor.visit_f64(n.into()),
            #[cfg(feature = "luau")]
-            Value::Vector(_, _, _) => self.deserialize_seq(visitor),
+            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()),
+                Ok(s) => visitor.visit_str(&s),
+                Err(_) => visitor.visit_bytes(&s.as_bytes()),
            },
            Value::Table(ref t) if t.raw_len() > 0 || t.is_array() => self.deserialize_seq(visitor),
            Value::Table(_) => self.deserialize_map(visitor),
            Value::LightUserData(ud) if ud.0.is_null() => visitor.visit_none(),
+            Value::UserData(ud) if ud.is_serializable() => {
+                serde_userdata(ud, |value| value.deserialize_any(visitor))
+            }
+            #[cfg(feature = "luau")]
+            Value::UserData(ud) if ud.1 == crate::types::SubtypeId::Buffer => unsafe {
+                let lua = ud.0.lua.lock();
+                let mut size = 0usize;
+                let buf = ffi::lua_tobuffer(lua.ref_thread(), ud.0.index, &mut size);
+                mlua_assert!(!buf.is_null(), "invalid Luau buffer");
+                let buf = std::slice::from_raw_parts(buf as *const u8, size);
+                visitor.visit_bytes(buf)
+            },
            Value::Function(_)
            | Value::Thread(_)
            | Value::UserData(_)
            | Value::LightUserData(_)
            | Value::Error(_) => {
                if self.options.deny_unsupported_types {
-                    Err(de::Error::custom(format!(
-                        "unsupported value type `{}`",
-                        self.value.type_name()
-                    )))
+                    let msg = format!("unsupported value type `{}`", self.value.type_name());
+                    Err(de::Error::custom(msg))
                } else {
                    visitor.visit_unit()
                }
@@ -163,8 +183,8 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
    #[inline]
    fn deserialize_enum<V>(
        self,
-        _name: &str,
-        _variants: &'static [&'static str],
+        name: &'static str,
+        variants: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value>
    where
@@ -191,13 +211,18 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                        &"map with a single key",
                    ));
                }
-                if check_value_if_skip(&value, self.options, &self.visited)? {
+                let skip = check_value_for_skip(&value, self.options, &self.visited)
+                    .map_err(|err| Error::DeserializeError(err.to_string()))?;
+                if skip {
                    return Err(de::Error::custom("bad enum value"));
                }

                (variant, Some(value), Some(_guard))
            }
            Value::String(variant) => (variant.to_str()?.to_owned(), None, None),
+            Value::UserData(ud) if ud.is_serializable() => {
+                return serde_userdata(ud, |value| value.deserialize_enum(name, variants, visitor));
+            }
            _ => return Err(de::Error::custom("bad enum value")),
        };

@@ -216,9 +241,9 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
    {
        match self.value {
            #[cfg(feature = "luau")]
-            Value::Vector(x, y, z) => {
+            Value::Vector(vec) => {
                let mut deserializer = VecDeserializer {
-                    vec: [x, y, z],
+                    vec,
                    next: 0,
                    options: self.options,
                    visited: self.visited,
@@ -228,9 +253,9 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
            Value::Table(t) => {
                let _guard = RecursionGuard::new(&t, &self.visited);

-                let len = t.raw_len() as usize;
+                let len = t.raw_len();
                let mut deserializer = SeqDeserializer {
-                    seq: t.raw_sequence_values(),
+                    seq: t.sequence_values(),
                    options: self.options,
                    visited: self.visited,
                };
@@ -238,12 +263,12 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                if deserializer.seq.count() == 0 {
                    Ok(seq)
                } else {
-                    Err(de::Error::invalid_length(
-                        len,
-                        &"fewer elements in the table",
-                    ))
+                    Err(de::Error::invalid_length(len, &"fewer elements in the table"))
                }
            }
+            Value::UserData(ud) if ud.is_serializable() => {
+                serde_userdata(ud, |value| value.deserialize_seq(visitor))
+            }
            value => Err(de::Error::invalid_type(
                de::Unexpected::Other(value.type_name()),
                &"table",
@@ -260,12 +285,7 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
    }

    #[inline]
-    fn deserialize_tuple_struct<V>(
-        self,
-        _name: &'static str,
-        _len: usize,
-        visitor: V,
-    ) -> Result<V::Value>
+    fn deserialize_tuple_struct<V>(self, _name: &'static str, _len: usize, visitor: V) -> Result<V::Value>
    where
        V: de::Visitor<'de>,
    {
@@ -282,7 +302,7 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                let _guard = RecursionGuard::new(&t, &self.visited);

                let mut deserializer = MapDeserializer {
-                    pairs: t.pairs(),
+                    pairs: MapPairs::new(&t, self.options.sort_keys)?,
                    value: None,
                    options: self.options,
                    visited: self.visited,
@@ -299,6 +319,9 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
                    ))
                }
            }
+            Value::UserData(ud) if ud.is_serializable() => {
+                serde_userdata(ud, |value| value.deserialize_map(visitor))
+            }
            value => Err(de::Error::invalid_type(
                de::Unexpected::Other(value.type_name()),
                &"table",
@@ -320,11 +343,16 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
    }

    #[inline]
-    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
+    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
    where
        V: de::Visitor<'de>,
    {
-        visitor.visit_newtype_struct(self)
+        match self.value {
+            Value::UserData(ud) if ud.is_serializable() => {
+                serde_userdata(ud, |value| value.deserialize_newtype_struct(name, visitor))
+            }
+            _ => visitor.visit_newtype_struct(self),
+        }
    }

    #[inline]
@@ -355,13 +383,13 @@ impl<'lua, 'de> serde::Deserializer<'de> for Deserializer<'lua> {
    }
 }

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

-impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {
+impl<'de> de::SeqAccess<'de> for SeqDeserializer<'_> {
    type Error = Error;

    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
@@ -372,7 +400,9 @@ impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {
            match self.seq.next() {
                Some(value) => {
                    let value = value?;
-                    if check_value_if_skip(&value, self.options, &self.visited)? {
+                    let skip = check_value_for_skip(&value, self.options, &self.visited)
+                        .map_err(|err| Error::DeserializeError(err.to_string()))?;
+                    if skip {
                        continue;
                    }
                    let visited = Rc::clone(&self.visited);
@@ -394,7 +424,7 @@ impl<'lua, 'de> de::SeqAccess<'de> for SeqDeserializer<'lua> {

 #[cfg(feature = "luau")]
 struct VecDeserializer {
-    vec: [f32; 3],
+    vec: crate::types::Vector,
    next: usize,
    options: Options,
    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
@@ -408,12 +438,11 @@ impl<'de> de::SeqAccess<'de> for VecDeserializer {
    where
        T: de::DeserializeSeed<'de>,
    {
-        match self.vec.get(self.next) {
+        match self.vec.0.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);
+                let deserializer = Deserializer::from_parts(Value::Number(n as _), self.options, visited);
                seed.deserialize(deserializer).map(Some)
            }
            None => Ok(None),
@@ -421,19 +450,61 @@ impl<'de> de::SeqAccess<'de> for VecDeserializer {
    }

    fn size_hint(&self) -> Option<usize> {
-        Some(3)
+        Some(crate::types::Vector::SIZE)
    }
 }

-struct MapDeserializer<'lua> {
-    pairs: TablePairs<'lua, Value<'lua>, Value<'lua>>,
-    value: Option<Value<'lua>>,
+pub(crate) enum MapPairs<'a> {
+    Iter(TablePairs<'a, Value, Value>),
+    Vec(Vec<(Value, Value)>),
+}
+
+impl<'a> MapPairs<'a> {
+    pub(crate) fn new(t: &'a Table, sort_keys: bool) -> Result<Self> {
+        if sort_keys {
+            let mut pairs = t.pairs::<Value, Value>().collect::<Result<Vec<_>>>()?;
+            pairs.sort_by(|(a, _), (b, _)| b.cmp(a)); // reverse order as we pop values from the end
+            Ok(MapPairs::Vec(pairs))
+        } else {
+            Ok(MapPairs::Iter(t.pairs::<Value, Value>()))
+        }
+    }
+
+    pub(crate) fn count(self) -> usize {
+        match self {
+            MapPairs::Iter(iter) => iter.count(),
+            MapPairs::Vec(vec) => vec.len(),
+        }
+    }
+
+    pub(crate) fn size_hint(&self) -> (usize, Option<usize>) {
+        match self {
+            MapPairs::Iter(iter) => iter.size_hint(),
+            MapPairs::Vec(vec) => (vec.len(), Some(vec.len())),
+        }
+    }
+}
+
+impl Iterator for MapPairs<'_> {
+    type Item = Result<(Value, Value)>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            MapPairs::Iter(iter) => iter.next(),
+            MapPairs::Vec(vec) => vec.pop().map(Ok),
+        }
+    }
+}
+
+struct MapDeserializer<'a> {
+    pairs: MapPairs<'a>,
+    value: Option<Value>,
    options: Options,
    visited: Rc<RefCell<FxHashSet<*const c_void>>>,
    processed: usize,
 }

-impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
+impl<'de> de::MapAccess<'de> for MapDeserializer<'_> {
    type Error = Error;

    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
@@ -444,9 +515,11 @@ impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
            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)?
-                    {
+                    let skip_key = check_value_for_skip(&key, self.options, &self.visited)
+                        .map_err(|err| Error::DeserializeError(err.to_string()))?;
+                    let skip_value = check_value_for_skip(&value, self.options, &self.visited)
+                        .map_err(|err| Error::DeserializeError(err.to_string()))?;
+                    if skip_key || skip_value {
                        continue;
                    }
                    self.processed += 1;
@@ -481,16 +554,16 @@ impl<'lua, 'de> de::MapAccess<'de> for MapDeserializer<'lua> {
    }
 }

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

-impl<'lua, 'de> de::EnumAccess<'de> for EnumDeserializer<'lua> {
+impl<'de> de::EnumAccess<'de> for EnumDeserializer {
    type Error = Error;
-    type Variant = VariantDeserializer<'lua>;
+    type Variant = VariantDeserializer;

    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant)>
    where
@@ -506,13 +579,13 @@ impl<'lua, 'de> de::EnumAccess<'de> for EnumDeserializer<'lua> {
    }
 }

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

-impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
+impl<'de> de::VariantAccess<'de> for VariantDeserializer {
    type Error = Error;

    fn unit_variant(self) -> Result<()> {
@@ -530,9 +603,7 @@ impl<'lua, 'de> de::VariantAccess<'de> for VariantDeserializer<'lua> {
        T: de::DeserializeSeed<'de>,
    {
        match self.value {
-            Some(value) => {
-                seed.deserialize(Deserializer::from_parts(value, self.options, self.visited))
-            }
+            Some(value) => seed.deserialize(Deserializer::from_parts(value, self.options, self.visited)),
            None => Err(de::Error::invalid_type(
                de::Unexpected::UnitVariant,
                &"newtype variant",
@@ -575,14 +646,14 @@ 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 {
+pub(crate) 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 {
+    pub(crate) fn new(table: &Table, visited: &Rc<RefCell<FxHashSet<*const c_void>>>) -> Self {
        let visited = Rc::clone(visited);
        let ptr = table.to_pointer();
        visited.borrow_mut().insert(ptr);
@@ -597,21 +668,22 @@ impl Drop for RecursionGuard {
 }

 // Checks `options` and decides should we emit an error or skip next element
-fn check_value_if_skip(
+pub(crate) fn check_value_for_skip(
    value: &Value,
    options: Options,
    visited: &RefCell<FxHashSet<*const c_void>>,
-) -> Result<bool> {
+) -> StdResult<bool, &'static str> {
    match value {
        Value::Table(table) => {
            let ptr = table.to_pointer();
            if visited.borrow().contains(&ptr) {
                if options.deny_recursive_tables {
-                    return Err(de::Error::custom("recursive table detected"));
+                    return Err("recursive table detected");
                }
                return Ok(true); // skip
            }
        }
+        Value::UserData(ud) if ud.is_serializable() => {}
        Value::Function(_)
        | Value::Thread(_)
        | Value::UserData(_)
@@ -625,3 +697,11 @@ fn check_value_if_skip(
    }
    Ok(false) // do not skip
 }
+
+fn serde_userdata<V>(
+    ud: AnyUserData,
+    f: impl FnOnce(serde_value::Value) -> std::result::Result<V, serde_value::DeserializerError>,
+) -> Result<V> {
+    let value = serde_value::to_value(ud).map_err(|err| Error::SerializeError(err.to_string()))?;
+    f(value).map_err(|err| Error::DeserializeError(err.to_string()))
+}
@@ -1,21 +1,20 @@
 //! (De)Serialization support using serde.

 use std::os::raw::c_void;
-use std::ptr;

-use serde::{Deserialize, Serialize};
+use serde::de::DeserializeOwned;
+use serde::ser::Serialize;

 use crate::error::Result;
-use crate::ffi;
-use crate::lua::Lua;
+use crate::private::Sealed;
+use crate::state::Lua;
 use crate::table::Table;
-use crate::types::LightUserData;
 use crate::util::check_stack;
 use crate::value::Value;

 /// Trait for serializing/deserializing Lua values using Serde.
 #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
-pub trait LuaSerdeExt<'lua> {
+pub trait LuaSerdeExt: Sealed {
    /// A special value (lightuserdata) to encode/decode optional (none) values.
    ///
    /// Requires `feature = "serialize"`
@@ -37,7 +36,7 @@ pub trait LuaSerdeExt<'lua> {
    ///     Ok(())
    /// }
    /// ```
-    fn null(&'lua self) -> Value<'lua>;
+    fn null(&self) -> Value;

    /// A metatable attachable to a Lua table to systematically encode it as Array (instead of Map).
    /// As result, encoded Array will contain only sequence part of the table, with the same length
@@ -68,7 +67,7 @@ pub trait LuaSerdeExt<'lua> {
    ///     Ok(())
    /// }
    /// ```
-    fn array_metatable(&'lua self) -> Table<'lua>;
+    fn array_metatable(&self) -> Table;

    /// Converts `T` into a [`Value`] instance.
    ///
@@ -101,7 +100,7 @@ pub trait LuaSerdeExt<'lua> {
    ///     "#).exec()
    /// }
    /// ```
-    fn to_value<T: Serialize + ?Sized>(&'lua self, t: &T) -> Result<Value<'lua>>;
+    fn to_value<T: Serialize + ?Sized>(&self, t: &T) -> Result<Value>;

    /// Converts `T` into a [`Value`] instance with options.
    ///
@@ -126,7 +125,7 @@ pub trait LuaSerdeExt<'lua> {
    ///     "#).exec()
    /// }
    /// ```
-    fn to_value_with<T>(&'lua self, t: &T, options: ser::Options) -> Result<Value<'lua>>
+    fn to_value_with<T>(&self, t: &T, options: ser::Options) -> Result<Value>
    where
        T: Serialize + ?Sized;

@@ -159,7 +158,7 @@ pub trait LuaSerdeExt<'lua> {
    /// }
    /// ```
    #[allow(clippy::wrong_self_convention)]
-    fn from_value<T: Deserialize<'lua>>(&'lua self, value: Value<'lua>) -> Result<T>;
+    fn from_value<T: DeserializeOwned>(&self, value: Value) -> Result<T>;

    /// Deserializes a [`Value`] into any serde deserializable object with options.
    ///
@@ -191,49 +190,46 @@ pub trait LuaSerdeExt<'lua> {
    /// }
    /// ```
    #[allow(clippy::wrong_self_convention)]
-    fn from_value_with<T: Deserialize<'lua>>(
-        &'lua self,
-        value: Value<'lua>,
-        options: de::Options,
-    ) -> Result<T>;
+    fn from_value_with<T: DeserializeOwned>(&self, value: Value, options: de::Options) -> Result<T>;
 }

-impl<'lua> LuaSerdeExt<'lua> for Lua {
-    fn null(&'lua self) -> Value<'lua> {
-        Value::LightUserData(LightUserData(ptr::null_mut()))
+impl LuaSerdeExt for Lua {
+    fn null(&self) -> Value {
+        Value::NULL
    }

-    fn array_metatable(&'lua self) -> Table<'lua> {
+    fn array_metatable(&self) -> Table {
+        let lua = self.lock();
        unsafe {
-            push_array_metatable(self.ref_thread());
-            Table(self.pop_ref_thread())
+            push_array_metatable(lua.ref_thread());
+            Table(lua.pop_ref_thread())
        }
    }

-    fn to_value<T>(&'lua self, t: &T) -> Result<Value<'lua>>
+    fn to_value<T>(&self, t: &T) -> Result<Value>
    where
        T: Serialize + ?Sized,
    {
        t.serialize(ser::Serializer::new(self))
    }

-    fn to_value_with<T>(&'lua self, t: &T, options: ser::Options) -> Result<Value<'lua>>
+    fn to_value_with<T>(&self, t: &T, options: ser::Options) -> Result<Value>
    where
        T: Serialize + ?Sized,
    {
        t.serialize(ser::Serializer::new_with_options(self, options))
    }

-    fn from_value<T>(&'lua self, value: Value<'lua>) -> Result<T>
+    fn from_value<T>(&self, value: Value) -> Result<T>
    where
-        T: Deserialize<'lua>,
+        T: DeserializeOwned,
    {
        T::deserialize(de::Deserializer::new(value))
    }

-    fn from_value_with<T>(&'lua self, value: Value<'lua>, options: de::Options) -> Result<T>
+    fn from_value_with<T>(&self, value: Value, options: de::Options) -> Result<T>
    where
-        T: Deserialize<'lua>,
+        T: DeserializeOwned,
    {
        T::deserialize(de::Deserializer::new_with_options(value, options))
    }
@@ -1,21 +1,15 @@
-use std::os::raw::c_int;
-
 use serde::{ser, Serialize};

 use super::LuaSerdeExt;
 use crate::error::{Error, Result};
-use crate::ffi;
-use crate::lua::Lua;
-use crate::string::String;
+use crate::state::Lua;
 use crate::table::Table;
-use crate::types::Integer;
-use crate::util::{check_stack, StackGuard};
-use crate::value::{ToLua, Value};
+use crate::value::{IntoLua, Value};

 /// A struct for serializing Rust values into Lua values.
 #[derive(Debug)]
-pub struct Serializer<'lua> {
-    lua: &'lua Lua,
+pub struct Serializer<'a> {
+    lua: &'a Lua,
    options: Options,
 }

@@ -48,6 +42,12 @@ pub struct Options {
    /// [`null`]: crate::LuaSerdeExt::null
    /// [`Nil`]: crate::Value::Nil
    pub serialize_unit_to_null: bool,
+
+    /// If true, serialize `serde_json::Number` with arbitrary_precision to a Lua number.
+    /// Otherwise it will be serialized as an object (what serde does).
+    ///
+    /// Default: **false**
+    pub detect_serde_json_arbitrary_precision: bool,
 }

 impl Default for Options {
@@ -63,6 +63,7 @@ impl Options {
            set_array_metatable: true,
            serialize_none_to_null: true,
            serialize_unit_to_null: true,
+            detect_serde_json_arbitrary_precision: false,
        }
    }

@@ -92,16 +93,30 @@ impl Options {
        self.serialize_unit_to_null = enabled;
        self
    }
+
+    /// Sets [`detect_serde_json_arbitrary_precision`] option.
+    ///
+    /// This option is used to serialize `serde_json::Number` with arbitrary precision to a Lua
+    /// number. Otherwise it will be serialized as an object (what serde does).
+    ///
+    /// This option is disabled by default.
+    ///
+    /// [`detect_serde_json_arbitrary_precision`]: #structfield.detect_serde_json_arbitrary_precision
+    #[must_use]
+    pub const fn detect_serde_json_arbitrary_precision(mut self, enabled: bool) -> Self {
+        self.detect_serde_json_arbitrary_precision = enabled;
+        self
+    }
 }

-impl<'lua> Serializer<'lua> {
+impl<'a> Serializer<'a> {
    /// Creates a new Lua Serializer with default options.
-    pub fn new(lua: &'lua Lua) -> Self {
+    pub fn new(lua: &'a Lua) -> Self {
        Self::new_with_options(lua, Options::default())
    }

    /// Creates a new Lua Serializer with custom options.
-    pub fn new_with_options(lua: &'lua Lua, options: Options) -> Self {
+    pub fn new_with_options(lua: &'a Lua, options: Options) -> Self {
        Serializer { lua, options }
    }
 }
@@ -109,28 +124,28 @@ impl<'lua> Serializer<'lua> {
 macro_rules! lua_serialize_number {
    ($name:ident, $t:ty) => {
        #[inline]
-        fn $name(self, value: $t) -> Result<Value<'lua>> {
-            value.to_lua(self.lua)
+        fn $name(self, value: $t) -> Result<Value> {
+            value.into_lua(self.lua)
        }
    };
 }

-impl<'lua> ser::Serializer for Serializer<'lua> {
-    type Ok = Value<'lua>;
+impl<'a> ser::Serializer for Serializer<'a> {
+    type Ok = Value;
    type Error = Error;

    // Associated types for keeping track of additional state while serializing
    // compound data structures like sequences and maps.
-    type SerializeSeq = SerializeVec<'lua>;
-    type SerializeTuple = SerializeVec<'lua>;
-    type SerializeTupleStruct = SerializeVec<'lua>;
-    type SerializeTupleVariant = SerializeTupleVariant<'lua>;
-    type SerializeMap = SerializeMap<'lua>;
-    type SerializeStruct = SerializeMap<'lua>;
-    type SerializeStructVariant = SerializeStructVariant<'lua>;
+    type SerializeSeq = SerializeSeq<'a>;
+    type SerializeTuple = SerializeSeq<'a>;
+    type SerializeTupleStruct = SerializeSeq<'a>;
+    type SerializeTupleVariant = SerializeTupleVariant<'a>;
+    type SerializeMap = SerializeMap<'a>;
+    type SerializeStruct = SerializeStruct<'a>;
+    type SerializeStructVariant = SerializeStructVariant<'a>;

    #[inline]
-    fn serialize_bool(self, value: bool) -> Result<Value<'lua>> {
+    fn serialize_bool(self, value: bool) -> Result<Value> {
        Ok(Value::Boolean(value))
    }

@@ -149,22 +164,22 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
    lua_serialize_number!(serialize_f64, f64);

    #[inline]
-    fn serialize_char(self, value: char) -> Result<Value<'lua>> {
+    fn serialize_char(self, value: char) -> Result<Value> {
        self.serialize_str(&value.to_string())
    }

    #[inline]
-    fn serialize_str(self, value: &str) -> Result<Value<'lua>> {
+    fn serialize_str(self, value: &str) -> Result<Value> {
        self.lua.create_string(value).map(Value::String)
    }

    #[inline]
-    fn serialize_bytes(self, value: &[u8]) -> Result<Value<'lua>> {
+    fn serialize_bytes(self, value: &[u8]) -> Result<Value> {
        self.lua.create_string(value).map(Value::String)
    }

    #[inline]
-    fn serialize_none(self) -> Result<Value<'lua>> {
+    fn serialize_none(self) -> Result<Value> {
        if self.options.serialize_none_to_null {
            Ok(self.lua.null())
        } else {
@@ -173,7 +188,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
    }

    #[inline]
-    fn serialize_some<T>(self, value: &T) -> Result<Value<'lua>>
+    fn serialize_some<T>(self, value: &T) -> Result<Value>
    where
        T: Serialize + ?Sized,
    {
@@ -181,7 +196,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
    }

    #[inline]
-    fn serialize_unit(self) -> Result<Value<'lua>> {
+    fn serialize_unit(self) -> Result<Value> {
        if self.options.serialize_unit_to_null {
            Ok(self.lua.null())
        } else {
@@ -190,7 +205,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
    }

    #[inline]
-    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value<'lua>> {
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value> {
        if self.options.serialize_unit_to_null {
            Ok(self.lua.null())
        } else {
@@ -204,12 +219,12 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
-    ) -> Result<Value<'lua>> {
+    ) -> Result<Value> {
        self.serialize_str(variant)
    }

    #[inline]
-    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value<'lua>>
+    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<Value>
    where
        T: Serialize + ?Sized,
    {
@@ -223,7 +238,7 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
        _variant_index: u32,
        variant: &'static str,
        value: &T,
-    ) -> Result<Value<'lua>>
+    ) -> Result<Value>
    where
        T: Serialize + ?Sized,
    {
@@ -236,13 +251,11 @@ impl<'lua> ser::Serializer for Serializer<'lua> {

    #[inline]
    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
-        let len = len.unwrap_or(0) as c_int;
-        let table = self.lua.create_table_with_capacity(len, 0)?;
+        let table = self.lua.create_table_with_capacity(len.unwrap_or(0), 0)?;
        if self.options.set_array_metatable {
            table.set_metatable(Some(self.lua.array_metatable()));
        }
-        let options = self.options;
-        Ok(SerializeVec { table, options })
+        Ok(SerializeSeq::new(self.lua, table, self.options))
    }

    #[inline]
@@ -251,11 +264,12 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
    }

    #[inline]
-    fn serialize_tuple_struct(
-        self,
-        _name: &'static str,
-        len: usize,
-    ) -> Result<Self::SerializeTupleStruct> {
+    fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct> {
+        #[cfg(feature = "luau")]
+        if name == "Vector" && len == crate::types::Vector::SIZE {
+            return Ok(SerializeSeq::new_vector(self.lua, self.options));
+        }
+        _ = name;
        self.serialize_seq(Some(len))
    }

@@ -268,7 +282,8 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant> {
        Ok(SerializeTupleVariant {
-            name: self.lua.create_string(variant)?,
+            lua: self.lua,
+            variant,
            table: self.lua.create_table()?,
            options: self.options,
        })
@@ -276,17 +291,32 @@ impl<'lua> ser::Serializer for Serializer<'lua> {

    #[inline]
    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
-        let len = len.unwrap_or(0) as c_int;
        Ok(SerializeMap {
+            lua: self.lua,
            key: None,
-            table: self.lua.create_table_with_capacity(0, len)?,
+            table: self.lua.create_table_with_capacity(0, len.unwrap_or(0))?,
            options: self.options,
        })
    }

    #[inline]
-    fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
-        self.serialize_map(Some(len))
+    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
+        if self.options.detect_serde_json_arbitrary_precision
+            && name == "$serde_json::private::Number"
+            && len == 1
+        {
+            return Ok(SerializeStruct {
+                lua: self.lua,
+                inner: None,
+                options: self.options,
+            });
+        }
+
+        Ok(SerializeStruct {
+            lua: self.lua,
+            inner: Some(Value::Table(self.lua.create_table_with_capacity(0, len)?)),
+            options: self.options,
+        })
    }

    #[inline]
@@ -298,56 +328,70 @@ impl<'lua> ser::Serializer for Serializer<'lua> {
        len: usize,
    ) -> Result<Self::SerializeStructVariant> {
        Ok(SerializeStructVariant {
-            name: self.lua.create_string(variant)?,
-            table: self.lua.create_table_with_capacity(0, len as c_int)?,
+            lua: self.lua,
+            variant,
+            table: self.lua.create_table_with_capacity(0, len)?,
            options: self.options,
        })
    }
 }

 #[doc(hidden)]
-pub struct SerializeVec<'lua> {
-    table: Table<'lua>,
+pub struct SerializeSeq<'a> {
+    lua: &'a Lua,
+    #[cfg(feature = "luau")]
+    vector: Option<crate::types::Vector>,
+    table: Option<Table>,
+    next: usize,
    options: Options,
 }

-impl<'lua> ser::SerializeSeq for SerializeVec<'lua> {
-    type Ok = Value<'lua>;
+impl<'a> SerializeSeq<'a> {
+    fn new(lua: &'a Lua, table: Table, options: Options) -> Self {
+        Self {
+            lua,
+            #[cfg(feature = "luau")]
+            vector: None,
+            table: Some(table),
+            next: 0,
+            options,
+        }
+    }
+
+    #[cfg(feature = "luau")]
+    const fn new_vector(lua: &'a Lua, options: Options) -> Self {
+        Self {
+            lua,
+            vector: Some(crate::types::Vector::zero()),
+            table: None,
+            next: 0,
+            options,
+        }
+    }
+}
+
+impl ser::SerializeSeq for SerializeSeq<'_> {
+    type Ok = Value;
    type Error = Error;

    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
    where
        T: Serialize + ?Sized,
    {
-        let lua = self.table.0.lua;
-        let value = lua.to_value_with(value, self.options)?;
-        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 4)?;
-
-            lua.push_ref(&self.table.0);
-            lua.push_value(value)?;
-            if lua.unlikely_memory_error() {
-                let len = ffi::lua_rawlen(lua.state, -2) as Integer;
-                ffi::lua_rawseti(lua.state, -2, len + 1);
-                ffi::lua_pop(lua.state, 1);
-                Ok(())
-            } else {
-                protect_lua!(lua.state, 2, 0, fn(state) {
-                    let len = ffi::lua_rawlen(state, -2) as Integer;
-                    ffi::lua_rawseti(state, -2, len + 1);
-                })
-            }
-        }
+        let value = self.lua.to_value_with(value, self.options)?;
+        let table = self.table.as_ref().unwrap();
+        table.raw_seti(self.next + 1, value)?;
+        self.next += 1;
+        Ok(())
    }

-    fn end(self) -> Result<Value<'lua>> {
-        Ok(Value::Table(self.table))
+    fn end(self) -> Result<Value> {
+        Ok(Value::Table(self.table.unwrap()))
    }
 }

-impl<'lua> ser::SerializeTuple for SerializeVec<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeTuple for SerializeSeq<'_> {
+    type Ok = Value;
    type Error = Error;

    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
@@ -357,73 +401,82 @@ impl<'lua> ser::SerializeTuple for SerializeVec<'lua> {
        ser::SerializeSeq::serialize_element(self, value)
    }

-    fn end(self) -> Result<Value<'lua>> {
+    fn end(self) -> Result<Value> {
        ser::SerializeSeq::end(self)
    }
 }

-impl<'lua> ser::SerializeTupleStruct for SerializeVec<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeTupleStruct for SerializeSeq<'_> {
+    type Ok = Value;
    type Error = Error;

    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
    where
        T: Serialize + ?Sized,
    {
+        #[cfg(feature = "luau")]
+        if let Some(vector) = self.vector.as_mut() {
+            let value = self.lua.to_value_with(value, self.options)?;
+            let value = self.lua.unpack(value)?;
+            vector.0[self.next] = value;
+            self.next += 1;
+            return Ok(());
+        }
        ser::SerializeSeq::serialize_element(self, value)
    }

-    fn end(self) -> Result<Value<'lua>> {
+    fn end(self) -> Result<Value> {
+        #[cfg(feature = "luau")]
+        if let Some(vector) = self.vector {
+            return Ok(Value::Vector(vector));
+        }
        ser::SerializeSeq::end(self)
    }
 }

 #[doc(hidden)]
-pub struct SerializeTupleVariant<'lua> {
-    name: String<'lua>,
-    table: Table<'lua>,
+pub struct SerializeTupleVariant<'a> {
+    lua: &'a Lua,
+    variant: &'static str,
+    table: Table,
    options: Options,
 }

-impl<'lua> ser::SerializeTupleVariant for SerializeTupleVariant<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeTupleVariant for SerializeTupleVariant<'_> {
+    type Ok = Value;
    type Error = Error;

    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
    where
        T: Serialize + ?Sized,
    {
-        let lua = self.table.0.lua;
-        let idx = self.table.raw_len() + 1;
-        self.table
-            .raw_insert(idx, lua.to_value_with(value, self.options)?)
+        self.table.raw_push(self.lua.to_value_with(value, self.options)?)
    }

-    fn end(self) -> Result<Value<'lua>> {
-        let lua = self.table.0.lua;
-        let table = lua.create_table()?;
-        table.raw_set(self.name, self.table)?;
+    fn end(self) -> Result<Value> {
+        let table = self.lua.create_table()?;
+        table.raw_set(self.variant, self.table)?;
        Ok(Value::Table(table))
    }
 }

 #[doc(hidden)]
-pub struct SerializeMap<'lua> {
-    table: Table<'lua>,
-    key: Option<Value<'lua>>,
+pub struct SerializeMap<'a> {
+    lua: &'a Lua,
+    table: Table,
+    key: Option<Value>,
    options: Options,
 }

-impl<'lua> ser::SerializeMap for SerializeMap<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeMap for SerializeMap<'_> {
+    type Ok = Value;
    type Error = Error;

    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
    where
        T: Serialize + ?Sized,
    {
-        let lua = self.table.0.lua;
-        self.key = Some(lua.to_value_with(key, self.options)?);
+        self.key = Some(self.lua.to_value_with(key, self.options)?);
        Ok(())
    }

@@ -431,62 +484,90 @@ impl<'lua> ser::SerializeMap for SerializeMap<'lua> {
    where
        T: Serialize + ?Sized,
    {
-        let lua = self.table.0.lua;
-        let key = mlua_expect!(
-            self.key.take(),
-            "serialize_value called before serialize_key"
-        );
-        let value = lua.to_value_with(value, self.options)?;
+        let key = mlua_expect!(self.key.take(), "serialize_value called before serialize_key");
+        let value = self.lua.to_value_with(value, self.options)?;
        self.table.raw_set(key, value)
    }

-    fn end(self) -> Result<Value<'lua>> {
+    fn end(self) -> Result<Value> {
        Ok(Value::Table(self.table))
    }
 }

-impl<'lua> ser::SerializeStruct for SerializeMap<'lua> {
-    type Ok = Value<'lua>;
+#[doc(hidden)]
+pub struct SerializeStruct<'a> {
+    lua: &'a Lua,
+    inner: Option<Value>,
+    options: Options,
+}
+
+impl ser::SerializeStruct for SerializeStruct<'_> {
+    type Ok = Value;
    type Error = Error;

    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
    where
        T: Serialize + ?Sized,
    {
-        ser::SerializeMap::serialize_key(self, key)?;
-        ser::SerializeMap::serialize_value(self, value)
+        match self.inner {
+            Some(Value::Table(ref table)) => {
+                table.raw_set(key, self.lua.to_value_with(value, self.options)?)?;
+            }
+            None if self.options.detect_serde_json_arbitrary_precision => {
+                // A special case for `serde_json::Number` with arbitrary precision.
+                assert_eq!(key, "$serde_json::private::Number");
+                self.inner = Some(self.lua.to_value_with(value, self.options)?);
+            }
+            _ => unreachable!(),
+        }
+        Ok(())
    }

-    fn end(self) -> Result<Value<'lua>> {
-        ser::SerializeMap::end(self)
+    fn end(self) -> Result<Value> {
+        match self.inner {
+            Some(table @ Value::Table(_)) => Ok(table),
+            Some(value) if self.options.detect_serde_json_arbitrary_precision => {
+                let number_s = value.as_str().expect("not an arbitrary precision number");
+                if number_s.contains(['.', 'e', 'E']) {
+                    if let Ok(number) = number_s.parse().map(Value::Number) {
+                        return Ok(number);
+                    }
+                }
+                Ok(number_s
+                    .parse()
+                    .map(Value::Integer)
+                    .or_else(|_| number_s.parse().map(Value::Number))
+                    .unwrap_or(value))
+            }
+            _ => unreachable!(),
+        }
    }
 }

 #[doc(hidden)]
-pub struct SerializeStructVariant<'lua> {
-    name: String<'lua>,
-    table: Table<'lua>,
+pub struct SerializeStructVariant<'a> {
+    lua: &'a Lua,
+    variant: &'static str,
+    table: Table,
    options: Options,
 }

-impl<'lua> ser::SerializeStructVariant for SerializeStructVariant<'lua> {
-    type Ok = Value<'lua>;
+impl ser::SerializeStructVariant for SerializeStructVariant<'_> {
+    type Ok = Value;
    type Error = Error;

    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
    where
        T: Serialize + ?Sized,
    {
-        let lua = self.table.0.lua;
        self.table
-            .raw_set(key, lua.to_value_with(value, self.options)?)?;
+            .raw_set(key, self.lua.to_value_with(value, self.options)?)?;
        Ok(())
    }

-    fn end(self) -> Result<Value<'lua>> {
-        let lua = self.table.0.lua;
-        let table = lua.create_table()?;
-        table.raw_set(self.name, self.table)?;
+    fn end(self) -> Result<Value> {
+        let table = self.lua.create_table_with_capacity(0, 1)?;
+        table.raw_set(self.variant, self.table)?;
        Ok(Value::Table(table))
    }
 }
@@ -0,0 +1,247 @@
+use std::any::TypeId;
+use std::cell::UnsafeCell;
+use std::rc::Rc;
+// use std::collections::VecDeque;
+use std::mem::{self, MaybeUninit};
+use std::os::raw::{c_int, c_void};
+use std::ptr;
+use std::sync::Arc;
+
+use parking_lot::Mutex;
+use rustc_hash::FxHashMap;
+
+use crate::error::Result;
+use crate::state::RawLua;
+use crate::stdlib::StdLib;
+use crate::types::{AppData, ReentrantMutex, XRc, XWeak};
+use crate::util::{get_internal_metatable, push_internal_userdata, TypeKey, WrappedFailure};
+
+#[cfg(any(feature = "luau", doc))]
+use crate::chunk::Compiler;
+
+#[cfg(feature = "async")]
+use {futures_util::task::noop_waker_ref, std::ptr::NonNull, std::task::Waker};
+
+use super::{Lua, WeakLua};
+
+// Unique key to store `ExtraData` in the registry
+static EXTRA_REGISTRY_KEY: u8 = 0;
+
+const WRAPPED_FAILURE_POOL_SIZE: usize = 64;
+// const MULTIVALUE_POOL_SIZE: usize = 64;
+const REF_STACK_RESERVE: c_int = 1;
+
+/// Data associated with the Lua state.
+pub(crate) struct ExtraData {
+    // Same layout as `Lua`
+    pub(super) lua: MaybeUninit<XRc<ReentrantMutex<RawLua>>>,
+    // Same layout as `WeakLua`
+    pub(super) weak: MaybeUninit<XWeak<ReentrantMutex<RawLua>>>,
+
+    pub(super) registered_userdata: FxHashMap<TypeId, c_int>,
+    pub(super) registered_userdata_mt: FxHashMap<*const c_void, Option<TypeId>>,
+    pub(super) last_checked_userdata_mt: (*const c_void, Option<TypeId>),
+
+    // When Lua instance dropped, setting `None` would prevent collecting `RegistryKey`s
+    pub(super) registry_unref_list: Arc<Mutex<Option<Vec<c_int>>>>,
+
+    // Container to store arbitrary data (extensions)
+    pub(super) app_data: AppData,
+
+    pub(super) safe: bool,
+    pub(super) libs: StdLib,
+    #[cfg(feature = "module")]
+    pub(super) skip_memory_check: bool,
+
+    // Auxiliary thread to store references
+    pub(super) ref_thread: *mut ffi::lua_State,
+    pub(super) ref_stack_size: c_int,
+    pub(super) ref_stack_top: c_int,
+    pub(super) ref_free: Vec<c_int>,
+
+    // Pool of `WrappedFailure` enums in the ref thread (as userdata)
+    pub(super) wrapped_failure_pool: Vec<c_int>,
+    // Pool of `MultiValue` containers
+    // multivalue_pool: Vec<VecDeque<Value>>,
+    // Pool of `Thread`s (coroutines) for async execution
+    #[cfg(feature = "async")]
+    pub(super) thread_pool: Vec<c_int>,
+
+    // Address of `WrappedFailure` metatable
+    pub(super) wrapped_failure_mt_ptr: *const c_void,
+
+    // Waker for polling futures
+    #[cfg(feature = "async")]
+    pub(super) waker: NonNull<Waker>,
+
+    #[cfg(not(feature = "luau"))]
+    pub(super) hook_callback: Option<crate::types::HookCallback>,
+    #[cfg(not(feature = "luau"))]
+    pub(super) hook_thread: *mut ffi::lua_State,
+    #[cfg(feature = "lua54")]
+    pub(super) warn_callback: Option<crate::types::WarnCallback>,
+    #[cfg(feature = "luau")]
+    pub(super) interrupt_callback: Option<crate::types::InterruptCallback>,
+
+    #[cfg(feature = "luau")]
+    pub(super) sandboxed: bool,
+    #[cfg(feature = "luau")]
+    pub(super) compiler: Option<Compiler>,
+    #[cfg(feature = "luau-jit")]
+    pub(super) enable_jit: bool,
+}
+
+impl Drop for ExtraData {
+    fn drop(&mut self) {
+        unsafe {
+            #[cfg(feature = "module")]
+            self.lua.assume_init_drop();
+
+            self.weak.assume_init_drop();
+        }
+        *self.registry_unref_list.lock() = None;
+    }
+}
+
+static EXTRA_TYPE_KEY: u8 = 0;
+
+impl TypeKey for XRc<UnsafeCell<ExtraData>> {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &EXTRA_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+impl ExtraData {
+    // Index of `error_traceback` function in auxiliary thread stack
+    #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+    pub(super) const ERROR_TRACEBACK_IDX: c_int = 1;
+
+    pub(super) unsafe fn init(state: *mut ffi::lua_State) -> XRc<UnsafeCell<Self>> {
+        // Create ref stack thread and place it in the registry to prevent it
+        // from being garbage collected.
+        let ref_thread = mlua_expect!(
+            protect_lua!(state, 0, 0, |state| {
+                let thread = ffi::lua_newthread(state);
+                ffi::luaL_ref(state, ffi::LUA_REGISTRYINDEX);
+                thread
+            }),
+            "Error while creating ref thread",
+        );
+
+        let wrapped_failure_mt_ptr = {
+            get_internal_metatable::<WrappedFailure>(state);
+            let ptr = ffi::lua_topointer(state, -1);
+            ffi::lua_pop(state, 1);
+            ptr
+        };
+
+        // Store `error_traceback` function on the ref stack
+        #[cfg(any(feature = "lua51", feature = "luajit", feature = "luau"))]
+        {
+            ffi::lua_pushcfunction(ref_thread, crate::util::error_traceback);
+            assert_eq!(ffi::lua_gettop(ref_thread), Self::ERROR_TRACEBACK_IDX);
+        }
+
+        let extra = XRc::new(UnsafeCell::new(ExtraData {
+            lua: MaybeUninit::uninit(),
+            weak: MaybeUninit::uninit(),
+            registered_userdata: FxHashMap::default(),
+            registered_userdata_mt: FxHashMap::default(),
+            last_checked_userdata_mt: (ptr::null(), None),
+            registry_unref_list: Arc::new(Mutex::new(Some(Vec::new()))),
+            app_data: AppData::default(),
+            safe: false,
+            libs: StdLib::NONE,
+            #[cfg(feature = "module")]
+            skip_memory_check: false,
+            ref_thread,
+            // We need some reserved stack space to move values in and out of the ref stack.
+            ref_stack_size: ffi::LUA_MINSTACK - REF_STACK_RESERVE,
+            ref_stack_top: ffi::lua_gettop(ref_thread),
+            ref_free: Vec::new(),
+            wrapped_failure_pool: Vec::with_capacity(WRAPPED_FAILURE_POOL_SIZE),
+            // multivalue_pool: Vec::with_capacity(MULTIVALUE_POOL_SIZE),
+            #[cfg(feature = "async")]
+            thread_pool: Vec::new(),
+            wrapped_failure_mt_ptr,
+            #[cfg(feature = "async")]
+            waker: NonNull::from(noop_waker_ref()),
+            #[cfg(not(feature = "luau"))]
+            hook_callback: None,
+            #[cfg(not(feature = "luau"))]
+            hook_thread: ptr::null_mut(),
+            #[cfg(feature = "lua54")]
+            warn_callback: None,
+            #[cfg(feature = "luau")]
+            interrupt_callback: None,
+            #[cfg(feature = "luau")]
+            sandboxed: false,
+            #[cfg(feature = "luau")]
+            compiler: None,
+            #[cfg(feature = "luau-jit")]
+            enable_jit: true,
+        }));
+
+        // Store it in the registry
+        mlua_expect!(Self::store(&extra, state), "Error while storing extra data");
+
+        extra
+    }
+
+    pub(super) unsafe fn set_lua(&mut self, lua: &XRc<ReentrantMutex<RawLua>>) {
+        self.lua.write(XRc::clone(lua));
+        if cfg!(not(feature = "module")) {
+            XRc::decrement_strong_count(XRc::as_ptr(lua));
+        }
+        self.weak.write(XRc::downgrade(lua));
+    }
+
+    pub(super) unsafe fn get(state: *mut ffi::lua_State) -> *mut Self {
+        #[cfg(feature = "luau")]
+        if cfg!(not(feature = "module")) {
+            // In the main app we can use `lua_callbacks` to access ExtraData
+            return (*ffi::lua_callbacks(state)).userdata as *mut _;
+        }
+
+        let extra_key = &EXTRA_REGISTRY_KEY as *const u8 as *const c_void;
+        if ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, extra_key) != ffi::LUA_TUSERDATA {
+            // `ExtraData` can be null only when Lua state is foreign.
+            // This case in used in `Lua::try_from_ptr()`.
+            ffi::lua_pop(state, 1);
+            return ptr::null_mut();
+        }
+        let extra_ptr = ffi::lua_touserdata(state, -1) as *mut Rc<UnsafeCell<ExtraData>>;
+        ffi::lua_pop(state, 1);
+        (*extra_ptr).get()
+    }
+
+    unsafe fn store(extra: &XRc<UnsafeCell<Self>>, state: *mut ffi::lua_State) -> Result<()> {
+        #[cfg(feature = "luau")]
+        if cfg!(not(feature = "module")) {
+            (*ffi::lua_callbacks(state)).userdata = extra.get() as *mut _;
+            return Ok(());
+        }
+
+        push_internal_userdata(state, XRc::clone(extra), true)?;
+        protect_lua!(state, 1, 0, fn(state) {
+            let extra_key = &EXTRA_REGISTRY_KEY as *const u8 as *const c_void;
+            ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, extra_key);
+        })
+    }
+
+    #[inline(always)]
+    pub(super) unsafe fn lua(&self) -> &Lua {
+        mem::transmute(self.lua.assume_init_ref())
+    }
+
+    #[inline(always)]
+    pub(super) unsafe fn raw_lua(&self) -> &RawLua {
+        &*self.lua.assume_init_ref().data_ptr()
+    }
+
+    #[inline(always)]
+    pub(super) unsafe fn weak(&self) -> &WeakLua {
+        mem::transmute(self.weak.assume_init_ref())
+    }
+}
@@ -0,0 +1,181 @@
+use std::os::raw::c_int;
+use std::panic::{catch_unwind, AssertUnwindSafe};
+use std::ptr;
+use std::sync::Arc;
+
+use crate::error::{Error, Result};
+use crate::state::{ExtraData, RawLua};
+use crate::util::{self, get_internal_metatable, WrappedFailure};
+
+const WRAPPED_FAILURE_POOL_SIZE: usize = 64;
+// const MULTIVALUE_POOL_SIZE: usize = 64;
+
+pub(super) struct StateGuard<'a>(&'a RawLua, *mut ffi::lua_State);
+
+impl<'a> StateGuard<'a> {
+    pub(super) fn new(inner: &'a RawLua, mut state: *mut ffi::lua_State) -> Self {
+        state = inner.state.replace(state);
+        Self(inner, state)
+    }
+}
+
+impl<'a> Drop for StateGuard<'a> {
+    fn drop(&mut self) {
+        self.0.state.set(self.1);
+    }
+}
+
+// An optimized version of `callback_error` that does not allocate `WrappedFailure` userdata
+// and instead reuses unsed values from previous calls (or allocates new).
+pub(super) unsafe fn callback_error_ext<F, R>(
+    state: *mut ffi::lua_State,
+    mut extra: *mut ExtraData,
+    f: F,
+) -> R
+where
+    F: FnOnce(c_int) -> Result<R>,
+{
+    if extra.is_null() {
+        extra = ExtraData::get(state);
+    }
+
+    let nargs = ffi::lua_gettop(state);
+
+    enum PreallocatedFailure {
+        New(*mut WrappedFailure),
+        Existing(i32),
+    }
+
+    impl PreallocatedFailure {
+        unsafe fn reserve(state: *mut ffi::lua_State, extra: *mut ExtraData) -> Self {
+            match (*extra).wrapped_failure_pool.pop() {
+                Some(index) => PreallocatedFailure::Existing(index),
+                None => {
+                    // We need to check stack for Luau in case when callback is called from interrupt
+                    // See https://github.com/Roblox/luau/issues/446 and mlua #142 and #153
+                    #[cfg(feature = "luau")]
+                    ffi::lua_rawcheckstack(state, 2);
+                    // Place it to the beginning of the stack
+                    let ud = WrappedFailure::new_userdata(state);
+                    ffi::lua_insert(state, 1);
+                    PreallocatedFailure::New(ud)
+                }
+            }
+        }
+
+        unsafe fn r#use(&self, state: *mut ffi::lua_State, extra: *mut ExtraData) -> *mut WrappedFailure {
+            let ref_thread = (*extra).ref_thread;
+            match *self {
+                PreallocatedFailure::New(ud) => {
+                    ffi::lua_settop(state, 1);
+                    ud
+                }
+                PreallocatedFailure::Existing(index) => {
+                    ffi::lua_settop(state, 0);
+                    #[cfg(feature = "luau")]
+                    ffi::lua_rawcheckstack(state, 2);
+                    ffi::lua_pushvalue(ref_thread, index);
+                    ffi::lua_xmove(ref_thread, state, 1);
+                    ffi::lua_pushnil(ref_thread);
+                    ffi::lua_replace(ref_thread, index);
+                    (*extra).ref_free.push(index);
+                    ffi::lua_touserdata(state, -1) as *mut WrappedFailure
+                }
+            }
+        }
+
+        unsafe fn release(self, state: *mut ffi::lua_State, extra: *mut ExtraData) {
+            let ref_thread = (*extra).ref_thread;
+            match self {
+                PreallocatedFailure::New(_) => {
+                    if (*extra).wrapped_failure_pool.len() < WRAPPED_FAILURE_POOL_SIZE {
+                        ffi::lua_rotate(state, 1, -1);
+                        ffi::lua_xmove(state, ref_thread, 1);
+                        let index = ref_stack_pop(extra);
+                        (*extra).wrapped_failure_pool.push(index);
+                    } else {
+                        ffi::lua_remove(state, 1);
+                    }
+                }
+                PreallocatedFailure::Existing(index) => {
+                    if (*extra).wrapped_failure_pool.len() < WRAPPED_FAILURE_POOL_SIZE {
+                        (*extra).wrapped_failure_pool.push(index);
+                    } else {
+                        ffi::lua_pushnil(ref_thread);
+                        ffi::lua_replace(ref_thread, index);
+                        (*extra).ref_free.push(index);
+                    }
+                }
+            }
+        }
+    }
+
+    // We cannot shadow Rust errors with Lua ones, so we need to reserve pre-allocated memory
+    // to store a wrapped failure (error or panic) *before* we proceed.
+    let prealloc_failure = PreallocatedFailure::reserve(state, extra);
+
+    match catch_unwind(AssertUnwindSafe(|| f(nargs))) {
+        Ok(Ok(r)) => {
+            // Return unused `WrappedFailure` to the pool
+            prealloc_failure.release(state, extra);
+            r
+        }
+        Ok(Err(err)) => {
+            let wrapped_error = prealloc_failure.r#use(state, extra);
+
+            // 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 = util::to_string(state, -1);
+                ffi::lua_pop(state, 1);
+                traceback
+            } else {
+                "<not enough stack space for traceback>".to_string()
+            };
+            let cause = Arc::new(err);
+            ptr::write(
+                wrapped_error,
+                WrappedFailure::Error(Error::CallbackError { traceback, cause }),
+            );
+            get_internal_metatable::<WrappedFailure>(state);
+            ffi::lua_setmetatable(state, -2);
+
+            ffi::lua_error(state)
+        }
+        Err(p) => {
+            let wrapped_panic = prealloc_failure.r#use(state, extra);
+            ptr::write(wrapped_panic, WrappedFailure::Panic(Some(p)));
+            get_internal_metatable::<WrappedFailure>(state);
+            ffi::lua_setmetatable(state, -2);
+            ffi::lua_error(state)
+        }
+    }
+}
+
+pub(super) unsafe fn ref_stack_pop(extra: *mut ExtraData) -> c_int {
+    let extra = &mut *extra;
+    if let Some(free) = extra.ref_free.pop() {
+        ffi::lua_replace(extra.ref_thread, free);
+        return free;
+    }
+
+    // Try to grow max stack size
+    if extra.ref_stack_top >= extra.ref_stack_size {
+        let mut inc = extra.ref_stack_size; // Try to double stack size
+        while inc > 0 && ffi::lua_checkstack(extra.ref_thread, inc) == 0 {
+            inc /= 2;
+        }
+        if inc == 0 {
+            // Pop item on top of the stack to avoid stack leaking and successfully run destructors
+            // during unwinding.
+            ffi::lua_pop(extra.ref_thread, 1);
+            let top = extra.ref_stack_top;
+            // It is a user error to create enough references to exhaust the Lua max stack size for
+            // the ref thread.
+            panic!("cannot create a Lua reference, out of auxiliary stack space (used {top} slots)");
+        }
+        extra.ref_stack_size += inc;
+    }
+    extra.ref_stack_top += 1;
+    extra.ref_stack_top
+}
@@ -1,5 +1,4 @@
 use std::ops::{BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign};
-use std::u32;

 /// Flags describing the set of lua standard libraries to load.
 #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
@@ -9,39 +8,46 @@ impl StdLib {
    /// [`coroutine`](https://www.lua.org/manual/5.4/manual.html#6.2) library
    ///
    /// Requires `feature = "lua54/lua53/lua52/luau"`
-    #[cfg(any(
-        feature = "lua54",
-        feature = "lua53",
-        feature = "lua52",
-        feature = "luau"
-    ))]
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luau"))]
    pub const COROUTINE: StdLib = StdLib(1);
+
    /// [`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.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.4/manual.html#6.9) library
    pub const OS: StdLib = StdLib(1 << 3);
+
    /// [`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.4/manual.html#6.5) library
    ///
    /// 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/luau"`
    #[cfg(any(feature = "lua52", feature = "luajit", feature = "luau", doc))]
    pub const BIT: StdLib = StdLib(1 << 6);
+
    /// [`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.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);
+
+    /// [`buffer`](https://luau-lang.org/library#buffer-library) library
+    #[cfg(any(feature = "luau", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+    pub const BUFFER: StdLib = StdLib(1 << 9);
+
    /// [`jit`](http://luajit.org/ext_jit.html) library
    ///
    /// Requires `feature = "luajit"`
@@ -55,6 +61,7 @@ impl StdLib {
    #[cfg(any(feature = "luajit", doc))]
    #[cfg_attr(docsrs, doc(cfg(feature = "luajit")))]
    pub const FFI: StdLib = StdLib(1 << 30);
+
    /// (**unsafe**) [`debug`](https://www.lua.org/manual/5.4/manual.html#6.10) library
    pub const DEBUG: StdLib = StdLib(1 << 31);

@@ -1,8 +1,9 @@
-use std::borrow::{Borrow, Cow};
+use std::borrow::Borrow;
 use std::hash::{Hash, Hasher};
+use std::ops::Deref;
 use std::os::raw::c_void;
 use std::string::String as StdString;
-use std::{slice, str};
+use std::{cmp, fmt, slice, str};

 #[cfg(feature = "serialize")]
 use {
@@ -11,17 +12,17 @@ use {
 };

 use crate::error::{Error, Result};
-use crate::ffi;
-use crate::types::LuaRef;
+use crate::state::LuaGuard;
+use crate::types::ValueRef;

 /// Handle to an internal Lua string.
 ///
 /// Unlike Rust strings, Lua strings may not be valid UTF-8.
-#[derive(Clone, Debug)]
-pub struct String<'lua>(pub(crate) LuaRef<'lua>);
+#[derive(Clone)]
+pub struct String(pub(crate) ValueRef);

-impl<'lua> String<'lua> {
-    /// Get a `&str` slice if the Lua string is valid UTF-8.
+impl String {
+    /// Get a [`BorrowedStr`] if the Lua string is valid UTF-8.
    ///
    /// # Examples
    ///
@@ -40,15 +41,17 @@ impl<'lua> String<'lua> {
    /// # }
    /// ```
    #[inline]
-    pub fn to_str(&self) -> Result<&str> {
-        str::from_utf8(self.as_bytes()).map_err(|e| Error::FromLuaConversionError {
+    pub fn to_str(&self) -> Result<BorrowedStr> {
+        let BorrowedBytes(bytes, guard) = self.as_bytes();
+        let s = str::from_utf8(bytes).map_err(|e| Error::FromLuaConversionError {
            from: "string",
            to: "&str",
            message: Some(e.to_string()),
-        })
+        })?;
+        Ok(BorrowedStr(s, guard))
    }

-    /// Converts this string to a [`Cow<str>`].
+    /// Converts this string to a [`StdString`].
    ///
    /// Any non-Unicode sequences are replaced with [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD].
    ///
@@ -67,8 +70,8 @@ impl<'lua> String<'lua> {
    /// # }
    /// ```
    #[inline]
-    pub fn to_string_lossy(&self) -> Cow<'_, str> {
-        StdString::from_utf8_lossy(self.as_bytes())
+    pub fn to_string_lossy(&self) -> StdString {
+        StdString::from_utf8_lossy(&self.as_bytes()).into_owned()
    }

    /// Get the bytes that make up this string.
@@ -89,14 +92,20 @@ impl<'lua> String<'lua> {
    /// # }
    /// ```
    #[inline]
-    pub fn as_bytes(&self) -> &[u8] {
-        let nulled = self.as_bytes_with_nul();
-        &nulled[..nulled.len() - 1]
+    pub fn as_bytes(&self) -> BorrowedBytes {
+        let (bytes, guard) = unsafe { self.to_slice() };
+        BorrowedBytes(&bytes[..bytes.len() - 1], guard)
    }

    /// Get the bytes that make up this string, including the trailing nul byte.
-    pub fn as_bytes_with_nul(&self) -> &[u8] {
-        let ref_thread = self.0.lua.ref_thread();
+    pub fn as_bytes_with_nul(&self) -> BorrowedBytes {
+        let (bytes, guard) = unsafe { self.to_slice() };
+        BorrowedBytes(bytes, guard)
+    }
+
+    unsafe fn to_slice(&self) -> (&[u8], LuaGuard) {
+        let lua = self.0.lua.lock();
+        let ref_thread = lua.ref_thread();
        unsafe {
            mlua_debug_assert!(
                ffi::lua_type(ref_thread, self.0.index) == ffi::LUA_TSTRING,
@@ -108,68 +117,220 @@ impl<'lua> String<'lua> {
            // string type
            let data = ffi::lua_tolstring(ref_thread, self.0.index, &mut size);

-            slice::from_raw_parts(data as *const u8, size + 1)
+            (slice::from_raw_parts(data as *const u8, size + 1), lua)
        }
    }

-    /// Converts the string to a generic C pointer.
+    /// Converts this string to a generic C pointer.
    ///
    /// There is no way to convert the pointer back to its original value.
    ///
    /// Typically this function is used only for hashing and debug information.
    #[inline]
    pub fn to_pointer(&self) -> *const c_void {
-        let ref_thread = self.0.lua.ref_thread();
-        unsafe { ffi::lua_topointer(ref_thread, self.0.index) }
+        self.0.to_pointer()
    }
 }

-impl<'lua> AsRef<[u8]> for String<'lua> {
-    fn as_ref(&self) -> &[u8] {
-        self.as_bytes()
-    }
-}
+impl fmt::Debug for String {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let bytes = self.as_bytes();
+        // Check if the string is valid utf8
+        if let Ok(s) = str::from_utf8(&bytes) {
+            return s.fmt(f);
+        }

-impl<'lua> Borrow<[u8]> for String<'lua> {
-    fn borrow(&self) -> &[u8] {
-        self.as_bytes()
+        // Format as bytes
+        write!(f, "b\"")?;
+        for &b in bytes {
+            // https://doc.rust-lang.org/reference/tokens.html#byte-escapes
+            match b {
+                b'\n' => write!(f, "\\n")?,
+                b'\r' => write!(f, "\\r")?,
+                b'\t' => write!(f, "\\t")?,
+                b'\\' | b'"' => write!(f, "\\{}", b as char)?,
+                b'\0' => write!(f, "\\0")?,
+                // ASCII printable
+                0x20..=0x7e => write!(f, "{}", b as char)?,
+                _ => write!(f, "\\x{b:02x}")?,
+            }
+        }
+        write!(f, "\"")?;
+
+        Ok(())
    }
 }

 // Lua strings are basically &[u8] slices, so implement PartialEq for anything resembling that.
 //
-// This makes our `String` comparable with `Vec<u8>`, `[u8]`, `&str`, `String` and `mlua::String`
-// itself.
+// This makes our `String` comparable with `Vec<u8>`, `[u8]`, `&str` and `String`.
 //
 // The only downside is that this disallows a comparison with `Cow<str>`, as that only implements
 // `AsRef<str>`, which collides with this impl. Requiring `AsRef<str>` would fix that, but limit us
 // in other ways.
-impl<'lua, T> PartialEq<T> for String<'lua>
+impl<T> PartialEq<T> for String
 where
-    T: AsRef<[u8]>,
+    T: AsRef<[u8]> + ?Sized,
 {
    fn eq(&self, other: &T) -> bool {
        self.as_bytes() == other.as_ref()
    }
 }

-impl<'lua> Eq for String<'lua> {}
+impl PartialEq<String> for String {
+    fn eq(&self, other: &String) -> bool {
+        self.as_bytes() == other.as_bytes()
+    }
+}

-impl<'lua> Hash for String<'lua> {
+impl PartialEq<&String> for String {
+    fn eq(&self, other: &&String) -> bool {
+        self.as_bytes() == other.as_bytes()
+    }
+}
+
+impl Eq for String {}
+
+impl Hash for String {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.as_bytes().hash(state);
    }
 }

 #[cfg(feature = "serialize")]
-impl<'lua> Serialize for String<'lua> {
+impl Serialize for String {
    fn serialize<S>(&self, serializer: S) -> StdResult<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match self.to_str() {
-            Ok(s) => serializer.serialize_str(s),
-            Err(_) => serializer.serialize_bytes(self.as_bytes()),
+            Ok(s) => serializer.serialize_str(&s),
+            Err(_) => serializer.serialize_bytes(&self.as_bytes()),
        }
    }
 }
+
+/// A borrowed string (`&str`) that holds a strong reference to the Lua state.
+pub struct BorrowedStr<'a>(&'a str, #[allow(unused)] LuaGuard);
+
+impl Deref for BorrowedStr<'_> {
+    type Target = str;
+
+    #[inline(always)]
+    fn deref(&self) -> &str {
+        self.0
+    }
+}
+
+impl Borrow<str> for BorrowedStr<'_> {
+    #[inline(always)]
+    fn borrow(&self) -> &str {
+        self.0
+    }
+}
+
+impl AsRef<str> for BorrowedStr<'_> {
+    #[inline(always)]
+    fn as_ref(&self) -> &str {
+        self.0
+    }
+}
+
+impl fmt::Display for BorrowedStr<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl fmt::Debug for BorrowedStr<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl<T> PartialEq<T> for BorrowedStr<'_>
+where
+    T: AsRef<str>,
+{
+    fn eq(&self, other: &T) -> bool {
+        self.0 == other.as_ref()
+    }
+}
+
+impl<T> PartialOrd<T> for BorrowedStr<'_>
+where
+    T: AsRef<str>,
+{
+    fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> {
+        self.0.partial_cmp(other.as_ref())
+    }
+}
+
+/// A borrowed byte slice (`&[u8]`) that holds a strong reference to the Lua state.
+pub struct BorrowedBytes<'a>(&'a [u8], #[allow(unused)] LuaGuard);
+
+impl Deref for BorrowedBytes<'_> {
+    type Target = [u8];
+
+    #[inline(always)]
+    fn deref(&self) -> &[u8] {
+        self.0
+    }
+}
+
+impl Borrow<[u8]> for BorrowedBytes<'_> {
+    #[inline(always)]
+    fn borrow(&self) -> &[u8] {
+        self.0
+    }
+}
+
+impl AsRef<[u8]> for BorrowedBytes<'_> {
+    #[inline(always)]
+    fn as_ref(&self) -> &[u8] {
+        self.0
+    }
+}
+
+impl fmt::Debug for BorrowedBytes<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl<T> PartialEq<T> for BorrowedBytes<'_>
+where
+    T: AsRef<[u8]>,
+{
+    fn eq(&self, other: &T) -> bool {
+        self.0 == other.as_ref()
+    }
+}
+
+impl<T> PartialOrd<T> for BorrowedBytes<'_>
+where
+    T: AsRef<[u8]>,
+{
+    fn partial_cmp(&self, other: &T) -> Option<cmp::Ordering> {
+        self.0.partial_cmp(other.as_ref())
+    }
+}
+
+impl<'a> IntoIterator for BorrowedBytes<'a> {
+    type Item = &'a u8;
+    type IntoIter = slice::Iter<'a, u8>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_any!(String: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(String: Send, Sync);
+}
@@ -1,35 +1,33 @@
-use std::cmp;
-use std::os::raw::c_int;
+use std::os::raw::{c_int, c_void};

 use crate::error::{Error, Result};
-use crate::ffi;
-use crate::types::LuaRef;
+#[allow(unused)]
+use crate::state::Lua;
+use crate::state::RawLua;
+use crate::types::ValueRef;
 use crate::util::{check_stack, error_traceback_thread, pop_error, StackGuard};
-use crate::value::{FromLuaMulti, ToLuaMulti};
+use crate::value::{FromLuaMulti, IntoLuaMulti};

-#[cfg(any(
-    feature = "lua54",
-    all(feature = "luajit", feature = "vendored"),
-    feature = "luau",
-))]
-use crate::function::Function;
+#[cfg(not(feature = "luau"))]
+use crate::{
+    hook::{Debug, HookTriggers},
+    types::MaybeSend,
+};

 #[cfg(feature = "async")]
 use {
-    crate::{
-        lua::{Lua, ASYNC_POLL_PENDING},
-        value::{MultiValue, Value},
-    },
-    futures_core::{future::Future, stream::Stream},
+    crate::value::MultiValue,
+    futures_util::stream::Stream,
    std::{
-        cell::RefCell,
+        future::Future,
        marker::PhantomData,
        pin::Pin,
+        ptr::NonNull,
        task::{Context, Poll, Waker},
    },
 };

-/// Status of a Lua thread (or coroutine).
+/// Status of a Lua thread (coroutine).
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum ThreadStatus {
    /// The thread was just created, or is suspended because it has called `coroutine.yield`.
@@ -44,27 +42,37 @@ pub enum ThreadStatus {
    Error,
 }

-/// Handle to an internal Lua thread (or coroutine).
+/// Handle to an internal Lua thread (coroutine).
 #[derive(Clone, Debug)]
-pub struct Thread<'lua>(pub(crate) LuaRef<'lua>);
+pub struct Thread(pub(crate) ValueRef, pub(crate) *mut ffi::lua_State);
+
+#[cfg(feature = "send")]
+unsafe impl Send for Thread {}
+#[cfg(feature = "send")]
+unsafe impl Sync for Thread {}

 /// Thread (coroutine) representation as an async [`Future`] or [`Stream`].
 ///
 /// Requires `feature = "async"`
 ///
-/// [`Future`]: futures_core::future::Future
-/// [`Stream`]: futures_core::stream::Stream
+/// [`Future`]: std::future::Future
+/// [`Stream`]: futures_util::stream::Stream
 #[cfg(feature = "async")]
 #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-#[derive(Debug)]
-pub struct AsyncThread<'lua, R> {
-    thread: Thread<'lua>,
-    args0: RefCell<Option<Result<MultiValue<'lua>>>>,
+#[must_use = "futures do nothing unless you `.await` or poll them"]
+pub struct AsyncThread<R> {
+    thread: Thread,
+    init_args: Option<Result<MultiValue>>,
    ret: PhantomData<R>,
    recycle: bool,
 }

-impl<'lua> Thread<'lua> {
+impl Thread {
+    #[inline(always)]
+    const fn state(&self) -> *mut ffi::lua_State {
+        self.1
+    }
+
    /// Resumes execution of this thread.
    ///
    /// Equivalent to `coroutine.resume`.
@@ -108,67 +116,95 @@ impl<'lua> Thread<'lua> {
    /// ```
    pub fn resume<A, R>(&self, args: A) -> Result<R>
    where
-        A: ToLuaMulti<'lua>,
-        R: FromLuaMulti<'lua>,
+        A: IntoLuaMulti,
+        R: FromLuaMulti,
    {
-        let lua = self.0.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::max(nargs + 1, 3))?;
+        let lua = self.0.lua.lock();

-            let thread_state = ffi::lua_tothread(lua.ref_thread(), self.0.index);
+        if unsafe { self.status_unprotected() } != ThreadStatus::Resumable {
+            return Err(Error::CoroutineInactive);
+        }

-            let status = ffi::lua_status(thread_state);
-            if status != ffi::LUA_YIELD && ffi::lua_gettop(thread_state) == 0 {
-                return Err(Error::CoroutineInactive);
-            }
+        let state = lua.state();
+        let thread_state = self.state();
+        unsafe {
+            let _sg = StackGuard::new(state);
+            let _thread_sg = StackGuard::with_top(thread_state, 0);

+            let nresults = self.resume_inner(args)?;
+            check_stack(state, nresults + 1)?;
+            ffi::lua_xmove(thread_state, state, nresults);
+
+            R::from_stack_multi(nresults, &lua)
+        }
+    }
+
+    /// Resumes execution of this thread.
+    ///
+    /// It's similar to `resume()` but leaves `nresults` values on the thread stack.
+    unsafe fn resume_inner<A: IntoLuaMulti>(&self, args: A) -> Result<c_int> {
+        let lua = self.0.lua.lock();
+        let state = lua.state();
+        let thread_state = self.state();
+
+        let nargs = args.push_into_stack_multi(&lua)?;
+        if nargs > 0 {
            check_stack(thread_state, nargs)?;
-            for arg in args.drain_all() {
-                lua.push_value(arg)?;
+            ffi::lua_xmove(state, thread_state, nargs);
+        }
+
+        let mut nresults = 0;
+        let ret = ffi::lua_resume(thread_state, state, nargs, &mut nresults as *mut c_int);
+        if ret != ffi::LUA_OK && ret != ffi::LUA_YIELD {
+            if ret == ffi::LUA_ERRMEM {
+                // Don't call error handler for memory errors
+                return Err(pop_error(thread_state, ret));
            }
-            ffi::lua_xmove(lua.state, thread_state, nargs);
+            check_stack(state, 3)?;
+            protect_lua!(state, 0, 1, |state| error_traceback_thread(state, thread_state))?;
+            return Err(pop_error(state, ret));
+        }

-            let mut nresults = 0;
-
-            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 {
-                check_stack(lua.state, 3)?;
-                protect_lua!(lua.state, 0, 1, |state| error_traceback_thread(
-                    state,
-                    thread_state
-                ))?;
-                return Err(pop_error(lua.state, ret));
-            }
-
-            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);
-
-            for _ in 0..nresults {
-                results.push_front(lua.pop_value());
-            }
-            results
-        };
-        R::from_lua_multi(results, lua)
+        Ok(nresults)
    }

    /// Gets the status of the thread.
    pub fn status(&self) -> ThreadStatus {
-        let lua = self.0.lua;
-        unsafe {
-            let thread_state = ffi::lua_tothread(lua.ref_thread(), self.0.index);
+        let _guard = self.0.lua.lock();
+        unsafe { self.status_unprotected() }
+    }

-            let status = ffi::lua_status(thread_state);
-            if status != ffi::LUA_OK && status != ffi::LUA_YIELD {
-                ThreadStatus::Error
-            } else if status == ffi::LUA_YIELD || ffi::lua_gettop(thread_state) > 0 {
-                ThreadStatus::Resumable
-            } else {
-                ThreadStatus::Unresumable
-            }
+    /// Gets the status of the thread without locking the Lua state.
+    pub(crate) unsafe fn status_unprotected(&self) -> ThreadStatus {
+        let thread_state = self.state();
+        // FIXME: skip double lock
+        if thread_state == self.0.lua.lock().state() {
+            // The coroutine is currently running
+            return ThreadStatus::Unresumable;
+        }
+        let status = ffi::lua_status(thread_state);
+        if status != ffi::LUA_OK && status != ffi::LUA_YIELD {
+            ThreadStatus::Error
+        } else if status == ffi::LUA_YIELD || ffi::lua_gettop(thread_state) > 0 {
+            ThreadStatus::Resumable
+        } else {
+            ThreadStatus::Unresumable
+        }
+    }
+
+    /// Sets a 'hook' function that will periodically be called as Lua code executes.
+    ///
+    /// This function is similar or [`Lua::set_hook()`] except that it sets for the thread.
+    /// To remove a hook call [`Lua::remove_hook()`].
+    #[cfg(not(feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(not(feature = "luau"))))]
+    pub fn set_hook<F>(&self, triggers: HookTriggers, callback: F)
+    where
+        F: Fn(&Lua, Debug) -> Result<()> + MaybeSend + 'static,
+    {
+        let lua = self.0.lua.lock();
+        unsafe {
+            lua.set_thread_hook(self.state(), triggers, callback);
        }
    }

@@ -178,49 +214,41 @@ 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] and Luau: resets to the initial state of a newly created Lua thread.
+    /// In 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"` OR `feature = "luau"`
+    /// Requires `feature = "lua54"` 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"),
-        feature = "luau",
-    ))]
-    pub fn reset(&self, func: Function<'lua>) -> Result<()> {
-        let lua = self.0.lua;
+    /// [Lua 5.4]: https://www.lua.org/manual/5.4/manual.html#lua_closethread
+    #[cfg(any(feature = "lua54", feature = "luau"))]
+    #[cfg_attr(docsrs, doc(cfg(any(feature = "lua54", feature = "luau"))))]
+    pub fn reset(&self, func: crate::function::Function) -> Result<()> {
+        let lua = self.0.lua.lock();
+        let thread_state = self.state();
+        if thread_state == lua.state() {
+            return Err(Error::runtime("cannot reset a running thread"));
+        }
        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            check_stack(lua.state, 2)?;
-
-            lua.push_ref(&self.0);
-            let thread_state = ffi::lua_tothread(lua.state, -1);
-
            #[cfg(all(feature = "lua54", not(feature = "vendored")))]
            let status = ffi::lua_resetthread(thread_state);
            #[cfg(all(feature = "lua54", feature = "vendored"))]
-            let status = ffi::lua_closethread(thread_state, lua.state);
+            let status = ffi::lua_closethread(thread_state, lua.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);
+            // Push function to the top of the thread stack
+            ffi::lua_xpush(lua.ref_thread(), thread_state, func.0.index);

            #[cfg(feature = "luau")]
            {
-                // Inherit `LUA_GLOBALSINDEX` from the caller
-                ffi::lua_xpush(lua.state, thread_state, ffi::LUA_GLOBALSINDEX);
+                // Inherit `LUA_GLOBALSINDEX` from the main thread
+                ffi::lua_xpush(lua.main_state(), thread_state, ffi::LUA_GLOBALSINDEX);
                ffi::lua_replace(thread_state, ffi::LUA_GLOBALSINDEX);
            }

@@ -240,15 +268,15 @@ impl<'lua> Thread<'lua> {
    ///
    /// Requires `feature = "async"`
    ///
-    /// [`Future`]: futures_core::future::Future
-    /// [`Stream`]: futures_core::stream::Stream
+    /// [`Future`]: std::future::Future
+    /// [`Stream`]: futures_util::stream::Stream
    /// [`resume()`]: https://www.lua.org/manual/5.4/manual.html#lua_resume
    ///
    /// # Examples
    ///
    /// ```
    /// # use mlua::{Lua, Result, Thread};
-    /// use futures::stream::TryStreamExt;
+    /// use futures_util::stream::TryStreamExt;
    /// # #[tokio::main]
    /// # async fn main() -> Result<()> {
    /// # let lua = Lua::new();
@@ -275,15 +303,16 @@ impl<'lua> Thread<'lua> {
    /// ```
    #[cfg(feature = "async")]
    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
-    pub fn into_async<A, R>(self, args: A) -> AsyncThread<'lua, R>
+    pub fn into_async<A, R>(self, args: A) -> AsyncThread<R>
    where
-        A: ToLuaMulti<'lua>,
-        R: FromLuaMulti<'lua>,
+        A: IntoLuaMulti,
+        R: FromLuaMulti,
    {
-        let args = args.to_lua_multi(self.0.lua);
+        let lua = self.0.lua.lock();
+        let args = args.into_lua_multi(lua.lua());
        AsyncThread {
            thread: self,
-            args0: RefCell::new(Some(args)),
+            init_args: Some(args),
            ret: PhantomData,
            recycle: false,
        }
@@ -324,27 +353,35 @@ impl<'lua> Thread<'lua> {
    #[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
    #[doc(hidden)]
    pub fn sandbox(&self) -> Result<()> {
-        let lua = self.0.lua;
+        let lua = self.0.lua.lock();
+        let state = lua.state();
+        let thread_state = self.state();
        unsafe {
-            let thread = ffi::lua_tothread(lua.ref_thread(), self.0.index);
-            check_stack(thread, 1)?;
-            check_stack(lua.state, 3)?;
-            // Inherit `LUA_GLOBALSINDEX` from the caller
-            ffi::lua_xpush(lua.state, thread, ffi::LUA_GLOBALSINDEX);
-            ffi::lua_replace(thread, ffi::LUA_GLOBALSINDEX);
-            protect_lua!(lua.state, 0, 0, |_| ffi::luaL_sandboxthread(thread))
+            check_stack(thread_state, 3)?;
+            check_stack(state, 3)?;
+            protect_lua!(state, 0, 0, |_| ffi::luaL_sandboxthread(thread_state))
        }
    }
+
+    /// Converts this thread to a generic C pointer.
+    ///
+    /// There is no way to convert the pointer back to its original value.
+    ///
+    /// Typically this function is used only for hashing and debug information.
+    #[inline]
+    pub fn to_pointer(&self) -> *const c_void {
+        self.0.to_pointer()
+    }
 }

-impl<'lua> PartialEq for Thread<'lua> {
+impl PartialEq for Thread {
    fn eq(&self, other: &Self) -> bool {
        self.0 == other.0
    }
 }

 #[cfg(feature = "async")]
-impl<'lua, R> AsyncThread<'lua, R> {
+impl<R> AsyncThread<R> {
    #[inline]
    pub(crate) fn set_recyclable(&mut self, recyclable: bool) {
        self.recycle = recyclable;
@@ -352,22 +389,20 @@ impl<'lua, R> AsyncThread<'lua, R> {
 }

 #[cfg(feature = "async")]
-#[cfg(any(
-    feature = "lua54",
-    all(feature = "luajit", feature = "vendored"),
-    feature = "luau",
-))]
-impl<'lua, R> Drop for AsyncThread<'lua, R> {
+#[cfg(any(feature = "lua54", feature = "luau"))]
+impl<R> Drop for AsyncThread<R> {
    fn drop(&mut self) {
        if self.recycle {
            unsafe {
-                let lua = self.thread.0.lua;
+                let lua = self.thread.0.lua.lock();
                // For Lua 5.4 this also closes all pending to-be-closed variables
                if !lua.recycle_thread(&mut self.thread) {
                    #[cfg(feature = "lua54")]
-                    if self.thread.status() == ThreadStatus::Error {
-                        let thread_state = ffi::lua_tothread(lua.ref_thread(), self.thread.0.index);
-                        ffi::lua_resetthread(thread_state);
+                    if self.thread.status_unprotected() == ThreadStatus::Error {
+                        #[cfg(not(feature = "vendored"))]
+                        ffi::lua_resetthread(self.thread.state());
+                        #[cfg(feature = "vendored")]
+                        ffi::lua_closethread(self.thread.state(), lua.state());
                    }
                }
            }
@@ -376,105 +411,125 @@ impl<'lua, R> Drop for AsyncThread<'lua, R> {
 }

 #[cfg(feature = "async")]
-impl<'lua, R> Stream for AsyncThread<'lua, R>
-where
-    R: FromLuaMulti<'lua>,
-{
+impl<R: FromLuaMulti> Stream for AsyncThread<R> {
    type Item = Result<R>;

    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let lua = self.thread.0.lua;
+        let lua = self.thread.0.lua.lock();
+        let state = lua.state();
+        let thread_state = self.thread.state();
+        unsafe {
+            if self.thread.status_unprotected() != ThreadStatus::Resumable {
+                return Poll::Ready(None);
+            }

-        match self.thread.status() {
-            ThreadStatus::Resumable => {}
-            _ => return Poll::Ready(None),
-        };
+            let _sg = StackGuard::new(state);
+            let _thread_sg = StackGuard::with_top(thread_state, 0);
+            let _wg = WakerGuard::new(&lua, cx.waker());

-        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 {
-            self.thread.resume(())?
-        };
+            // This is safe as we are not moving the whole struct
+            let this = self.get_unchecked_mut();
+            let nresults = if let Some(args) = this.init_args.take() {
+                this.thread.resume_inner(args?)?
+            } else {
+                this.thread.resume_inner(())?
+            };

-        if is_poll_pending(&ret) {
-            return Poll::Pending;
+            if nresults == 1 && is_poll_pending(thread_state) {
+                return Poll::Pending;
+            }
+
+            check_stack(state, nresults + 1)?;
+            ffi::lua_xmove(thread_state, state, nresults);
+
+            cx.waker().wake_by_ref();
+            Poll::Ready(Some(R::from_stack_multi(nresults, &lua)))
        }
-
-        cx.waker().wake_by_ref();
-        Poll::Ready(Some(R::from_lua_multi(ret, lua)))
    }
 }

 #[cfg(feature = "async")]
-impl<'lua, R> Future for AsyncThread<'lua, R>
-where
-    R: FromLuaMulti<'lua>,
-{
+impl<R: FromLuaMulti> Future for AsyncThread<R> {
    type Output = Result<R>;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let lua = self.thread.0.lua;
+        let lua = self.thread.0.lua.lock();
+        let state = lua.state();
+        let thread_state = self.thread.state();
+        unsafe {
+            if self.thread.status_unprotected() != ThreadStatus::Resumable {
+                return Poll::Ready(Err(Error::CoroutineInactive));
+            }

-        match self.thread.status() {
-            ThreadStatus::Resumable => {}
-            _ => return Poll::Ready(Err(Error::CoroutineInactive)),
-        };
+            let _sg = StackGuard::new(state);
+            let _thread_sg = StackGuard::with_top(thread_state, 0);
+            let _wg = WakerGuard::new(&lua, cx.waker());

-        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 {
-            self.thread.resume(())?
-        };
+            // This is safe as we are not moving the whole struct
+            let this = self.get_unchecked_mut();
+            let nresults = if let Some(args) = this.init_args.take() {
+                this.thread.resume_inner(args?)?
+            } else {
+                this.thread.resume_inner(())?
+            };

-        if is_poll_pending(&ret) {
-            return Poll::Pending;
+            if nresults == 1 && is_poll_pending(thread_state) {
+                return Poll::Pending;
+            }
+
+            if ffi::lua_status(thread_state) == ffi::LUA_YIELD {
+                // Ignore value returned via yield()
+                cx.waker().wake_by_ref();
+                return Poll::Pending;
+            }
+
+            check_stack(state, nresults + 1)?;
+            ffi::lua_xmove(thread_state, state, nresults);
+
+            Poll::Ready(R::from_stack_multi(nresults, &lua))
        }
-
-        if let ThreadStatus::Resumable = self.thread.status() {
-            // Ignore value returned via yield()
-            cx.waker().wake_by_ref();
-            return Poll::Pending;
-        }
-
-        Poll::Ready(R::from_lua_multi(ret, lua))
    }
 }

 #[cfg(feature = "async")]
 #[inline(always)]
-fn is_poll_pending(val: &MultiValue) -> bool {
-    match val.iter().enumerate().last() {
-        Some((0, Value::LightUserData(ud))) => {
-            std::ptr::eq(ud.0 as *const u8, &ASYNC_POLL_PENDING as *const u8)
-        }
-        _ => false,
-    }
+unsafe fn is_poll_pending(state: *mut ffi::lua_State) -> bool {
+    ffi::lua_tolightuserdata(state, -1) == Lua::poll_pending().0
 }

 #[cfg(feature = "async")]
-struct WakerGuard<'lua> {
-    lua: &'lua Lua,
-    prev: Option<Waker>,
+struct WakerGuard<'lua, 'a> {
+    lua: &'lua RawLua,
+    prev: NonNull<Waker>,
+    _phantom: PhantomData<&'a ()>,
 }

 #[cfg(feature = "async")]
-impl<'lua> WakerGuard<'lua> {
+impl<'lua, 'a> WakerGuard<'lua, 'a> {
    #[inline]
-    pub fn new(lua: &Lua, waker: Waker) -> Result<WakerGuard> {
-        unsafe {
-            let prev = lua.set_waker(Some(waker));
-            Ok(WakerGuard { lua, prev })
-        }
+    pub fn new(lua: &'lua RawLua, waker: &'a Waker) -> Result<WakerGuard<'lua, 'a>> {
+        let prev = unsafe { lua.set_waker(NonNull::from(waker)) };
+        Ok(WakerGuard {
+            lua,
+            prev,
+            _phantom: PhantomData,
+        })
    }
 }

 #[cfg(feature = "async")]
-impl<'lua> Drop for WakerGuard<'lua> {
+impl<'lua, 'a> Drop for WakerGuard<'lua, 'a> {
    fn drop(&mut self) {
-        unsafe {
-            self.lua.set_waker(self.prev.take());
-        }
+        unsafe { self.lua.set_waker(self.prev) };
    }
 }
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_any!(Thread: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(Thread: Send, Sync);
+}
@@ -1,52 +1,69 @@
 use std::cell::UnsafeCell;
 use std::hash::{Hash, Hasher};
 use std::os::raw::{c_int, c_void};
-use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::{Arc, Mutex};
+use std::rc::Rc;
+use std::sync::Arc;
 use std::{fmt, mem, ptr};

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

 use crate::error::Result;
-use crate::ffi;
 #[cfg(not(feature = "luau"))]
 use crate::hook::Debug;
-use crate::lua::{ExtraData, Lua};
-use crate::util::{assert_stack, StackGuard};
-use crate::value::MultiValue;
+use crate::state::{ExtraData, Lua, RawLua, WeakLua};
+
+#[cfg(feature = "async")]
+use {crate::value::MultiValue, futures_util::future::LocalBoxFuture};
+
+#[cfg(all(feature = "luau", feature = "serialize"))]
+use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
+
+// Re-export mutex wrappers
+pub use app_data::{AppData, AppDataRef, AppDataRefMut};
+pub(crate) use sync::{ArcReentrantMutexGuard, ReentrantMutex, ReentrantMutexGuard, XRc, XWeak};

 /// Type of Lua integer numbers.
 pub type Integer = ffi::lua_Integer;
 /// Type of Lua floating point numbers.
 pub type Number = ffi::lua_Number;

+// Represents different subtypes wrapped to AnyUserData
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub(crate) enum SubtypeId {
+    None,
+    #[cfg(feature = "luau")]
+    Buffer,
+    #[cfg(feature = "luajit")]
+    CData,
+}
+
 /// A "light" userdata value. Equivalent to an unmanaged raw pointer.
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub struct LightUserData(pub *mut c_void);

-pub(crate) type Callback<'lua, 'a> =
-    Box<dyn Fn(&'lua Lua, MultiValue<'lua>) -> Result<MultiValue<'lua>> + 'a>;
+#[cfg(feature = "send")]
+unsafe impl Send for LightUserData {}
+#[cfg(feature = "send")]
+unsafe impl Sync for LightUserData {}
+
+pub(crate) type Callback<'a> = Box<dyn Fn(&'a RawLua, c_int) -> Result<c_int> + 'static>;

 pub(crate) struct Upvalue<T> {
    pub(crate) data: T,
-    pub(crate) extra: Arc<UnsafeCell<ExtraData>>,
+    pub(crate) extra: XRc<UnsafeCell<ExtraData>>,
 }

-pub(crate) type CallbackUpvalue = Upvalue<Callback<'static, 'static>>;
+pub(crate) type CallbackUpvalue = Upvalue<Callback<'static>>;

 #[cfg(feature = "async")]
-pub(crate) type AsyncCallback<'lua, 'a> =
-    Box<dyn Fn(&'lua Lua, MultiValue<'lua>) -> LocalBoxFuture<'lua, Result<MultiValue<'lua>>> + 'a>;
+pub(crate) type AsyncCallback<'a> =
+    Box<dyn Fn(&'a RawLua, MultiValue) -> LocalBoxFuture<'a, Result<c_int>> + 'static>;

 #[cfg(feature = "async")]
-pub(crate) type AsyncCallbackUpvalue = Upvalue<AsyncCallback<'static, 'static>>;
+pub(crate) type AsyncCallbackUpvalue = Upvalue<AsyncCallback<'static>>;

 #[cfg(feature = "async")]
-pub(crate) type AsyncPollUpvalue = Upvalue<LocalBoxFuture<'static, Result<MultiValue<'static>>>>;
+pub(crate) type AsyncPollUpvalue = Upvalue<LocalBoxFuture<'static, Result<c_int>>>;

 /// Type to set next Luau VM action after executing interrupt function.
 #[cfg(any(feature = "luau", doc))]
@@ -57,22 +74,22 @@ pub enum VmState {
 }

 #[cfg(all(feature = "send", not(feature = "luau")))]
-pub(crate) type HookCallback = Arc<dyn Fn(&Lua, Debug) -> Result<()> + Send>;
+pub(crate) type HookCallback = Rc<dyn Fn(&Lua, Debug) -> Result<()> + Send>;

 #[cfg(all(not(feature = "send"), not(feature = "luau")))]
-pub(crate) type HookCallback = Arc<dyn Fn(&Lua, Debug) -> Result<()>>;
+pub(crate) type HookCallback = Rc<dyn Fn(&Lua, Debug) -> Result<()>>;

-#[cfg(all(feature = "luau", feature = "send"))]
-pub(crate) type InterruptCallback = Arc<dyn Fn() -> Result<VmState> + Send>;
+#[cfg(all(feature = "send", feature = "luau"))]
+pub(crate) type InterruptCallback = Rc<dyn Fn(&Lua) -> Result<VmState> + Send>;

-#[cfg(all(feature = "luau", not(feature = "send")))]
-pub(crate) type InterruptCallback = Arc<dyn Fn() -> Result<VmState>>;
+#[cfg(all(not(feature = "send"), feature = "luau"))]
+pub(crate) type InterruptCallback = Rc<dyn Fn(&Lua) -> Result<VmState>>;

 #[cfg(all(feature = "send", feature = "lua54"))]
-pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &CStr, bool) -> Result<()> + Send>;
+pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &str, bool) -> Result<()> + Send>;

 #[cfg(all(not(feature = "send"), feature = "lua54"))]
-pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &CStr, bool) -> Result<()>>;
+pub(crate) type WarnCallback = Box<dyn Fn(&Lua, &str, bool) -> Result<()>>;

 #[cfg(feature = "send")]
 pub trait MaybeSend: Send {}
@@ -84,46 +101,132 @@ pub trait MaybeSend {}
 #[cfg(not(feature = "send"))]
 impl<T> MaybeSend for T {}

+/// A Luau vector type.
+///
+/// By default vectors are 3-dimensional, but can be 4-dimensional
+/// if the `luau-vector4` feature is enabled.
+#[cfg(any(feature = "luau", doc))]
+#[cfg_attr(docsrs, doc(cfg(feature = "luau")))]
+#[derive(Debug, Default, Clone, Copy, PartialEq)]
+pub struct Vector(pub(crate) [f32; Self::SIZE]);
+
+#[cfg(any(feature = "luau", doc))]
+impl fmt::Display for Vector {
+    #[rustfmt::skip]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        #[cfg(not(feature = "luau-vector4"))]
+        return write!(f, "vector({}, {}, {})", self.x(), self.y(), self.z());
+        #[cfg(feature = "luau-vector4")]
+        return write!(f, "vector({}, {}, {}, {})", self.x(), self.y(), self.z(), self.w());
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl Vector {
+    pub(crate) const SIZE: usize = if cfg!(feature = "luau-vector4") { 4 } else { 3 };
+
+    /// Creates a new vector.
+    #[cfg(not(feature = "luau-vector4"))]
+    pub const fn new(x: f32, y: f32, z: f32) -> Self {
+        Self([x, y, z])
+    }
+
+    /// Creates a new vector.
+    #[cfg(feature = "luau-vector4")]
+    pub const fn new(x: f32, y: f32, z: f32, w: f32) -> Self {
+        Self([x, y, z, w])
+    }
+
+    /// Creates a new vector with all components set to `0.0`.
+    #[doc(hidden)]
+    pub const fn zero() -> Self {
+        Self([0.0; Self::SIZE])
+    }
+
+    /// Returns 1st component of the vector.
+    pub const fn x(&self) -> f32 {
+        self.0[0]
+    }
+
+    /// Returns 2nd component of the vector.
+    pub const fn y(&self) -> f32 {
+        self.0[1]
+    }
+
+    /// Returns 3rd component of the vector.
+    pub const fn z(&self) -> f32 {
+        self.0[2]
+    }
+
+    /// Returns 4th component of the vector.
+    #[cfg(any(feature = "luau-vector4", doc))]
+    #[cfg_attr(docsrs, doc(cfg(feature = "luau-vector4")))]
+    pub const fn w(&self) -> f32 {
+        self.0[3]
+    }
+}
+
+#[cfg(all(feature = "luau", feature = "serialize"))]
+impl Serialize for Vector {
+    fn serialize<S: Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
+        let mut ts = serializer.serialize_tuple_struct("Vector", Self::SIZE)?;
+        ts.serialize_field(&self.x())?;
+        ts.serialize_field(&self.y())?;
+        ts.serialize_field(&self.z())?;
+        #[cfg(feature = "luau-vector4")]
+        ts.serialize_field(&self.w())?;
+        ts.end()
+    }
+}
+
+#[cfg(any(feature = "luau", doc))]
+impl PartialEq<[f32; Self::SIZE]> for Vector {
+    #[inline]
+    fn eq(&self, other: &[f32; Self::SIZE]) -> bool {
+        self.0 == *other
+    }
+}
+
 pub(crate) struct DestructedUserdata;

 /// 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`].
+/// 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
 /// 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
-/// [`AnyUserData::set_user_value`] / [`AnyUserData::get_user_value`].
+/// [`AnyUserData::set_user_value`] / [`AnyUserData::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
+/// [`AnyUserData::user_value`]: crate::AnyUserData::user_value
 pub struct RegistryKey {
-    pub(crate) registry_id: c_int,
-    pub(crate) is_nil: AtomicBool,
+    pub(crate) registry_id: i32,
    pub(crate) unref_list: Arc<Mutex<Option<Vec<c_int>>>>,
 }

 impl fmt::Debug for RegistryKey {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "RegistryKey({})", self.registry_id)
+        write!(f, "RegistryKey({})", self.id())
    }
 }

 impl Hash for RegistryKey {
    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.registry_id.hash(state)
+        self.id().hash(state)
    }
 }

 impl PartialEq for RegistryKey {
    fn eq(&self, other: &RegistryKey) -> bool {
-        self.registry_id == other.registry_id && Arc::ptr_eq(&self.unref_list, &other.unref_list)
+        self.id() == other.id() && Arc::ptr_eq(&self.unref_list, &other.unref_list)
    }
 }

@@ -131,86 +234,116 @@ impl Eq for RegistryKey {}

 impl Drop for RegistryKey {
    fn drop(&mut self) {
+        let registry_id = self.id();
        // We don't need to collect nil slot
-        if self.registry_id > ffi::LUA_REFNIL {
-            let mut unref_list = mlua_expect!(self.unref_list.lock(), "unref list poisoned");
+        if registry_id > ffi::LUA_REFNIL {
+            let mut unref_list = self.unref_list.lock();
            if let Some(list) = unref_list.as_mut() {
-                list.push(self.registry_id);
+                list.push(registry_id);
            }
        }
    }
 }

 impl RegistryKey {
-    // Creates a new instance of `RegistryKey`
+    /// Creates a new instance of `RegistryKey`
    pub(crate) const fn new(id: c_int, unref_list: Arc<Mutex<Option<Vec<c_int>>>>) -> Self {
        RegistryKey {
            registry_id: id,
-            is_nil: AtomicBool::new(id == ffi::LUA_REFNIL),
            unref_list,
        }
    }

-    // Destroys the `RegistryKey` without adding to the unref list
-    pub(crate) fn take(self) -> c_int {
-        let registry_id = self.registry_id;
+    /// Returns the underlying Lua reference of this `RegistryKey`
+    #[inline(always)]
+    pub fn id(&self) -> c_int {
+        self.registry_id
+    }
+
+    /// Sets the unique Lua reference key of this `RegistryKey`
+    #[inline(always)]
+    pub(crate) fn set_id(&mut self, id: c_int) {
+        self.registry_id = id;
+    }
+
+    /// Destroys the `RegistryKey` without adding to the unref list
+    pub(crate) fn take(self) -> i32 {
+        let registry_id = self.id();
        unsafe {
            ptr::read(&self.unref_list);
            mem::forget(self);
        }
        registry_id
    }
-
-    // Returns true if this `RegistryKey` holds a nil value
-    #[inline(always)]
-    pub(crate) fn is_nil(&self) -> bool {
-        self.is_nil.load(Ordering::Relaxed)
-    }
-
-    // Marks value of this `RegistryKey` as `Nil`
-    #[inline(always)]
-    pub(crate) fn set_nil(&self, enabled: bool) {
-        // We cannot replace previous value with nil in as this will break
-        // Lua mechanism to find free keys.
-        // Instead, we set a special flag to mark value as nil.
-        self.is_nil.store(enabled, Ordering::Relaxed);
-    }
 }

-pub(crate) struct LuaRef<'lua> {
-    pub(crate) lua: &'lua Lua,
+pub(crate) struct ValueRef {
+    pub(crate) lua: WeakLua,
    pub(crate) index: c_int,
+    pub(crate) drop: bool,
 }

-impl<'lua> fmt::Debug for LuaRef<'lua> {
+impl ValueRef {
+    #[inline]
+    pub(crate) fn new(lua: &RawLua, index: c_int) -> Self {
+        ValueRef {
+            lua: lua.weak().clone(),
+            index,
+            drop: true,
+        }
+    }
+
+    #[inline]
+    pub(crate) fn to_pointer(&self) -> *const c_void {
+        let lua = self.lua.lock();
+        unsafe { ffi::lua_topointer(lua.ref_thread(), self.index) }
+    }
+}
+
+impl fmt::Debug for ValueRef {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Ref({})", self.index)
+        write!(f, "Ref({:p})", self.to_pointer())
    }
 }

-impl<'lua> Clone for LuaRef<'lua> {
+impl Clone for ValueRef {
    fn clone(&self) -> Self {
-        self.lua.clone_ref(self)
+        unsafe { self.lua.lock().clone_ref(self) }
    }
 }

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

-impl<'lua> PartialEq for LuaRef<'lua> {
+impl PartialEq for ValueRef {
    fn eq(&self, other: &Self) -> bool {
-        let lua = self.lua;
-        unsafe {
-            let _sg = StackGuard::new(lua.state);
-            assert_stack(lua.state, 2);
-            lua.push_ref(self);
-            lua.push_ref(other);
-            ffi::lua_rawequal(lua.state, -1, -2) == 1
-        }
+        assert!(
+            self.lua == other.lua,
+            "Lua instance passed Value created from a different main Lua state"
+        );
+        let lua = self.lua.lock();
+        unsafe { ffi::lua_rawequal(lua.ref_thread(), self.index, other.index) == 1 }
    }
 }
+
+mod app_data;
+mod sync;
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    static_assertions::assert_impl_all!(RegistryKey: Send, Sync);
+
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_any!(ValueRef: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(ValueRef: Send, Sync);
+}
@@ -0,0 +1,176 @@
+use std::any::{Any, TypeId};
+use std::cell::{Cell, Ref, RefCell, RefMut, UnsafeCell};
+use std::fmt;
+use std::ops::{Deref, DerefMut};
+use std::result::Result as StdResult;
+
+use rustc_hash::FxHashMap;
+
+use super::MaybeSend;
+use crate::state::LuaGuard;
+
+#[cfg(not(feature = "send"))]
+type Container = UnsafeCell<FxHashMap<TypeId, RefCell<Box<dyn Any>>>>;
+
+#[cfg(feature = "send")]
+type Container = UnsafeCell<FxHashMap<TypeId, RefCell<Box<dyn Any + Send>>>>;
+
+/// A container for arbitrary data associated with the Lua state.
+#[derive(Debug, Default)]
+pub struct AppData {
+    container: Container,
+    borrow: Cell<usize>,
+}
+
+impl AppData {
+    #[track_caller]
+    pub(crate) fn insert<T: MaybeSend + 'static>(&self, data: T) -> Option<T> {
+        match self.try_insert(data) {
+            Ok(data) => data,
+            Err(_) => panic!("cannot mutably borrow app data container"),
+        }
+    }
+
+    pub(crate) fn try_insert<T: MaybeSend + 'static>(&self, data: T) -> StdResult<Option<T>, T> {
+        if self.borrow.get() != 0 {
+            return Err(data);
+        }
+        // SAFETY: we checked that there are no other references to the container
+        Ok(unsafe { &mut *self.container.get() }
+            .insert(TypeId::of::<T>(), RefCell::new(Box::new(data)))
+            .and_then(|data| data.into_inner().downcast::<T>().ok().map(|data| *data)))
+    }
+
+    #[track_caller]
+    pub(crate) fn borrow<T: 'static>(&self, guard: Option<LuaGuard>) -> Option<AppDataRef<T>> {
+        let data = unsafe { &*self.container.get() }
+            .get(&TypeId::of::<T>())?
+            .borrow();
+        self.borrow.set(self.borrow.get() + 1);
+        Some(AppDataRef {
+            data: Ref::filter_map(data, |data| data.downcast_ref()).ok()?,
+            borrow: &self.borrow,
+            _guard: guard,
+        })
+    }
+
+    #[track_caller]
+    pub(crate) fn borrow_mut<T: 'static>(&self, guard: Option<LuaGuard>) -> Option<AppDataRefMut<T>> {
+        let data = unsafe { &*self.container.get() }
+            .get(&TypeId::of::<T>())?
+            .borrow_mut();
+        self.borrow.set(self.borrow.get() + 1);
+        Some(AppDataRefMut {
+            data: RefMut::filter_map(data, |data| data.downcast_mut()).ok()?,
+            borrow: &self.borrow,
+            _guard: guard,
+        })
+    }
+
+    #[track_caller]
+    pub(crate) fn remove<T: 'static>(&self) -> Option<T> {
+        if self.borrow.get() != 0 {
+            panic!("cannot mutably borrow app data container");
+        }
+        // SAFETY: we checked that there are no other references to the container
+        unsafe { &mut *self.container.get() }
+            .remove(&TypeId::of::<T>())?
+            .into_inner()
+            .downcast::<T>()
+            .ok()
+            .map(|data| *data)
+    }
+}
+
+/// A wrapper type for an immutably borrowed value from an app data container.
+///
+/// This type is similar to [`Ref`].
+pub struct AppDataRef<'a, T: ?Sized + 'a> {
+    data: Ref<'a, T>,
+    borrow: &'a Cell<usize>,
+    _guard: Option<LuaGuard>,
+}
+
+impl<T: ?Sized> Drop for AppDataRef<'_, T> {
+    fn drop(&mut self) {
+        self.borrow.set(self.borrow.get() - 1);
+    }
+}
+
+impl<T: ?Sized> Deref for AppDataRef<'_, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
+impl<T: ?Sized + fmt::Display> fmt::Display for AppDataRef<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T: ?Sized + fmt::Debug> fmt::Debug for AppDataRef<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+/// A wrapper type for a mutably borrowed value from an app data container.
+///
+/// This type is similar to [`RefMut`].
+pub struct AppDataRefMut<'a, T: ?Sized + 'a> {
+    data: RefMut<'a, T>,
+    borrow: &'a Cell<usize>,
+    _guard: Option<LuaGuard>,
+}
+
+impl<T: ?Sized> Drop for AppDataRefMut<'_, T> {
+    fn drop(&mut self) {
+        self.borrow.set(self.borrow.get() - 1);
+    }
+}
+
+impl<T: ?Sized> Deref for AppDataRefMut<'_, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
+impl<T: ?Sized> DerefMut for AppDataRefMut<'_, T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.data
+    }
+}
+
+impl<T: ?Sized + fmt::Display> fmt::Display for AppDataRefMut<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T: ?Sized + fmt::Debug> fmt::Debug for AppDataRefMut<'_, T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    #[cfg(not(feature = "send"))]
+    static_assertions::assert_not_impl_any!(AppData: Send);
+    #[cfg(feature = "send")]
+    static_assertions::assert_impl_all!(AppData: Send);
+
+    // Must be !Send
+    static_assertions::assert_not_impl_any!(AppDataRef<()>: Send);
+    static_assertions::assert_not_impl_any!(AppDataRefMut<()>: Send);
+}
@@ -0,0 +1,77 @@
+#[cfg(feature = "send")]
+mod inner {
+    use parking_lot::{RawMutex, RawThreadId};
+    use std::sync::{Arc, Weak};
+
+    pub(crate) type XRc<T> = Arc<T>;
+    pub(crate) type XWeak<T> = Weak<T>;
+
+    pub(crate) type ReentrantMutex<T> = parking_lot::ReentrantMutex<T>;
+
+    pub(crate) type ReentrantMutexGuard<'a, T> = parking_lot::ReentrantMutexGuard<'a, T>;
+
+    pub(crate) type ArcReentrantMutexGuard<T> =
+        parking_lot::lock_api::ArcReentrantMutexGuard<RawMutex, RawThreadId, T>;
+}
+
+#[cfg(not(feature = "send"))]
+mod inner {
+    use std::ops::Deref;
+    use std::rc::{Rc, Weak};
+
+    pub(crate) type XRc<T> = Rc<T>;
+    pub(crate) type XWeak<T> = Weak<T>;
+
+    pub(crate) struct ReentrantMutex<T>(T);
+
+    impl<T> ReentrantMutex<T> {
+        #[inline(always)]
+        pub(crate) fn new(val: T) -> Self {
+            ReentrantMutex(val)
+        }
+
+        #[inline(always)]
+        pub(crate) fn lock(&self) -> ReentrantMutexGuard<T> {
+            ReentrantMutexGuard(&self.0)
+        }
+
+        #[inline(always)]
+        pub(crate) fn lock_arc(self: &XRc<Self>) -> ArcReentrantMutexGuard<T> {
+            ArcReentrantMutexGuard(Rc::clone(self))
+        }
+
+        #[inline(always)]
+        pub(crate) fn into_lock_arc(self: XRc<Self>) -> ArcReentrantMutexGuard<T> {
+            ArcReentrantMutexGuard(self)
+        }
+
+        #[inline(always)]
+        pub(crate) fn data_ptr(&self) -> *const T {
+            &self.0 as *const _
+        }
+    }
+
+    pub(crate) struct ReentrantMutexGuard<'a, T>(&'a T);
+
+    impl<'a, T> Deref for ReentrantMutexGuard<'a, T> {
+        type Target = T;
+
+        #[inline(always)]
+        fn deref(&self) -> &Self::Target {
+            self.0
+        }
+    }
+
+    pub(crate) struct ArcReentrantMutexGuard<T>(XRc<ReentrantMutex<T>>);
+
+    impl<T> Deref for ArcReentrantMutexGuard<T> {
+        type Target = T;
+
+        #[inline(always)]
+        fn deref(&self) -> &Self::Target {
+            &self.0 .0
+        }
+    }
+}
+
+pub(crate) use inner::{ArcReentrantMutexGuard, ReentrantMutex, ReentrantMutexGuard, XRc, XWeak};
@@ -0,0 +1,422 @@
+use std::any::{type_name, TypeId};
+use std::cell::{Cell, UnsafeCell};
+use std::fmt;
+use std::ops::{Deref, DerefMut};
+use std::os::raw::c_int;
+use std::rc::Rc;
+
+#[cfg(feature = "serialize")]
+use serde::ser::{Serialize, Serializer};
+
+use crate::error::{Error, Result};
+use crate::state::{Lua, LuaGuard, RawLua};
+use crate::userdata::AnyUserData;
+use crate::util::get_userdata;
+use crate::value::{FromLua, Value};
+
+// A enum for storing userdata values.
+// It's stored inside a Lua VM and protected by the outer `ReentrantMutex`.
+pub(crate) enum UserDataVariant<T> {
+    Default(Rc<InnerRefCell<T>>),
+    #[cfg(feature = "serialize")]
+    Serializable(Rc<InnerRefCell<Box<dyn erased_serde::Serialize>>>),
+}
+
+impl<T> Clone for UserDataVariant<T> {
+    #[inline]
+    fn clone(&self) -> Self {
+        match self {
+            Self::Default(inner) => Self::Default(Rc::clone(inner)),
+            #[cfg(feature = "serialize")]
+            Self::Serializable(inner) => UserDataVariant::Serializable(Rc::clone(inner)),
+        }
+    }
+}
+
+impl<T> UserDataVariant<T> {
+    #[inline(always)]
+    pub(crate) fn new(data: T) -> Self {
+        Self::Default(Rc::new(InnerRefCell::new(data)))
+    }
+
+    // Immutably borrows the wrapped value in-place.
+    #[inline(always)]
+    pub(crate) unsafe fn try_borrow(&self) -> Result<UserDataBorrowRef<T>> {
+        UserDataBorrowRef::try_from(self)
+    }
+
+    // Immutably borrows the wrapped value and returns an owned reference.
+    #[inline(always)]
+    pub(crate) fn try_make_ref(&self, guard: LuaGuard) -> Result<UserDataRef<T>> {
+        UserDataRef::try_from(self.clone(), guard)
+    }
+
+    // Mutably borrows the wrapped value in-place.
+    #[inline(always)]
+    pub(crate) unsafe fn try_borrow_mut(&self) -> Result<UserDataBorrowMut<T>> {
+        UserDataBorrowMut::try_from(self)
+    }
+
+    // Mutably borrows the wrapped value and returns an owned reference.
+    #[inline(always)]
+    pub(crate) fn try_make_mut_ref(&self, guard: LuaGuard) -> Result<UserDataRefMut<T>> {
+        UserDataRefMut::try_from(self.clone(), guard)
+    }
+
+    // Returns the wrapped value.
+    //
+    // This method checks that we have exclusive access to the value.
+    pub(crate) fn into_inner(self) -> Result<T> {
+        set_writing(self.flag())?;
+        Ok(match self {
+            Self::Default(inner) => Rc::into_inner(inner).unwrap().value.into_inner(),
+            #[cfg(feature = "serialize")]
+            Self::Serializable(inner) => unsafe {
+                let raw = Box::into_raw(Rc::into_inner(inner).unwrap().value.into_inner());
+                *Box::from_raw(raw as *mut T)
+            },
+        })
+    }
+
+    #[inline(always)]
+    fn flag(&self) -> &Cell<BorrowFlag> {
+        match self {
+            Self::Default(inner) => &inner.borrow,
+            #[cfg(feature = "serialize")]
+            Self::Serializable(inner) => &inner.borrow,
+        }
+    }
+
+    #[inline(always)]
+    fn as_ptr(&self) -> *mut T {
+        match self {
+            Self::Default(inner) => inner.value.get(),
+            #[cfg(feature = "serialize")]
+            Self::Serializable(inner) => unsafe { &mut **(inner.value.get() as *mut Box<T>) },
+        }
+    }
+}
+
+#[cfg(feature = "serialize")]
+impl<T: Serialize + 'static> UserDataVariant<T> {
+    #[inline(always)]
+    pub(crate) fn new_ser(data: T) -> Self {
+        let data = Box::new(data) as Box<dyn erased_serde::Serialize>;
+        Self::Serializable(Rc::new(InnerRefCell::new(data)))
+    }
+}
+
+#[cfg(feature = "serialize")]
+impl Serialize for UserDataVariant<()> {
+    fn serialize<S: Serializer>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error> {
+        match self {
+            UserDataVariant::Default(_) => Err(serde::ser::Error::custom("cannot serialize <userdata>")),
+            UserDataVariant::Serializable(inner) => unsafe {
+                let _ = self.try_borrow().map_err(serde::ser::Error::custom)?;
+                (*inner.value.get()).serialize(serializer)
+            },
+        }
+    }
+}
+
+//
+// Inspired by `std::cell::RefCell`` implementation
+//
+
+pub(crate) struct InnerRefCell<T> {
+    borrow: Cell<BorrowFlag>,
+    value: UnsafeCell<T>,
+}
+
+impl<T> InnerRefCell<T> {
+    #[inline(always)]
+    pub fn new(value: T) -> Self {
+        InnerRefCell {
+            borrow: Cell::new(UNUSED),
+            value: UnsafeCell::new(value),
+        }
+    }
+}
+
+/// A wrapper type for a [`UserData`] value that provides read access.
+///
+/// It implements [`FromLua`] and can be used to receive a typed userdata from Lua.
+pub struct UserDataRef<T> {
+    variant: UserDataVariant<T>,
+    #[allow(unused)]
+    guard: LuaGuard,
+}
+
+impl<T> Deref for UserDataRef<T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &T {
+        unsafe { &*self.variant.as_ptr() }
+    }
+}
+
+impl<T> Drop for UserDataRef<T> {
+    #[inline]
+    fn drop(&mut self) {
+        unset_reading(self.variant.flag());
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for UserDataRef<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T: fmt::Display> fmt::Display for UserDataRef<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T> UserDataRef<T> {
+    #[inline]
+    fn try_from(variant: UserDataVariant<T>, guard: LuaGuard) -> Result<Self> {
+        set_reading(variant.flag())?;
+        Ok(UserDataRef { variant, guard })
+    }
+}
+
+impl<T: 'static> FromLua for UserDataRef<T> {
+    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
+        try_value_to_userdata::<T>(value)?.borrow()
+    }
+
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
+        let type_id = lua.get_userdata_type_id(idx)?;
+        match type_id {
+            Some(type_id) if type_id == TypeId::of::<T>() => {
+                let guard = lua.lua().lock_arc();
+                (*get_userdata::<UserDataVariant<T>>(lua.state(), idx)).try_make_ref(guard)
+            }
+            _ => Err(Error::UserDataTypeMismatch),
+        }
+    }
+}
+
+/// A wrapper type for a mutably borrowed value from a `AnyUserData`.
+///
+/// It implements [`FromLua`] and can be used to receive a typed userdata from Lua.
+pub struct UserDataRefMut<T> {
+    variant: UserDataVariant<T>,
+    #[allow(unused)]
+    guard: LuaGuard,
+}
+
+impl<T> Deref for UserDataRefMut<T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*self.variant.as_ptr() }
+    }
+}
+
+impl<T> DerefMut for UserDataRefMut<T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        unsafe { &mut *self.variant.as_ptr() }
+    }
+}
+
+impl<T> Drop for UserDataRefMut<T> {
+    #[inline]
+    fn drop(&mut self) {
+        unset_writing(self.variant.flag());
+    }
+}
+
+impl<T: fmt::Debug> fmt::Debug for UserDataRefMut<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T: fmt::Display> fmt::Display for UserDataRefMut<T> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        (**self).fmt(f)
+    }
+}
+
+impl<T> UserDataRefMut<T> {
+    fn try_from(variant: UserDataVariant<T>, guard: LuaGuard) -> Result<Self> {
+        // There must currently be no existing references
+        set_writing(variant.flag())?;
+        Ok(UserDataRefMut { variant, guard })
+    }
+}
+
+impl<T: 'static> FromLua for UserDataRefMut<T> {
+    fn from_lua(value: Value, _: &Lua) -> Result<Self> {
+        try_value_to_userdata::<T>(value)?.borrow_mut()
+    }
+
+    unsafe fn from_stack(idx: c_int, lua: &RawLua) -> Result<Self> {
+        let type_id = lua.get_userdata_type_id(idx)?;
+        match type_id {
+            Some(type_id) if type_id == TypeId::of::<T>() => {
+                let guard = lua.lua().lock_arc();
+                (*get_userdata::<UserDataVariant<T>>(lua.state(), idx)).try_make_mut_ref(guard)
+            }
+            _ => Err(Error::UserDataTypeMismatch),
+        }
+    }
+}
+
+// Positive values represent the number of `Ref` active. Negative values
+// represent the number of `RefMut` active. Multiple `RefMut`s can only be
+// active at a time if they refer to distinct, nonoverlapping components of a
+// `RefCell` (e.g., different ranges of a slice).
+type BorrowFlag = isize;
+const UNUSED: BorrowFlag = 0;
+
+#[inline(always)]
+fn is_writing(x: BorrowFlag) -> bool {
+    x < UNUSED
+}
+
+#[inline(always)]
+fn is_reading(x: BorrowFlag) -> bool {
+    x > UNUSED
+}
+
+#[inline(always)]
+fn set_writing(borrow: &Cell<BorrowFlag>) -> Result<()> {
+    let flag = borrow.get();
+    if flag != UNUSED {
+        return Err(Error::UserDataBorrowMutError);
+    }
+    borrow.set(UNUSED - 1);
+    Ok(())
+}
+
+#[inline(always)]
+fn set_reading(borrow: &Cell<BorrowFlag>) -> Result<()> {
+    let flag = borrow.get().wrapping_add(1);
+    if !is_reading(flag) {
+        return Err(Error::UserDataBorrowError);
+    }
+    borrow.set(flag);
+    Ok(())
+}
+
+#[inline(always)]
+#[track_caller]
+fn unset_writing(borrow: &Cell<BorrowFlag>) {
+    let flag = borrow.get();
+    debug_assert!(is_writing(flag));
+    borrow.set(flag + 1);
+}
+
+#[inline(always)]
+#[track_caller]
+fn unset_reading(borrow: &Cell<BorrowFlag>) {
+    let flag = borrow.get();
+    debug_assert!(is_reading(flag));
+    borrow.set(flag - 1);
+}
+
+pub(crate) struct UserDataBorrowRef<'a, T>(&'a UserDataVariant<T>);
+
+impl<'a, T> Drop for UserDataBorrowRef<'a, T> {
+    #[inline]
+    fn drop(&mut self) {
+        unset_reading(self.0.flag());
+    }
+}
+
+impl<'a, T> Deref for UserDataBorrowRef<'a, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &T {
+        unsafe { &*self.0.as_ptr() }
+    }
+}
+
+impl<'a, T> TryFrom<&'a UserDataVariant<T>> for UserDataBorrowRef<'a, T> {
+    type Error = Error;
+
+    #[inline(always)]
+    fn try_from(variant: &'a UserDataVariant<T>) -> Result<Self> {
+        set_reading(variant.flag())?;
+        Ok(UserDataBorrowRef(variant))
+    }
+}
+
+impl<'a, T> UserDataBorrowRef<'a, T> {
+    #[inline(always)]
+    pub(crate) fn get_ref(&self) -> &'a T {
+        // SAFETY: `UserDataBorrowRef` is only created when the borrow flag is set to reading.
+        unsafe { &*self.0.as_ptr() }
+    }
+}
+
+pub(crate) struct UserDataBorrowMut<'a, T>(&'a UserDataVariant<T>);
+
+impl<'a, T> Drop for UserDataBorrowMut<'a, T> {
+    #[inline]
+    fn drop(&mut self) {
+        unset_writing(self.0.flag());
+    }
+}
+
+impl<'a, T> Deref for UserDataBorrowMut<'a, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &T {
+        unsafe { &*self.0.as_ptr() }
+    }
+}
+
+impl<'a, T> DerefMut for UserDataBorrowMut<'a, T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { &mut *self.0.as_ptr() }
+    }
+}
+
+impl<'a, T> TryFrom<&'a UserDataVariant<T>> for UserDataBorrowMut<'a, T> {
+    type Error = Error;
+
+    #[inline(always)]
+    fn try_from(variant: &'a UserDataVariant<T>) -> Result<Self> {
+        set_writing(variant.flag())?;
+        Ok(UserDataBorrowMut(variant))
+    }
+}
+
+impl<'a, T> UserDataBorrowMut<'a, T> {
+    #[inline(always)]
+    pub(crate) fn get_mut(&mut self) -> &'a mut T {
+        // SAFETY: `UserDataBorrowMut` is only created when the borrow flag is set to writing.
+        unsafe { &mut *self.0.as_ptr() }
+    }
+}
+
+#[inline]
+fn try_value_to_userdata<T>(value: Value) -> Result<AnyUserData> {
+    match value {
+        Value::UserData(ud) => Ok(ud),
+        _ => Err(Error::FromLuaConversionError {
+            from: value.type_name(),
+            to: "userdata",
+            message: Some(format!("expected userdata of type {}", type_name::<T>())),
+        }),
+    }
+}
+
+#[cfg(test)]
+mod assertions {
+    use super::*;
+
+    static_assertions::assert_not_impl_all!(UserDataRef<()>: Sync, Send);
+    static_assertions::assert_not_impl_all!(UserDataRefMut<()>: Sync, Send);
+}
@@ -0,0 +1,180 @@
+use crate::error::{Error, Result};
+use crate::private::Sealed;
+use crate::userdata::{AnyUserData, MetaMethod};
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Value};
+
+#[cfg(feature = "async")]
+use std::future::Future;
+
+/// An extension trait for [`AnyUserData`] that provides a variety of convenient functionality.
+pub trait AnyUserDataExt: Sealed {
+    /// Gets the value associated to `key` from the userdata, assuming it has `__index` metamethod.
+    fn get<K: IntoLua, V: FromLua>(&self, key: K) -> Result<V>;
+
+    /// Sets the value associated to `key` in the userdata, assuming it has `__newindex` metamethod.
+    fn set<K: IntoLua, V: IntoLua>(&self, key: K, value: V) -> Result<()>;
+
+    /// Calls the userdata as a function assuming it has `__call` metamethod.
+    ///
+    /// The metamethod is called with the userdata as its first argument, followed by the passed
+    /// arguments.
+    fn call<A, R>(&self, args: A) -> Result<R>
+    where
+        A: IntoLuaMulti,
+        R: FromLuaMulti;
+
+    /// Asynchronously calls the userdata as a function assuming it has `__call` metamethod.
+    ///
+    /// The metamethod is called with the userdata as its first argument, followed by the passed
+    /// arguments.
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    fn call_async<A, R>(&self, args: A) -> impl Future<Output = Result<R>>
+    where
+        A: IntoLuaMulti,
+        R: FromLuaMulti;
+
+    /// Calls the userdata method, assuming it has `__index` metamethod
+    /// and a function associated to `name`.
+    fn call_method<A, R>(&self, name: &str, args: A) -> Result<R>
+    where
+        A: IntoLuaMulti,
+        R: FromLuaMulti;
+
+    /// Gets the function associated to `key` from the table and asynchronously executes it,
+    /// passing the table itself along with `args` as function arguments and returning Future.
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// This might invoke the `__index` metamethod.
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    fn call_async_method<A, R>(&self, name: &str, args: A) -> impl Future<Output = Result<R>>
+    where
+        A: IntoLuaMulti,
+        R: FromLuaMulti;
+
+    /// Gets the function associated to `key` from the table and executes it,
+    /// passing `args` as function arguments.
+    ///
+    /// This is a shortcut for
+    /// `table.get::<_, Function>(key)?.call(args)`
+    ///
+    /// This might invoke the `__index` metamethod.
+    fn call_function<A, R>(&self, name: &str, args: A) -> Result<R>
+    where
+        A: IntoLuaMulti,
+        R: FromLuaMulti;
+
+    /// Gets the function associated to `key` from the table and asynchronously executes it,
+    /// passing `args` as function arguments and returning Future.
+    ///
+    /// Requires `feature = "async"`
+    ///
+    /// This might invoke the `__index` metamethod.
+    #[cfg(feature = "async")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
+    fn call_async_function<A, R>(&self, name: &str, args: A) -> impl Future<Output = Result<R>>
+    where
+        A: IntoLuaMulti,
+        R: FromLuaMulti;
+}
+
+impl AnyUserDataExt for AnyUserData {
+    fn get<K: IntoLua, V: FromLua>(&self, key: K) -> Result<V> {
+        let metatable = self.get_metatable()?;
+        match metatable.get::<Value>(MetaMethod::Index)? {
+            Value::Table(table) => table.raw_get(key),
+            Value::Function(func) => func.call((self, key)),
+            _ => Err(Error::runtime("attempt to index a userdata value")),
+        }
+    }
+
+    fn set<K: IntoLua, V: IntoLua>(&self, key: K, value: V) -> Result<()> {
+        let metatable = self.get_metatable()?;
+        match metatable.get::<Value>(MetaMethod::NewIndex)? {
+            Value::Table(table) => table.raw_set(key, value),
+            Value::Function(func) => func.call((self, key, value)),
+            _ => Err(Error::runtime("attempt to index a userdata value")),
+        }
+    }
+
+    fn call<A, R>(&self, args: A) -> Result<R>
+    where
+        A: IntoLuaMulti,
+        R: FromLuaMulti,
+    {
+        let metatable = self.get_metatable()?;
+        match metatable.get::<Value>(MetaMethod::Call)? {
+            Value::Function(func) => func.call((self, args)),
+            _ => Err(Error::runtime("attempt to call a userdata value")),
+        }
+    }
+
+    #[cfg(feature = "async")]
+    fn call_async<A, R>(&self, args: A) -> impl Future<Output = Result<R>>
+    where
+        A: IntoLuaMulti,
+        R: FromLuaMulti,
+    {
+        let lua = self.0.lua.lock();
+        let args = (self, args).into_lua_multi(lua.lua());
+        async move {
+            let metatable = self.get_metatable()?;
+            match metatable.get::<Value>(MetaMethod::Call)? {
+                Value::Function(func) => func.call_async(args?).await,
+                _ => Err(Error::runtime("attempt to call a userdata value")),
+            }
+        }
+    }
+
+    fn call_method<A, R>(&self, name: &str, args: A) -> Result<R>
+    where
+        A: IntoLuaMulti,
+        R: FromLuaMulti,
+    {
+        self.call_function(name, (self, args))
+    }
+
+    #[cfg(feature = "async")]
+    fn call_async_method<A, R>(&self, name: &str, args: A) -> impl Future<Output = Result<R>>
+    where
+        A: IntoLuaMulti,
+        R: FromLuaMulti,
+    {
+        self.call_async_function(name, (self, args))
+    }
+
+    fn call_function<A, R>(&self, name: &str, args: A) -> Result<R>
+    where
+        A: IntoLuaMulti,
+        R: FromLuaMulti,
+    {
+        match self.get(name)? {
+            Value::Function(func) => func.call(args),
+            val => {
+                let msg = format!("attempt to call a {} value", val.type_name());
+                Err(Error::runtime(msg))
+            }
+        }
+    }
+
+    #[cfg(feature = "async")]
+    fn call_async_function<A, R>(&self, name: &str, args: A) -> impl Future<Output = Result<R>>
+    where
+        A: IntoLuaMulti,
+        R: FromLuaMulti,
+    {
+        let lua = self.0.lua.lock();
+        let args = args.into_lua_multi(lua.lua());
+        async move {
+            match self.get::<_, Value>(name)? {
+                Value::Function(func) => func.call_async(args?).await,
+                val => {
+                    let msg = format!("attempt to call a {} value", val.type_name());
+                    Err(Error::runtime(msg))
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,591 @@
+#![allow(clippy::await_holding_refcell_ref, clippy::await_holding_lock)]
+
+use std::any::TypeId;
+use std::cell::RefCell;
+use std::marker::PhantomData;
+use std::os::raw::c_int;
+use std::string::String as StdString;
+
+use crate::error::{Error, Result};
+use crate::state::Lua;
+use crate::types::{Callback, MaybeSend};
+use crate::userdata::{AnyUserData, MetaMethod, UserData, UserDataFields, UserDataMethods};
+use crate::util::{get_userdata, short_type_name};
+use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, Value};
+
+use super::cell::{UserDataBorrowMut, UserDataBorrowRef, UserDataVariant};
+
+#[cfg(feature = "async")]
+use {
+    crate::types::AsyncCallback,
+    std::future::{self, Future},
+};
+
+/// Handle to registry for userdata methods and metamethods.
+pub struct UserDataRegistry<'a, T: 'static> {
+    // Fields
+    pub(crate) fields: Vec<(String, Callback<'a>)>,
+    pub(crate) field_getters: Vec<(String, Callback<'a>)>,
+    pub(crate) field_setters: Vec<(String, Callback<'a>)>,
+    pub(crate) meta_fields: Vec<(String, Callback<'a>)>,
+
+    // Methods
+    pub(crate) methods: Vec<(String, Callback<'a>)>,
+    #[cfg(feature = "async")]
+    pub(crate) async_methods: Vec<(String, AsyncCallback<'a>)>,
+    pub(crate) meta_methods: Vec<(String, Callback<'a>)>,
+    #[cfg(feature = "async")]
+    pub(crate) async_meta_methods: Vec<(String, AsyncCallback<'a>)>,
+
+    _type: PhantomData<T>,
+}
+
+impl<'a, T: 'static> UserDataRegistry<'a, T> {
+    pub(crate) const fn new() -> Self {
+        UserDataRegistry {
+            fields: Vec::new(),
+            field_getters: Vec::new(),
+            field_setters: Vec::new(),
+            meta_fields: Vec::new(),
+            methods: Vec::new(),
+            #[cfg(feature = "async")]
+            async_methods: Vec::new(),
+            meta_methods: Vec::new(),
+            #[cfg(feature = "async")]
+            async_meta_methods: Vec::new(),
+            _type: PhantomData,
+        }
+    }
+
+    fn box_method<M, A, R>(name: &str, method: M) -> Callback<'a>
+    where
+        M: Fn(&'a Lua, &T, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = get_function_name::<T>(name);
+        macro_rules! try_self_arg {
+            ($res:expr) => {
+                $res.map_err(|err| Error::bad_self_argument(&name, err))?
+            };
+        }
+
+        Box::new(move |rawlua, nargs| unsafe {
+            if nargs == 0 {
+                let err = Error::from_lua_conversion("missing argument", "userdata", None);
+                try_self_arg!(Err(err));
+            }
+            let state = rawlua.state();
+            // Find absolute "self" index before processing args
+            let index = ffi::lua_absindex(state, -nargs);
+            // Self was at position 1, so we pass 2 here
+            let args = A::from_stack_args(nargs - 1, 2, Some(&name), rawlua);
+
+            match try_self_arg!(rawlua.get_userdata_type_id(index)) {
+                Some(id) if id == TypeId::of::<T>() => {
+                    let ud = try_self_arg!(borrow_userdata_ref::<T>(state, index));
+                    method(rawlua.lua(), &ud, args?)?.push_into_stack_multi(rawlua)
+                }
+                _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
+            }
+        })
+    }
+
+    fn box_method_mut<M, A, R>(name: &str, method: M) -> Callback<'a>
+    where
+        M: FnMut(&'a Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = get_function_name::<T>(name);
+        macro_rules! try_self_arg {
+            ($res:expr) => {
+                $res.map_err(|err| Error::bad_self_argument(&name, err))?
+            };
+        }
+
+        let method = RefCell::new(method);
+        Box::new(move |rawlua, nargs| unsafe {
+            let mut method = method.try_borrow_mut().map_err(|_| Error::RecursiveMutCallback)?;
+            if nargs == 0 {
+                let err = Error::from_lua_conversion("missing argument", "userdata", None);
+                try_self_arg!(Err(err));
+            }
+            let state = rawlua.state();
+            // Find absolute "self" index before processing args
+            let index = ffi::lua_absindex(state, -nargs);
+            // Self was at position 1, so we pass 2 here
+            let args = A::from_stack_args(nargs - 1, 2, Some(&name), rawlua);
+
+            match try_self_arg!(rawlua.get_userdata_type_id(index)) {
+                Some(id) if id == TypeId::of::<T>() => {
+                    let mut ud = try_self_arg!(borrow_userdata_mut::<T>(state, index));
+                    method(rawlua.lua(), &mut ud, args?)?.push_into_stack_multi(rawlua)
+                }
+                _ => Err(Error::bad_self_argument(&name, Error::UserDataTypeMismatch)),
+            }
+        })
+    }
+
+    #[cfg(feature = "async")]
+    fn box_async_method<M, A, MR, R>(name: &str, method: M) -> AsyncCallback<'a>
+    where
+        M: Fn(&'a Lua, &'a T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        MR: Future<Output = Result<R>> + 'a,
+        R: IntoLuaMulti,
+    {
+        let name = get_function_name::<T>(name);
+        macro_rules! try_self_arg {
+            ($res:expr) => {
+                match $res {
+                    Ok(res) => res,
+                    Err(err) => return Box::pin(future::ready(Err(Error::bad_self_argument(&name, err)))),
+                }
+            };
+        }
+
+        Box::new(move |rawlua, mut args| unsafe {
+            let this = args
+                .pop_front()
+                .ok_or_else(|| Error::from_lua_conversion("missing argument", "userdata", None));
+            let lua = rawlua.lua();
+            let this = try_self_arg!(AnyUserData::from_lua(try_self_arg!(this), lua));
+            let args = A::from_lua_args(args, 2, Some(&name), lua);
+
+            let (ref_thread, index) = (rawlua.ref_thread(), this.0.index);
+            match try_self_arg!(this.type_id()) {
+                Some(id) if id == TypeId::of::<T>() => {
+                    let ud = try_self_arg!(borrow_userdata_ref::<T>(ref_thread, index));
+                    let args = match args {
+                        Ok(args) => args,
+                        Err(e) => return Box::pin(future::ready(Err(e))),
+                    };
+                    let fut = method(lua, ud.get_ref(), args);
+                    Box::pin(async move { fut.await?.push_into_stack_multi(rawlua) })
+                }
+                _ => {
+                    let err = Error::bad_self_argument(&name, Error::UserDataTypeMismatch);
+                    Box::pin(future::ready(Err(err)))
+                }
+            }
+        })
+    }
+
+    #[cfg(feature = "async")]
+    fn box_async_method_mut<M, A, MR, R>(name: &str, method: M) -> AsyncCallback<'a>
+    where
+        M: Fn(&'a Lua, &'a mut T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        MR: Future<Output = Result<R>> + 'a,
+        R: IntoLuaMulti,
+    {
+        let name = get_function_name::<T>(name);
+        macro_rules! try_self_arg {
+            ($res:expr) => {
+                match $res {
+                    Ok(res) => res,
+                    Err(err) => return Box::pin(future::ready(Err(Error::bad_self_argument(&name, err)))),
+                }
+            };
+        }
+
+        Box::new(move |rawlua, mut args| unsafe {
+            let this = args
+                .pop_front()
+                .ok_or_else(|| Error::from_lua_conversion("missing argument", "userdata", None));
+            let lua = rawlua.lua();
+            let this = try_self_arg!(AnyUserData::from_lua(try_self_arg!(this), lua));
+            let args = A::from_lua_args(args, 2, Some(&name), lua);
+
+            let (ref_thread, index) = (rawlua.ref_thread(), this.0.index);
+            match try_self_arg!(this.type_id()) {
+                Some(id) if id == TypeId::of::<T>() => {
+                    let mut ud = try_self_arg!(borrow_userdata_mut::<T>(ref_thread, index));
+                    let args = match args {
+                        Ok(args) => args,
+                        Err(e) => return Box::pin(future::ready(Err(e))),
+                    };
+                    let fut = method(lua, ud.get_mut(), args);
+                    Box::pin(async move { fut.await?.push_into_stack_multi(rawlua) })
+                }
+                _ => {
+                    let err = Error::bad_self_argument(&name, Error::UserDataTypeMismatch);
+                    Box::pin(future::ready(Err(err)))
+                }
+            }
+        })
+    }
+
+    fn box_function<F, A, R>(name: &str, function: F) -> Callback<'a>
+    where
+        F: Fn(&'a Lua, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = get_function_name::<T>(name);
+        Box::new(move |lua, nargs| unsafe {
+            let args = A::from_stack_args(nargs, 1, Some(&name), lua)?;
+            function(lua.lua(), args)?.push_into_stack_multi(lua)
+        })
+    }
+
+    fn box_function_mut<F, A, R>(name: &str, function: F) -> Callback<'a>
+    where
+        F: FnMut(&'a Lua, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = get_function_name::<T>(name);
+        let function = RefCell::new(function);
+        Box::new(move |lua, nargs| unsafe {
+            let function = &mut *function
+                .try_borrow_mut()
+                .map_err(|_| Error::RecursiveMutCallback)?;
+            let args = A::from_stack_args(nargs, 1, Some(&name), lua)?;
+            function(lua.lua(), args)?.push_into_stack_multi(lua)
+        })
+    }
+
+    #[cfg(feature = "async")]
+    fn box_async_function<F, A, FR, R>(name: &str, function: F) -> AsyncCallback<'a>
+    where
+        F: Fn(&'a Lua, A) -> FR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        FR: Future<Output = Result<R>> + 'a,
+        R: IntoLuaMulti,
+    {
+        let name = get_function_name::<T>(name);
+        Box::new(move |rawlua, args| unsafe {
+            let lua = rawlua.lua();
+            let args = match A::from_lua_args(args, 1, Some(&name), lua) {
+                Ok(args) => args,
+                Err(e) => return Box::pin(future::ready(Err(e))),
+            };
+            let fut = function(lua, args);
+            Box::pin(async move { fut.await?.push_into_stack_multi(rawlua) })
+        })
+    }
+
+    pub(crate) fn check_meta_field<V>(lua: &Lua, name: &str, value: V) -> Result<Value>
+    where
+        V: IntoLua,
+    {
+        let value = value.into_lua(lua)?;
+        if name == MetaMethod::Index || name == MetaMethod::NewIndex {
+            match value {
+                Value::Nil | Value::Table(_) | Value::Function(_) => {}
+                _ => {
+                    return Err(Error::MetaMethodTypeError {
+                        method: name.to_string(),
+                        type_name: value.type_name(),
+                        message: Some("expected nil, table or function".to_string()),
+                    })
+                }
+            }
+        }
+        value.into_lua(lua)
+    }
+}
+
+// Returns function name for the type `T`, without the module path
+fn get_function_name<T>(name: &str) -> StdString {
+    format!("{}.{name}", short_type_name::<T>())
+}
+
+impl<'a, T: 'static> UserDataFields<'a, T> for UserDataRegistry<'a, T> {
+    fn add_field<V>(&mut self, name: impl ToString, value: V)
+    where
+        V: IntoLua + Clone + 'static,
+    {
+        let name = name.to_string();
+        let callback = Box::new(move |lua, _| unsafe { value.clone().push_into_stack_multi(lua) });
+        self.fields.push((name, callback));
+    }
+
+    fn add_field_method_get<M, R>(&mut self, name: impl ToString, method: M)
+    where
+        M: Fn(&'a Lua, &T) -> Result<R> + MaybeSend + 'static,
+        R: IntoLua,
+    {
+        let name = name.to_string();
+        let callback = Self::box_method(&name, move |lua, data, ()| method(lua, data));
+        self.field_getters.push((name, callback));
+    }
+
+    fn add_field_method_set<M, A>(&mut self, name: impl ToString, method: M)
+    where
+        M: FnMut(&'a Lua, &mut T, A) -> Result<()> + MaybeSend + 'static,
+        A: FromLua,
+    {
+        let name = name.to_string();
+        let callback = Self::box_method_mut(&name, method);
+        self.field_setters.push((name, callback));
+    }
+
+    fn add_field_function_get<F, R>(&mut self, name: impl ToString, function: F)
+    where
+        F: Fn(&'a Lua, AnyUserData) -> Result<R> + MaybeSend + 'static,
+        R: IntoLua,
+    {
+        let name = name.to_string();
+        let callback = Self::box_function(&name, function);
+        self.field_getters.push((name, callback));
+    }
+
+    fn add_field_function_set<F, A>(&mut self, name: impl ToString, mut function: F)
+    where
+        F: FnMut(&'a Lua, AnyUserData, A) -> Result<()> + MaybeSend + 'static,
+        A: FromLua,
+    {
+        let name = name.to_string();
+        let callback = Self::box_function_mut(&name, move |lua, (data, val)| function(lua, data, val));
+        self.field_setters.push((name, callback));
+    }
+
+    fn add_meta_field<V>(&mut self, name: impl ToString, value: V)
+    where
+        V: IntoLua + Clone + 'static,
+    {
+        let name = name.to_string();
+        self.meta_fields.push((
+            name.clone(),
+            Box::new(move |lua, _| unsafe {
+                Self::check_meta_field(lua.lua(), &name, value.clone())?.push_into_stack_multi(lua)
+            }),
+        ));
+    }
+
+    fn add_meta_field_with<F, R>(&mut self, name: impl ToString, f: F)
+    where
+        F: Fn(&'a Lua) -> Result<R> + MaybeSend + 'static,
+        R: IntoLua,
+    {
+        let name = name.to_string();
+        self.meta_fields.push((
+            name.clone(),
+            Box::new(move |rawlua, _| unsafe {
+                let lua = rawlua.lua();
+                Self::check_meta_field(lua, &name, f(lua)?)?.push_into_stack_multi(rawlua)
+            }),
+        ));
+    }
+}
+
+impl<'a, T: 'static> UserDataMethods<'a, T> for UserDataRegistry<'a, T> {
+    fn add_method<M, A, R>(&mut self, name: impl ToString, method: M)
+    where
+        M: Fn(&'a Lua, &T, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = Self::box_method(&name, method);
+        self.methods.push((name, callback));
+    }
+
+    fn add_method_mut<M, A, R>(&mut self, name: impl ToString, method: M)
+    where
+        M: FnMut(&'a Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = Self::box_method_mut(&name, method);
+        self.methods.push((name, callback));
+    }
+
+    #[cfg(feature = "async")]
+    fn add_async_method<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    where
+        M: Fn(&'a Lua, &'a T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        MR: Future<Output = Result<R>> + 'a,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = Self::box_async_method(&name, method);
+        self.async_methods.push((name, callback));
+    }
+
+    #[cfg(feature = "async")]
+    fn add_async_method_mut<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    where
+        M: Fn(&'a Lua, &'a mut T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        MR: Future<Output = Result<R>> + 'a,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = Self::box_async_method_mut(&name, method);
+        self.async_methods.push((name, callback));
+    }
+
+    fn add_function<F, A, R>(&mut self, name: impl ToString, function: F)
+    where
+        F: Fn(&'a Lua, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = Self::box_function(&name, function);
+        self.methods.push((name, callback));
+    }
+
+    fn add_function_mut<F, A, R>(&mut self, name: impl ToString, function: F)
+    where
+        F: FnMut(&'a Lua, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = Self::box_function_mut(&name, function);
+        self.methods.push((name, callback));
+    }
+
+    #[cfg(feature = "async")]
+    fn add_async_function<F, A, FR, R>(&mut self, name: impl ToString, function: F)
+    where
+        F: Fn(&'a Lua, A) -> FR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        FR: Future<Output = Result<R>> + 'a,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = Self::box_async_function(&name, function);
+        self.async_methods.push((name, callback));
+    }
+
+    fn add_meta_method<M, A, R>(&mut self, name: impl ToString, method: M)
+    where
+        M: Fn(&'a Lua, &T, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = Self::box_method(&name, method);
+        self.meta_methods.push((name, callback));
+    }
+
+    fn add_meta_method_mut<M, A, R>(&mut self, name: impl ToString, method: M)
+    where
+        M: FnMut(&'a Lua, &mut T, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = Self::box_method_mut(&name, method);
+        self.meta_methods.push((name, callback));
+    }
+
+    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
+    fn add_async_meta_method<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    where
+        M: Fn(&'a Lua, &'a T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        MR: Future<Output = Result<R>> + 'a,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = Self::box_async_method(&name, method);
+        self.async_meta_methods.push((name, callback));
+    }
+
+    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
+    fn add_async_meta_method_mut<M, A, MR, R>(&mut self, name: impl ToString, method: M)
+    where
+        M: Fn(&'a Lua, &'a mut T, A) -> MR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        MR: Future<Output = Result<R>> + 'a,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = Self::box_async_method_mut(&name, method);
+        self.async_meta_methods.push((name, callback));
+    }
+
+    fn add_meta_function<F, A, R>(&mut self, name: impl ToString, function: F)
+    where
+        F: Fn(&'a Lua, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = Self::box_function(&name, function);
+        self.meta_methods.push((name, callback));
+    }
+
+    fn add_meta_function_mut<F, A, R>(&mut self, name: impl ToString, function: F)
+    where
+        F: FnMut(&'a Lua, A) -> Result<R> + MaybeSend + 'static,
+        A: FromLuaMulti,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = Self::box_function_mut(&name, function);
+        self.meta_methods.push((name, callback));
+    }
+
+    #[cfg(all(feature = "async", not(any(feature = "lua51", feature = "luau"))))]
+    fn add_async_meta_function<F, A, FR, R>(&mut self, name: impl ToString, function: F)
+    where
+        F: Fn(&'a Lua, A) -> FR + MaybeSend + 'static,
+        A: FromLuaMulti,
+        FR: Future<Output = Result<R>> + 'a,
+        R: IntoLuaMulti,
+    {
+        let name = name.to_string();
+        let callback = Self::box_async_function(&name, function);
+        self.async_meta_methods.push((name, callback));
+    }
+}
+
+// Borrow the userdata in-place from the Lua stack
+#[inline(always)]
+unsafe fn borrow_userdata_ref<'a, T>(
+    state: *mut ffi::lua_State,
+    index: c_int,
+) -> Result<UserDataBorrowRef<'a, T>> {
+    let ud = get_userdata::<UserDataVariant<T>>(state, index);
+    (*ud).try_borrow()
+}
+
+// Borrow the userdata mutably in-place from the Lua stack
+#[inline(always)]
+unsafe fn borrow_userdata_mut<'a, T>(
+    state: *mut ffi::lua_State,
+    index: c_int,
+) -> Result<UserDataBorrowMut<'a, T>> {
+    let ud = get_userdata::<UserDataVariant<T>>(state, index);
+    (*ud).try_borrow_mut()
+}
+
+macro_rules! lua_userdata_impl {
+    ($type:ty) => {
+        impl<T: UserData + 'static> UserData for $type {
+            fn register(registry: &mut UserDataRegistry<Self>) {
+                let mut orig_registry = UserDataRegistry::new();
+                T::register(&mut orig_registry);
+
+                // Copy all fields, methods, etc. from the original registry
+                registry.fields.extend(orig_registry.fields);
+                registry.field_getters.extend(orig_registry.field_getters);
+                registry.field_setters.extend(orig_registry.field_setters);
+                registry.meta_fields.extend(orig_registry.meta_fields);
+                registry.methods.extend(orig_registry.methods);
+                #[cfg(feature = "async")]
+                registry.async_methods.extend(orig_registry.async_methods);
+                registry.meta_methods.extend(orig_registry.meta_methods);
+                #[cfg(feature = "async")]
+                registry
+                    .async_meta_methods
+                    .extend(orig_registry.async_meta_methods);
+            }
+        }
+    };
+}
+
+// A special proxy object for UserData
+pub(crate) struct UserDataProxy<T>(pub(crate) PhantomData<T>);
+
+lua_userdata_impl!(UserDataProxy<T>);
@@ -1,629 +0,0 @@
-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)
-                        }
-                        #[cfg(feature = "parking_lot")]
-                        Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
-                            let ud = get_userdata_ref::<Arc<parking_lot::Mutex<T>>>(lua.state)?;
-                            let ud = ud.try_lock().ok_or(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)
-                        }
-                        #[cfg(feature = "parking_lot")]
-                        Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
-                            let ud = get_userdata_ref::<Arc<parking_lot::RwLock<T>>>(lua.state)?;
-                            let ud = ud.try_read().ok_or(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)
-                        }
-                        #[cfg(feature = "parking_lot")]
-                        Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
-                            let ud = get_userdata_mut::<Arc<parking_lot::Mutex<T>>>(lua.state)?;
-                            let mut ud = ud.try_lock().ok_or(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)
-                        }
-                        #[cfg(feature = "parking_lot")]
-                        Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
-                            let ud = get_userdata_mut::<Arc<parking_lot::RwLock<T>>>(lua.state)?;
-                            let mut ud = ud.try_write().ok_or(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)?))
-                            }
-                            #[cfg(feature = "parking_lot")]
-                            Some(id) if id == TypeId::of::<Arc<parking_lot::Mutex<T>>>() => {
-                                let ud = get_userdata_ref::<Arc<parking_lot::Mutex<T>>>(lua.state)?;
-                                let ud = ud.try_lock().ok_or(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)?))
-                            }
-                            #[cfg(feature = "parking_lot")]
-                            Some(id) if id == TypeId::of::<Arc<parking_lot::RwLock<T>>>() => {
-                                let ud =
-                                    get_userdata_ref::<Arc<parking_lot::RwLock<T>>>(lua.state)?;
-                                let ud = ud.try_read().ok_or(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>>);
-#[cfg(feature = "parking_lot")]
-lua_userdata_impl!(Arc<parking_lot::Mutex<T>>);
-#[cfg(feature = "parking_lot")]
-lua_userdata_impl!(Arc<parking_lot::RwLock<T>>);
-
-// A special proxy object for UserData
-pub(crate) struct UserDataProxy<T>(pub(crate) PhantomData<T>);
-
-lua_userdata_impl!(UserDataProxy<T>);
@@ -0,0 +1,432 @@
+use std::any::Any;
+use std::fmt::Write as _;
+use std::mem::MaybeUninit;
+use std::os::raw::{c_int, c_void};
+use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe};
+use std::ptr;
+use std::sync::Arc;
+
+use crate::error::{Error, Result};
+use crate::memory::MemoryState;
+use crate::util::{
+    check_stack, get_internal_metatable, get_internal_userdata, init_internal_metatable,
+    push_internal_userdata, push_string, push_table, rawset_field, to_string, TypeKey,
+    DESTRUCTED_USERDATA_METATABLE,
+};
+
+static WRAPPED_FAILURE_TYPE_KEY: u8 = 0;
+
+pub(crate) enum WrappedFailure {
+    None,
+    Error(Error),
+    Panic(Option<Box<dyn Any + Send + 'static>>),
+}
+
+impl TypeKey for WrappedFailure {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &WRAPPED_FAILURE_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+impl WrappedFailure {
+    pub(crate) unsafe fn new_userdata(state: *mut ffi::lua_State) -> *mut Self {
+        #[cfg(feature = "luau")]
+        let ud = ffi::lua_newuserdata_t::<Self>(state);
+        #[cfg(not(feature = "luau"))]
+        let ud = ffi::lua_newuserdata(state, std::mem::size_of::<Self>()) as *mut Self;
+        ptr::write(ud, WrappedFailure::None);
+        ud
+    }
+}
+
+// In the context of a lua callback, this will call the given function and if the given function
+// returns an error, *or if the given function panics*, this will result in a call to `lua_error` (a
+// longjmp). The error or panic is wrapped in such a way that when calling `pop_error` back on
+// the Rust side, it will resume the panic.
+//
+// This function assumes the structure of the stack at the beginning of a callback, that the only
+// elements on the stack are the arguments to the callback.
+//
+// This function uses some of the bottom of the stack for error handling, the given callback will be
+// given the number of arguments available as an argument, and should return the number of returns
+// as normal, but cannot assume that the arguments available start at 0.
+unsafe fn callback_error<F, R>(state: *mut ffi::lua_State, f: F) -> R
+where
+    F: FnOnce(c_int) -> Result<R>,
+{
+    let nargs = ffi::lua_gettop(state);
+
+    // We need 2 extra stack spaces to store preallocated memory and error/panic metatable
+    let extra_stack = if nargs < 2 { 2 - nargs } else { 1 };
+    ffi::luaL_checkstack(
+        state,
+        extra_stack,
+        cstr!("not enough stack space for callback error handling"),
+    );
+
+    // 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 = WrappedFailure::new_userdata(state);
+    ffi::lua_rotate(state, 1, 1);
+
+    match catch_unwind(AssertUnwindSafe(|| f(nargs))) {
+        Ok(Ok(r)) => {
+            ffi::lua_remove(state, 1);
+            r
+        }
+        Ok(Err(err)) => {
+            ffi::lua_settop(state, 1);
+
+            // 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);
+                ffi::lua_pop(state, 1);
+                traceback
+            } else {
+                "<not enough stack space for traceback>".to_string()
+            };
+            let cause = Arc::new(err);
+            let wrapped_error = WrappedFailure::Error(Error::CallbackError { traceback, cause });
+            ptr::write(ud, wrapped_error);
+            get_internal_metatable::<WrappedFailure>(state);
+            ffi::lua_setmetatable(state, -2);
+
+            ffi::lua_error(state)
+        }
+        Err(p) => {
+            ffi::lua_settop(state, 1);
+            ptr::write(ud, WrappedFailure::Panic(Some(p)));
+            get_internal_metatable::<WrappedFailure>(state);
+            ffi::lua_setmetatable(state, -2);
+            ffi::lua_error(state)
+        }
+    }
+}
+
+// Pops an error off of the stack and returns it. The specific behavior depends on the type of the
+// error at the top of the stack:
+//   1) If the error is actually a panic, this will continue the panic.
+//   2) If the error on the top of the stack is actually an error, just returns it.
+//   3) Otherwise, interprets the error as the appropriate lua error.
+// Uses 2 stack spaces, does not call checkstack.
+pub(crate) unsafe fn pop_error(state: *mut ffi::lua_State, err_code: c_int) -> Error {
+    mlua_debug_assert!(
+        err_code != ffi::LUA_OK && err_code != ffi::LUA_YIELD,
+        "pop_error called with non-error return code"
+    );
+
+    match get_internal_userdata::<WrappedFailure>(state, -1, ptr::null()).as_mut() {
+        Some(WrappedFailure::Error(err)) => {
+            ffi::lua_pop(state, 1);
+            err.clone()
+        }
+        Some(WrappedFailure::Panic(panic)) => {
+            if let Some(p) = panic.take() {
+                resume_unwind(p);
+            } else {
+                Error::PreviouslyResumedPanic
+            }
+        }
+        _ => {
+            let err_string = to_string(state, -1);
+            ffi::lua_pop(state, 1);
+
+            match err_code {
+                ffi::LUA_ERRRUN => Error::RuntimeError(err_string),
+                ffi::LUA_ERRSYNTAX => {
+                    Error::SyntaxError {
+                        // This seems terrible, but as far as I can tell, this is exactly what the
+                        // stock Lua REPL does.
+                        incomplete_input: err_string.ends_with("<eof>") || err_string.ends_with("'<eof>'"),
+                        message: err_string,
+                    }
+                }
+                ffi::LUA_ERRERR => {
+                    // This error is raised when the error handler raises an error too many times
+                    // recursively, and continuing to trigger the error handler would cause a stack
+                    // overflow. It is not very useful to differentiate between this and "ordinary"
+                    // runtime errors, so we handle them the same way.
+                    Error::RuntimeError(err_string)
+                }
+                ffi::LUA_ERRMEM => Error::MemoryError(err_string),
+                #[cfg(any(feature = "lua53", feature = "lua52"))]
+                ffi::LUA_ERRGCMM => Error::GarbageCollectorError(err_string),
+                _ => mlua_panic!("unrecognized lua error code"),
+            }
+        }
+    }
+}
+
+// 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
+// longjmping, should not contain any values that implements Drop.
+// Internally uses 2 extra stack spaces, and does not call checkstack.
+pub(crate) unsafe fn protect_lua_call(
+    state: *mut ffi::lua_State,
+    nargs: c_int,
+    f: unsafe extern "C-unwind" fn(*mut ffi::lua_State) -> c_int,
+) -> Result<()> {
+    let stack_start = ffi::lua_gettop(state) - nargs;
+
+    MemoryState::relax_limit_with(state, || {
+        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
+// given function return type is not the return value count, instead the inner function return
+// values are assumed to match the `nresults` param. Provided function must *not* panic, and since
+// it will generally be longjmping, should not contain any values that implements Drop.
+// Internally uses 3 extra stack spaces, and does not call checkstack.
+pub(crate) unsafe fn protect_lua_closure<F, R>(
+    state: *mut ffi::lua_State,
+    nargs: c_int,
+    nresults: c_int,
+    f: F,
+) -> Result<R>
+where
+    F: Fn(*mut ffi::lua_State) -> R,
+    R: Copy,
+{
+    struct Params<F, R: Copy> {
+        function: F,
+        result: MaybeUninit<R>,
+        nresults: c_int,
+    }
+
+    unsafe extern "C-unwind" fn do_call<F, R>(state: *mut ffi::lua_State) -> c_int
+    where
+        F: Fn(*mut ffi::lua_State) -> R,
+        R: Copy,
+    {
+        let params = ffi::lua_touserdata(state, -1) as *mut Params<F, R>;
+        ffi::lua_pop(state, 1);
+
+        (*params).result.write(((*params).function)(state));
+
+        if (*params).nresults == ffi::LUA_MULTRET {
+            ffi::lua_gettop(state)
+        } else {
+            (*params).nresults
+        }
+    }
+
+    let stack_start = ffi::lua_gettop(state) - nargs;
+
+    MemoryState::relax_limit_with(state, || {
+        ffi::lua_pushcfunction(state, error_traceback);
+        ffi::lua_pushcfunction(state, do_call::<F, R>);
+    });
+    if nargs > 0 {
+        ffi::lua_rotate(state, stack_start + 1, 2);
+    }
+
+    let mut params = Params {
+        function: f,
+        result: MaybeUninit::uninit(),
+        nresults,
+    };
+
+    ffi::lua_pushlightuserdata(state, &mut params as *mut Params<F, R> as *mut c_void);
+    let ret = ffi::lua_pcall(state, nargs + 1, nresults, stack_start + 1);
+    ffi::lua_remove(state, stack_start + 1);
+
+    if ret == ffi::LUA_OK {
+        // `LUA_OK` is only returned when the `do_call` function has completed successfully, so
+        // `params.result` is definitely initialized.
+        Ok(params.result.assume_init())
+    } else {
+        Err(pop_error(state, ret))
+    }
+}
+
+pub(crate) unsafe extern "C-unwind" fn error_traceback(state: *mut ffi::lua_State) -> c_int {
+    // Luau calls error handler for memory allocation errors, skip it
+    // See https://github.com/Roblox/luau/issues/880
+    #[cfg(feature = "luau")]
+    if MemoryState::limit_reached(state) {
+        return 0;
+    }
+
+    if ffi::lua_checkstack(state, 2) == 0 {
+        // If we don't have enough stack space to even check the error type, do
+        // nothing so we don't risk shadowing a rust panic.
+        return 1;
+    }
+
+    if get_internal_userdata::<WrappedFailure>(state, -1, ptr::null()).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, 0);
+            ffi::lua_remove(state, -2);
+        }
+    }
+
+    1
+}
+
+// A variant of `error_traceback` that can safely inspect another (yielded) thread stack
+pub(crate) unsafe fn error_traceback_thread(state: *mut ffi::lua_State, thread: *mut ffi::lua_State) {
+    // Move error object to the main thread to safely call `__tostring` metamethod if present
+    ffi::lua_xmove(thread, state, 1);
+
+    if get_internal_userdata::<WrappedFailure>(state, -1, ptr::null()).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, thread, s, 0);
+            ffi::lua_remove(state, -2);
+        }
+    }
+}
+
+// Initialize the error, panic, and destructed userdata metatables.
+pub(crate) unsafe fn init_error_registry(state: *mut ffi::lua_State) -> Result<()> {
+    check_stack(state, 7)?;
+
+    // Create error and panic metatables
+
+    static ERROR_PRINT_BUFFER_KEY: u8 = 0;
+
+    unsafe extern "C-unwind" fn error_tostring(state: *mut ffi::lua_State) -> c_int {
+        callback_error(state, |_| {
+            check_stack(state, 3)?;
+
+            let err_buf = match get_internal_userdata::<WrappedFailure>(state, -1, ptr::null()).as_ref() {
+                Some(WrappedFailure::Error(error)) => {
+                    let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
+                    ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
+                    let err_buf = ffi::lua_touserdata(state, -1) as *mut String;
+                    ffi::lua_pop(state, 2);
+
+                    (*err_buf).clear();
+                    // Depending on how the API is used and what error types scripts are given, it may
+                    // be possible to make this consume arbitrary amounts of memory (for example, some
+                    // kind of recursive error structure?)
+                    let _ = write!(&mut (*err_buf), "{error}");
+                    Ok(err_buf)
+                }
+                Some(WrappedFailure::Panic(Some(ref panic))) => {
+                    let err_buf_key = &ERROR_PRINT_BUFFER_KEY as *const u8 as *const c_void;
+                    ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, err_buf_key);
+                    let err_buf = ffi::lua_touserdata(state, -1) as *mut String;
+                    (*err_buf).clear();
+                    ffi::lua_pop(state, 2);
+
+                    if let Some(msg) = panic.downcast_ref::<&str>() {
+                        let _ = write!(&mut (*err_buf), "{msg}");
+                    } else if let Some(msg) = panic.downcast_ref::<String>() {
+                        let _ = write!(&mut (*err_buf), "{msg}");
+                    } else {
+                        let _ = write!(&mut (*err_buf), "<panic>");
+                    };
+                    Ok(err_buf)
+                }
+                Some(WrappedFailure::Panic(None)) => Err(Error::PreviouslyResumedPanic),
+                _ => {
+                    // I'm not sure whether this is possible to trigger without bugs in mlua?
+                    Err(Error::UserDataTypeMismatch)
+                }
+            }?;
+
+            push_string(state, (*err_buf).as_bytes(), true)?;
+            (*err_buf).clear();
+
+            Ok(1)
+        })
+    }
+
+    init_internal_metatable::<WrappedFailure>(
+        state,
+        Some(|state| {
+            ffi::lua_pushcfunction(state, error_tostring);
+            rawset_field(state, -2, "__tostring")
+        }),
+    )?;
+
+    // Create destructed userdata metatable
+
+    unsafe extern "C-unwind" fn destructed_error(state: *mut ffi::lua_State) -> c_int {
+        callback_error(state, |_| Err(Error::CallbackDestructed))
+    }
+
+    push_table(state, 0, 26, true)?;
+    ffi::lua_pushcfunction(state, destructed_error);
+    for &method in &[
+        "__add",
+        "__sub",
+        "__mul",
+        "__div",
+        "__mod",
+        "__pow",
+        "__unm",
+        #[cfg(any(feature = "lua54", feature = "lua53", feature = "luau"))]
+        "__idiv",
+        #[cfg(any(feature = "lua54", feature = "lua53"))]
+        "__band",
+        #[cfg(any(feature = "lua54", feature = "lua53"))]
+        "__bor",
+        #[cfg(any(feature = "lua54", feature = "lua53"))]
+        "__bxor",
+        #[cfg(any(feature = "lua54", feature = "lua53"))]
+        "__bnot",
+        #[cfg(any(feature = "lua54", feature = "lua53"))]
+        "__shl",
+        #[cfg(any(feature = "lua54", feature = "lua53"))]
+        "__shr",
+        "__concat",
+        "__len",
+        "__eq",
+        "__lt",
+        "__le",
+        "__index",
+        "__newindex",
+        "__call",
+        "__tostring",
+        #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52", feature = "luajit52"))]
+        "__pairs",
+        #[cfg(any(feature = "lua53", feature = "lua52", feature = "luajit52"))]
+        "__ipairs",
+        #[cfg(feature = "luau")]
+        "__iter",
+        #[cfg(feature = "lua54")]
+        "__close",
+    ] {
+        ffi::lua_pushvalue(state, -1);
+        rawset_field(state, -3, method)?;
+    }
+    ffi::lua_pop(state, 1);
+
+    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);
+    })?;
+
+    // Create error print buffer
+    init_internal_metatable::<String>(state, None)?;
+    push_internal_userdata(state, String::new(), true)?;
+    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);
+    })?;
+
+    Ok(())
+}
@@ -0,0 +1,308 @@
+use std::borrow::Cow;
+use std::ffi::CStr;
+use std::os::raw::{c_char, c_int};
+use std::{ptr, slice, str};
+
+use crate::error::{Error, Result};
+
+pub(crate) use error::{
+    error_traceback, error_traceback_thread, init_error_registry, pop_error, protect_lua_call,
+    protect_lua_closure, WrappedFailure,
+};
+pub(crate) use short_names::short_type_name;
+pub(crate) use types::TypeKey;
+pub(crate) use userdata::{
+    get_destructed_userdata_metatable, get_internal_metatable, get_internal_userdata, get_userdata,
+    init_internal_metatable, init_userdata_metatable, push_internal_userdata, take_userdata,
+    DESTRUCTED_USERDATA_METATABLE,
+};
+
+#[cfg(not(feature = "lua54"))]
+pub(crate) use userdata::push_userdata;
+#[cfg(feature = "lua54")]
+pub(crate) use userdata::push_userdata_uv;
+
+#[cfg(not(feature = "luau"))]
+pub(crate) use userdata::userdata_destructor;
+
+// Checks that Lua has enough free stack space for future stack operations. On failure, this will
+// panic with an internal error message.
+#[inline]
+pub(crate) 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
+    // only when `cfg!(debug_assertions)` is true.
+    mlua_assert!(ffi::lua_checkstack(state, amount) != 0, "out of stack space");
+}
+
+// Checks that Lua has enough free stack space and returns `Error::StackError` on failure.
+#[inline]
+pub(crate) unsafe fn check_stack(state: *mut ffi::lua_State, amount: c_int) -> Result<()> {
+    if ffi::lua_checkstack(state, amount) == 0 {
+        Err(Error::StackError)
+    } else {
+        Ok(())
+    }
+}
+
+pub(crate) struct StackGuard {
+    state: *mut ffi::lua_State,
+    top: c_int,
+}
+
+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(crate) unsafe fn new(state: *mut ffi::lua_State) -> StackGuard {
+        StackGuard {
+            state,
+            top: ffi::lua_gettop(state),
+        }
+    }
+
+    // Same as `new()`, but allows specifying the expected stack size at the end of the scope.
+    #[inline]
+    pub(crate) fn with_top(state: *mut ffi::lua_State, top: c_int) -> StackGuard {
+        StackGuard { state, top }
+    }
+}
+
+impl Drop for StackGuard {
+    fn drop(&mut self) {
+        unsafe {
+            let top = ffi::lua_gettop(self.state);
+            if top < self.top {
+                mlua_panic!("{} too many stack values popped", self.top - top)
+            }
+            if top > self.top {
+                ffi::lua_settop(self.state, self.top);
+            }
+        }
+    }
+}
+
+// Uses 3 (or 1 if unprotected) stack spaces, does not call checkstack.
+#[inline(always)]
+pub(crate) unsafe fn push_string(state: *mut ffi::lua_State, s: &[u8], protect: bool) -> Result<()> {
+    // Always use protected mode if the string is too long
+    if protect || s.len() > (1 << 30) {
+        protect_lua!(state, 0, 1, |state| {
+            ffi::lua_pushlstring(state, s.as_ptr() as *const c_char, s.len());
+        })
+    } else {
+        ffi::lua_pushlstring(state, s.as_ptr() as *const c_char, s.len());
+        Ok(())
+    }
+}
+
+// Uses 3 stack spaces (when protect), does not call checkstack.
+#[cfg(feature = "luau")]
+#[inline(always)]
+pub(crate) unsafe fn push_buffer(state: *mut ffi::lua_State, b: &[u8], protect: bool) -> Result<()> {
+    let data = if protect {
+        protect_lua!(state, 0, 1, |state| ffi::lua_newbuffer(state, b.len()))?
+    } else {
+        ffi::lua_newbuffer(state, b.len())
+    };
+    let buf = slice::from_raw_parts_mut(data as *mut u8, b.len());
+    buf.copy_from_slice(b);
+    Ok(())
+}
+
+// Uses 3 stack spaces, does not call checkstack.
+#[inline]
+pub(crate) unsafe fn push_table(
+    state: *mut ffi::lua_State,
+    narr: usize,
+    nrec: usize,
+    protect: bool,
+) -> Result<()> {
+    let narr: c_int = narr.try_into().unwrap_or(c_int::MAX);
+    let nrec: c_int = nrec.try_into().unwrap_or(c_int::MAX);
+    if protect {
+        protect_lua!(state, 0, 1, |state| ffi::lua_createtable(state, narr, nrec))
+    } else {
+        ffi::lua_createtable(state, narr, nrec);
+        Ok(())
+    }
+}
+
+// Uses 4 stack spaces, does not call checkstack.
+pub(crate) unsafe fn rawset_field(state: *mut ffi::lua_State, table: c_int, field: &str) -> Result<()> {
+    ffi::lua_pushvalue(state, table);
+    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);
+    })
+}
+
+// A variant of `pcall` that does not allow Lua to catch Rust panics from `callback_error`.
+pub(crate) unsafe extern "C-unwind" fn safe_pcall(state: *mut ffi::lua_State) -> c_int {
+    ffi::luaL_checkstack(state, 2, ptr::null());
+
+    let top = ffi::lua_gettop(state);
+    if top == 0 {
+        ffi::lua_pushstring(state, cstr!("not enough arguments to pcall"));
+        ffi::lua_error(state);
+    }
+
+    if ffi::lua_pcall(state, top - 1, ffi::LUA_MULTRET, 0) == ffi::LUA_OK {
+        ffi::lua_pushboolean(state, 1);
+        ffi::lua_insert(state, 1);
+        ffi::lua_gettop(state)
+    } else {
+        let wf_ud = get_internal_userdata::<WrappedFailure>(state, -1, ptr::null());
+        if let Some(WrappedFailure::Panic(_)) = wf_ud.as_ref() {
+            ffi::lua_error(state);
+        }
+        ffi::lua_pushboolean(state, 0);
+        ffi::lua_insert(state, -2);
+        2
+    }
+}
+
+// A variant of `xpcall` that does not allow Lua to catch Rust panics from `callback_error`.
+pub(crate) unsafe extern "C-unwind" fn safe_xpcall(state: *mut ffi::lua_State) -> c_int {
+    unsafe extern "C-unwind" fn xpcall_msgh(state: *mut ffi::lua_State) -> c_int {
+        ffi::luaL_checkstack(state, 2, ptr::null());
+
+        let wf_ud = get_internal_userdata::<WrappedFailure>(state, -1, ptr::null());
+        if let Some(WrappedFailure::Panic(_)) = wf_ud.as_ref() {
+            1
+        } else {
+            ffi::lua_pushvalue(state, ffi::lua_upvalueindex(1));
+            ffi::lua_insert(state, 1);
+            ffi::lua_call(state, ffi::lua_gettop(state) - 1, ffi::LUA_MULTRET);
+            ffi::lua_gettop(state)
+        }
+    }
+
+    ffi::luaL_checkstack(state, 2, ptr::null());
+
+    let top = ffi::lua_gettop(state);
+    if top < 2 {
+        ffi::lua_pushstring(state, cstr!("not enough arguments to xpcall"));
+        ffi::lua_error(state);
+    }
+
+    ffi::lua_pushvalue(state, 2);
+    ffi::lua_pushcclosure(state, xpcall_msgh, 1);
+    ffi::lua_copy(state, 1, 2);
+    ffi::lua_replace(state, 1);
+
+    if ffi::lua_pcall(state, ffi::lua_gettop(state) - 2, ffi::LUA_MULTRET, 1) == ffi::LUA_OK {
+        ffi::lua_pushboolean(state, 1);
+        ffi::lua_insert(state, 2);
+        ffi::lua_gettop(state) - 1
+    } else {
+        let wf_ud = get_internal_userdata::<WrappedFailure>(state, -1, ptr::null());
+        if let Some(WrappedFailure::Panic(_)) = wf_ud.as_ref() {
+            ffi::lua_error(state);
+        }
+        ffi::lua_pushboolean(state, 0);
+        ffi::lua_insert(state, -2);
+        2
+    }
+}
+
+// Returns Lua main thread for Lua >= 5.2 or checks that the passed thread is main for Lua 5.1.
+// Does not call lua_checkstack, uses 1 stack space.
+pub(crate) unsafe fn get_main_state(state: *mut ffi::lua_State) -> Option<*mut ffi::lua_State> {
+    #[cfg(any(feature = "lua54", feature = "lua53", feature = "lua52"))]
+    {
+        ffi::lua_rawgeti(state, ffi::LUA_REGISTRYINDEX, ffi::LUA_RIDX_MAINTHREAD);
+        let main_state = ffi::lua_tothread(state, -1);
+        ffi::lua_pop(state, 1);
+        Some(main_state)
+    }
+    #[cfg(any(feature = "lua51", feature = "luajit"))]
+    {
+        // Check the current state first
+        let is_main_state = ffi::lua_pushthread(state) == 1;
+        ffi::lua_pop(state, 1);
+        if is_main_state {
+            Some(state)
+        } else {
+            None
+        }
+    }
+    #[cfg(feature = "luau")]
+    Some(ffi::lua_mainthread(state))
+}
+
+// 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 {
+    match ffi::lua_type(state, index) {
+        ffi::LUA_TNONE => "<none>".to_string(),
+        ffi::LUA_TNIL => "<nil>".to_string(),
+        ffi::LUA_TBOOLEAN => (ffi::lua_toboolean(state, index) != 1).to_string(),
+        ffi::LUA_TLIGHTUSERDATA => {
+            format!("<lightuserdata {:?}>", ffi::lua_topointer(state, index))
+        }
+        ffi::LUA_TNUMBER => {
+            let mut isint = 0;
+            let i = ffi::lua_tointegerx(state, -1, &mut isint);
+            if isint == 0 {
+                ffi::lua_tonumber(state, index).to_string()
+            } else {
+                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));
+            #[cfg(not(feature = "luau-vector4"))]
+            return format!("vector({x}, {y}, {z})");
+            #[cfg(feature = "luau-vector4")]
+            return format!("vector({x}, {y}, {z}, {w})", w = *v.add(3));
+        }
+        ffi::LUA_TSTRING => {
+            let mut size = 0;
+            // This will not trigger a 'm' error, because the reference is guaranteed to be of
+            // string type
+            let data = ffi::lua_tolstring(state, index, &mut size);
+            String::from_utf8_lossy(slice::from_raw_parts(data as *const u8, size)).into_owned()
+        }
+        ffi::LUA_TTABLE => format!("<table {:?}>", ffi::lua_topointer(state, index)),
+        ffi::LUA_TFUNCTION => format!("<function {:?}>", ffi::lua_topointer(state, index)),
+        ffi::LUA_TUSERDATA => format!("<userdata {:?}>", ffi::lua_topointer(state, index)),
+        ffi::LUA_TTHREAD => format!("<thread {:?}>", ffi::lua_topointer(state, index)),
+        #[cfg(feature = "luau")]
+        ffi::LUA_TBUFFER => format!("<buffer {:?}>", ffi::lua_topointer(state, index)),
+        #[cfg(feature = "luajit")]
+        ffi::LUA_TCDATA => format!("<cdata {:?}>", ffi::lua_topointer(state, index)),
+        _ => "<unknown>".to_string(),
+    }
+}
+
+pub(crate) unsafe fn ptr_to_str<'a>(input: *const c_char) -> Option<&'a str> {
+    if input.is_null() {
+        return None;
+    }
+    str::from_utf8(CStr::from_ptr(input).to_bytes()).ok()
+}
+
+pub(crate) unsafe fn ptr_to_lossy_str<'a>(input: *const c_char) -> Option<Cow<'a, str>> {
+    if input.is_null() {
+        return None;
+    }
+    Some(String::from_utf8_lossy(CStr::from_ptr(input).to_bytes()))
+}
+
+pub(crate) fn linenumber_to_usize(n: c_int) -> Option<usize> {
+    match n {
+        n if n < 0 => None,
+        n => Some(n as usize),
+    }
+}
+
+mod error;
+mod short_names;
+mod types;
+mod userdata;
@@ -0,0 +1,77 @@
+//! Mostly copied from [bevy_utils]
+//!
+//! [bevy_utils]: https://github.com/bevyengine/bevy/blob/main/crates/bevy_utils/src/short_names.rs
+
+use std::any::type_name;
+
+/// Returns a short version of a type name `T` without all module paths.
+///
+/// The short name of a type is its full name as returned by
+/// [`std::any::type_name`], but with the prefix of all paths removed. For
+/// example, the short name of `alloc::vec::Vec<core::option::Option<u32>>`
+/// would be `Vec<Option<u32>>`.
+pub(crate) fn short_type_name<T: ?Sized>() -> String {
+    let full_name = type_name::<T>();
+
+    // Generics result in nested paths within <..> blocks.
+    // Consider "core::option::Option<alloc::string::String>".
+    // To tackle this, we parse the string from left to right, collapsing as we go.
+    let mut index: usize = 0;
+    let end_of_string = full_name.len();
+    let mut parsed_name = String::new();
+
+    while index < end_of_string {
+        let rest_of_string = full_name.get(index..end_of_string).unwrap_or_default();
+
+        // Collapse everything up to the next special character,
+        // then skip over it
+        if let Some(special_character_index) =
+            rest_of_string.find(|c: char| [' ', '<', '>', '(', ')', '[', ']', ',', ';'].contains(&c))
+        {
+            let segment_to_collapse = rest_of_string.get(0..special_character_index).unwrap_or_default();
+            parsed_name += collapse_type_name(segment_to_collapse);
+            // Insert the special character
+            let special_character = &rest_of_string[special_character_index..=special_character_index];
+            parsed_name.push_str(special_character);
+
+            match special_character {
+                ">" | ")" | "]" if rest_of_string[special_character_index + 1..].starts_with("::") => {
+                    parsed_name.push_str("::");
+                    // Move the index past the "::"
+                    index += special_character_index + 3;
+                }
+                // Move the index just past the special character
+                _ => index += special_character_index + 1,
+            }
+        } else {
+            // If there are no special characters left, we're done!
+            parsed_name += collapse_type_name(rest_of_string);
+            index = end_of_string;
+        }
+    }
+    parsed_name
+}
+
+#[inline(always)]
+fn collapse_type_name(string: &str) -> &str {
+    string.rsplit("::").next().unwrap()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::short_type_name;
+    use std::collections::HashMap;
+
+    #[test]
+    fn tests() {
+        assert_eq!(short_type_name::<String>(), "String");
+        assert_eq!(short_type_name::<Option<String>>(), "Option<String>");
+        assert_eq!(short_type_name::<(String, &str)>(), "(String, &str)");
+        assert_eq!(short_type_name::<[i32; 3]>(), "[i32; 3]");
+        assert_eq!(
+            short_type_name::<HashMap<String, Option<[i32; 3]>>>(),
+            "HashMap<String, Option<[i32; 3]>>"
+        );
+        assert_eq!(short_type_name::<dyn Fn(i32) -> i32>(), "dyn Fn(i32) -> i32");
+    }
+}
@@ -0,0 +1,82 @@
+use std::any::Any;
+use std::os::raw::c_void;
+
+use crate::types::{Callback, CallbackUpvalue};
+
+#[cfg(feature = "async")]
+use crate::types::{AsyncCallback, AsyncCallbackUpvalue, AsyncPollUpvalue};
+
+pub(crate) trait TypeKey: Any {
+    fn type_key() -> *const c_void;
+}
+
+static STRING_TYPE_KEY: u8 = 0;
+
+impl TypeKey for String {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &STRING_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+static CALLBACK_TYPE_KEY: u8 = 0;
+
+impl TypeKey for Callback<'static> {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &CALLBACK_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+static CALLBACK_UPVALUE_TYPE_KEY: u8 = 0;
+
+impl TypeKey for CallbackUpvalue {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &CALLBACK_UPVALUE_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+#[cfg(feature = "async")]
+static ASYNC_CALLBACK_TYPE_KEY: u8 = 0;
+
+#[cfg(feature = "async")]
+impl TypeKey for AsyncCallback<'static> {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &ASYNC_CALLBACK_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+#[cfg(feature = "async")]
+static ASYNC_CALLBACK_UPVALUE_TYPE_KEY: u8 = 0;
+
+#[cfg(feature = "async")]
+impl TypeKey for AsyncCallbackUpvalue {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &ASYNC_CALLBACK_UPVALUE_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+#[cfg(feature = "async")]
+static ASYNC_POLL_UPVALUE_TYPE_KEY: u8 = 0;
+
+#[cfg(feature = "async")]
+impl TypeKey for AsyncPollUpvalue {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &ASYNC_POLL_UPVALUE_TYPE_KEY as *const u8 as *const c_void
+    }
+}
+
+#[cfg(feature = "async")]
+static WAKER_TYPE_KEY: u8 = 0;
+
+#[cfg(feature = "async")]
+impl TypeKey for Option<std::task::Waker> {
+    #[inline(always)]
+    fn type_key() -> *const c_void {
+        &WAKER_TYPE_KEY as *const u8 as *const c_void
+    }
+}
@@ -0,0 +1,380 @@
+use std::ffi::CStr;
+use std::os::raw::{c_int, c_void};
+use std::{ptr, str};
+
+use crate::error::Result;
+use crate::util::{check_stack, push_string, push_table, rawset_field, TypeKey};
+
+// Pushes the userdata and attaches a metatable with __gc method.
+// Internally uses 3 stack spaces, does not call checkstack.
+pub(crate) unsafe fn push_internal_userdata<T: TypeKey>(
+    state: *mut ffi::lua_State,
+    t: T,
+    protect: bool,
+) -> Result<()> {
+    push_userdata(state, t, protect)?;
+    get_internal_metatable::<T>(state);
+    ffi::lua_setmetatable(state, -2);
+    Ok(())
+}
+
+#[track_caller]
+pub(crate) unsafe fn get_internal_metatable<T: TypeKey>(state: *mut ffi::lua_State) {
+    ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, T::type_key());
+    debug_assert!(ffi::lua_isnil(state, -1) == 0, "internal metatable not found");
+}
+
+// Initialize the internal metatable for a type T (with __gc method).
+// Uses 6 stack spaces and calls checkstack.
+pub(crate) unsafe fn init_internal_metatable<T: TypeKey>(
+    state: *mut ffi::lua_State,
+    customize_fn: Option<fn(*mut ffi::lua_State) -> Result<()>>,
+) -> Result<()> {
+    check_stack(state, 6)?;
+
+    push_table(state, 0, 3, true)?;
+
+    #[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")?;
+
+    if let Some(f) = customize_fn {
+        f(state)?;
+    }
+
+    protect_lua!(state, 1, 0, |state| {
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, T::type_key());
+    })?;
+
+    Ok(())
+}
+
+// Uses 2 stack spaces, does not call checkstack
+pub(crate) unsafe fn get_internal_userdata<T: TypeKey>(
+    state: *mut ffi::lua_State,
+    index: c_int,
+    type_mt_ptr: *const c_void,
+) -> *mut T {
+    let ud = ffi::lua_touserdata(state, index) as *mut T;
+    if ud.is_null() || ffi::lua_getmetatable(state, index) == 0 {
+        return ptr::null_mut();
+    }
+    if !type_mt_ptr.is_null() {
+        let ud_mt_ptr = ffi::lua_topointer(state, -1);
+        ffi::lua_pop(state, 1);
+        if ud_mt_ptr != type_mt_ptr {
+            return ptr::null_mut();
+        }
+    } else {
+        get_internal_metatable::<T>(state);
+        let res = ffi::lua_rawequal(state, -1, -2);
+        ffi::lua_pop(state, 2);
+        if res == 0 {
+            return ptr::null_mut();
+        }
+    }
+    ud
+}
+
+// Internally uses 3 stack spaces, does not call checkstack.
+#[inline]
+pub(crate) unsafe fn push_userdata<T>(state: *mut ffi::lua_State, t: T, protect: bool) -> Result<()> {
+    #[cfg(not(feature = "luau"))]
+    let ud = if protect {
+        protect_lua!(state, 0, 1, |state| {
+            ffi::lua_newuserdata(state, std::mem::size_of::<T>()) as *mut T
+        })?
+    } else {
+        ffi::lua_newuserdata(state, std::mem::size_of::<T>()) as *mut T
+    };
+    #[cfg(feature = "luau")]
+    let ud = if protect {
+        protect_lua!(state, 0, 1, |state| { ffi::lua_newuserdata_t::<T>(state) })?
+    } else {
+        ffi::lua_newuserdata_t::<T>(state)
+    };
+    ptr::write(ud, t);
+    Ok(())
+}
+
+// Internally uses 3 stack spaces, does not call checkstack.
+#[cfg(feature = "lua54")]
+#[inline]
+pub(crate) unsafe fn push_userdata_uv<T>(
+    state: *mut ffi::lua_State,
+    t: T,
+    nuvalue: c_int,
+    protect: bool,
+) -> Result<()> {
+    let ud = if protect {
+        protect_lua!(state, 0, 1, |state| {
+            ffi::lua_newuserdatauv(state, std::mem::size_of::<T>(), nuvalue) as *mut T
+        })?
+    } else {
+        ffi::lua_newuserdatauv(state, std::mem::size_of::<T>(), nuvalue) as *mut T
+    };
+    ptr::write(ud, t);
+    Ok(())
+}
+
+#[inline]
+pub(crate) 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");
+    ud
+}
+
+// Pops the userdata off of the top of the stack and returns it to rust, invalidating the lua
+// userdata and gives it the special "destructed" userdata metatable. Userdata must not have been
+// previously invalidated, and this method does not check for this.
+// Uses 1 extra stack space and does not call checkstack.
+pub(crate) unsafe fn take_userdata<T>(state: *mut ffi::lua_State) -> T {
+    // We set the metatable of userdata on __gc to a special table with no __gc method and with
+    // metamethods that trigger an error on access. We do this so that it will not be double
+    // dropped, and also so that it cannot be used or identified as any particular userdata type
+    // after the first call to __gc.
+    get_destructed_userdata_metatable(state);
+    ffi::lua_setmetatable(state, -2);
+    let ud = get_userdata::<T>(state, -1);
+
+    // Update userdata tag to disable destructor and mark as destructed
+    #[cfg(feature = "luau")]
+    ffi::lua_setuserdatatag(state, -1, 1);
+
+    ffi::lua_pop(state, 1);
+    ptr::read(ud)
+}
+
+pub(crate) unsafe fn get_destructed_userdata_metatable(state: *mut ffi::lua_State) {
+    let key = &DESTRUCTED_USERDATA_METATABLE as *const u8 as *const c_void;
+    ffi::lua_rawgetp(state, ffi::LUA_REGISTRYINDEX, 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. The function also, if given a `field_getters` or `methods` tables, will create an
+// `__index` metamethod (capturing previous one) to lookup in `field_getters` first, then `methods`
+// and falling back to the captured `__index` if no matches found.
+// The same is also applicable for `__newindex` metamethod and `field_setters` table.
+// Internally uses 9 stack spaces and does not call checkstack.
+pub(crate) unsafe fn init_userdata_metatable(
+    state: *mut ffi::lua_State,
+    metatable: c_int,
+    field_getters: Option<c_int>,
+    field_setters: Option<c_int>,
+    methods: Option<c_int>,
+    extra_init: Option<fn(*mut ffi::lua_State) -> Result<()>>,
+) -> Result<()> {
+    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, b"__index", true)?;
+        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] {
+                    if let Some(idx) = idx {
+                        ffi::lua_pushvalue(state, idx);
+                    } else {
+                        ffi::lua_pushnil(state);
+                    }
+                }
+
+                // Generate `__index`
+                protect_lua!(state, 4, 1, fn(state) ffi::lua_call(state, 3, 1))?;
+            }
+            _ => mlua_panic!("improper __index type {}", index_type),
+        }
+
+        rawset_field(state, -2, "__index")?;
+    }
+
+    if let Some(field_setters) = field_setters {
+        // Push `__newindex` generator function
+        init_userdata_metatable_newindex(state)?;
+
+        push_string(state, b"__newindex", true)?;
+        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);
+                // Generate `__newindex`
+                protect_lua!(state, 3, 1, fn(state) ffi::lua_call(state, 2, 1))?;
+            }
+            _ => mlua_panic!("improper __newindex type {}", newindex_type),
+        }
+
+        rawset_field(state, -2, "__newindex")?;
+    }
+
+    // Additional initialization
+    if let Some(extra_init) = extra_init {
+        extra_init(state)?;
+    }
+
+    ffi::lua_pushboolean(state, 0);
+    rawset_field(state, -2, "__metatable")?;
+
+    ffi::lua_pop(state, 1);
+
+    Ok(())
+}
+
+unsafe extern "C-unwind" fn lua_error_impl(state: *mut ffi::lua_State) -> c_int {
+    ffi::lua_error(state);
+}
+
+unsafe extern "C-unwind" fn lua_isfunction_impl(state: *mut ffi::lua_State) -> c_int {
+    ffi::lua_pushboolean(state, ffi::lua_isfunction(state, -1));
+    1
+}
+
+unsafe extern "C-unwind" fn lua_istable_impl(state: *mut ffi::lua_State) -> c_int {
+    ffi::lua_pushboolean(state, ffi::lua_istable(state, -1));
+    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` generator
+    let code = cstr!(
+        r#"
+            local error, isfunction, istable = ...
+            return function (__index, field_getters, methods)
+                -- Common case: has field getters and index is a table
+                if field_getters ~= nil and methods == nil and istable(__index) then
+                    return function (self, key)
+                        local field_getter = field_getters[key]
+                        if field_getter ~= nil then
+                            return field_getter(self)
+                        end
+                        return __index[key]
+                    end
+                end
+
+                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_pushcfunction(state, lua_istable_impl);
+        ffi::lua_call(state, 3, 1);
+
+        #[cfg(feature = "luau-jit")]
+        if ffi::luau_codegen_supported() != 0 {
+            ffi::luau_codegen_compile(state, -1);
+        }
+
+        // Store in the registry
+        ffi::lua_pushvalue(state, -1);
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, index_key);
+    })
+}
+
+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` generator
+    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);
+
+        #[cfg(feature = "luau-jit")]
+        if ffi::luau_codegen_supported() != 0 {
+            ffi::luau_codegen_compile(state, -1);
+        }
+
+        // Store in the registry
+        ffi::lua_pushvalue(state, -1);
+        ffi::lua_rawsetp(state, ffi::LUA_REGISTRYINDEX, newindex_key);
+    })
+}
+
+#[cfg(not(feature = "luau"))]
+pub(crate) unsafe extern "C-unwind" fn userdata_destructor<T>(state: *mut ffi::lua_State) -> c_int {
+    // 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
+}
+
+pub(crate) static DESTRUCTED_USERDATA_METATABLE: u8 = 0;
+static USERDATA_METATABLE_INDEX: u8 = 0;
+static USERDATA_METATABLE_NEWINDEX: u8 = 0;
--- a/Show More
+++ b/Show More