diff --git a/src/error.rs b/src/error.rs
index 6d13a91e..47915af7 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -96,8 +96,8 @@ pub enum Error {
     /// [`Thread::status`] can be used to check if the coroutine can be resumed without causing this
     /// error.
     ///
-    /// [`Thread::resume`]: struct.Thread.html#method.resume
-    /// [`Thread::status`]: struct.Thread.html#method.status
+    /// [`Thread::resume`]: crate::Thread::resume
+    /// [`Thread::status`]: crate::Thread::status
     CoroutineInactive,
     /// An [`AnyUserData`] is not the expected type in a borrow.
     ///
@@ -105,15 +105,15 @@ pub enum Error {
     /// metamethods for binary operators. Refer to the documentation of [`UserDataMethods`] for
     /// details.
     ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
-    /// [`UserDataMethods`]: trait.UserDataMethods.html
+    /// [`AnyUserData`]: crate::AnyUserData
+    /// [`UserDataMethods`]: crate::UserDataMethods
     UserDataTypeMismatch,
     /// An [`AnyUserData`] borrow failed because it has been destructed.
     ///
     /// This error can happen either due to to being destructed in a previous __gc, or due to being
     /// destructed from exiting a `Lua::scope` call.
     ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
     UserDataDestructed,
     /// An [`AnyUserData`] immutable borrow failed because it is already borrowed mutably.
     ///
@@ -121,8 +121,8 @@ pub enum Error {
     /// tries to call a method on the same [`UserData`] type. Consider restructuring your API to
     /// prevent these errors.
     ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
-    /// [`UserData`]: trait.UserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
+    /// [`UserData`]: crate::UserData
     UserDataBorrowError,
     /// An [`AnyUserData`] mutable borrow failed because it is already borrowed.
     ///
@@ -130,22 +130,24 @@ pub enum Error {
     /// tries to call a method on the same [`UserData`] type. Consider restructuring your API to
     /// prevent these errors.
     ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
-    /// [`UserData`]: trait.UserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
+    /// [`UserData`]: crate::UserData
     UserDataBorrowMutError,
     /// A [`MetaMethod`] operation is restricted (typically for `__gc` or `__metatable`).
     ///
-    /// [`MetaMethod`]: enum.MetaMethod.html
+    /// [`MetaMethod`]: crate::MetaMethod
     MetaMethodRestricted(StdString),
     /// A [`MetaMethod`] (eg. `__index` or `__newindex`) has invalid type.
     ///
-    /// [`MetaMethod`]: enum.MetaMethod.html
+    /// [`MetaMethod`]: crate::MetaMethod
     MetaMethodTypeError {
         method: StdString,
         type_name: &'static str,
         message: Option<StdString>,
     },
-    /// A `RegistryKey` produced from a different Lua state was used.
+    /// A [`RegistryKey`] produced from a different Lua state was used.
+    ///
+    /// [`RegistryKey`]: crate::RegistryKey
     MismatchedRegistryKey,
     /// A Rust callback returned `Err`, raising the contained `Error` as a Lua error.
     CallbackError {
diff --git a/src/function.rs b/src/function.rs
index 966533c2..f87d52c2 100644
--- a/src/function.rs
+++ b/src/function.rs
@@ -116,7 +116,7 @@ impl<'lua> Function<'lua> {
     /// # }
     /// ```
     ///
-    /// [`AsyncThread`]: struct.AsyncThread.html
+    /// [`AsyncThread`]: crate::AsyncThread
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
     pub fn call_async<'fut, A, R>(&self, args: A) -> LocalBoxFuture<'fut, Result<R>>
diff --git a/src/hook.rs b/src/hook.rs
index 03dc245c..ed1fcf32 100644
--- a/src/hook.rs
+++ b/src/hook.rs
@@ -15,7 +15,7 @@ use crate::util::callback_error;
 /// found in the [Lua 5.3 documentation][lua_doc].
 ///
 /// [lua_doc]: https://www.lua.org/manual/5.3/manual.html#lua_Debug
-/// [`Lua::set_hook`]: struct.Lua.html#method.set_hook
+/// [`Lua::set_hook`]: crate::Lua::set_hook
 #[derive(Clone)]
 pub struct Debug<'a> {
     ar: *mut lua_Debug,
diff --git a/src/lib.rs b/src/lib.rs
index 7d54b6dd..60260f0f 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -50,24 +50,24 @@
 //! to [`Function`]s and [`UserData`].
 //!
 //! [Lua programming language]: https://www.lua.org/
-//! [`Lua`]: struct.Lua.html
-//! [executing]: struct.Chunk.html#method.exec
-//! [evaluating]: struct.Chunk.html#method.eval
-//! [globals]: struct.Lua.html#method.globals
-//! [`ToLua`]: trait.ToLua.html
-//! [`FromLua`]: trait.FromLua.html
-//! [`ToLuaMulti`]: trait.ToLuaMulti.html
-//! [`FromLuaMulti`]: trait.FromLuaMulti.html
-//! [`Function`]: struct.Function.html
-//! [`UserData`]: trait.UserData.html
-//! [`UserDataFields`]: trait.UserDataFields.html
-//! [`UserDataMethods`]: trait.UserDataMethods.html
-//! [`LuaSerdeExt`]: serde/trait.LuaSerdeExt.html
-//! [`Value`]: enum.Value.html
-//! [`create_async_function`]: struct.Lua.html#method.create_async_function
-//! [`call_async`]: struct.Function.html#method.call_async
-//! [`AsyncThread`]: struct.AsyncThread.html
-//! [`Future`]: ../futures_core/future/trait.Future.html
+//! [`Lua`]: crate::Lua
+//! [executing]: crate::Chunk::exec
+//! [evaluating]: crate::Chunk::eval
+//! [globals]: crate::Lua::globals
+//! [`ToLua`]: crate::ToLua
+//! [`FromLua`]: crate::FromLua
+//! [`ToLuaMulti`]: crate::ToLuaMulti
+//! [`FromLuaMulti`]: crate::FromLuaMulti
+//! [`Function`]: crate::Function
+//! [`UserData`]: crate::UserData
+//! [`UserDataFields`]: crate::UserDataFields
+//! [`UserDataMethods`]: crate::UserDataMethods
+//! [`LuaSerdeExt`]: crate::LuaSerdeExt
+//! [`Value`]: crate::Value
+//! [`create_async_function`]: crate::Lua::create_async_function
+//! [`call_async`]: crate::Function::call_async
+//! [`AsyncThread`]: crate::AsyncThread
+//! [`Future`]: std::future::Future
 //! [`serde::Serialize`]: https://docs.serde.rs/serde/ser/trait.Serialize.html
 //! [`serde::Deserialize`]: https://docs.serde.rs/serde/de/trait.Deserialize.html
 
@@ -98,6 +98,8 @@ mod userdata;
 mod util;
 mod value;
 
+pub mod prelude;
+
 pub use crate::{ffi::lua_CFunction, ffi::lua_State};
 
 pub use crate::error::{Error, ExternalError, ExternalResult, Result};
@@ -120,13 +122,11 @@ pub use crate::value::{FromLua, FromLuaMulti, MultiValue, Nil, ToLua, ToLuaMulti
 pub use crate::thread::AsyncThread;
 
 #[cfg(feature = "serialize")]
-#[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
 #[doc(inline)]
 pub use crate::serde::{
     de::Options as DeserializeOptions, ser::Options as SerializeOptions, LuaSerdeExt,
 };
 
-pub mod prelude;
 #[cfg(feature = "serialize")]
 #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
 pub mod serde;
@@ -185,9 +185,9 @@ extern crate mlua_derive;
 ///
 /// Everything else should work.
 ///
-/// [`AsChunk`]: trait.AsChunk.html
-/// [`UserData`]: trait.UserData.html
-/// [`ToLua`]: trait.ToLua.html
+/// [`AsChunk`]: crate::AsChunk
+/// [`UserData`]: crate::UserData
+/// [`ToLua`]: crate::ToLua
 #[cfg(any(feature = "macros"))]
 #[cfg_attr(docsrs, doc(cfg(feature = "macros")))]
 pub use mlua_derive::chunk;
diff --git a/src/lua.rs b/src/lua.rs
index 31317531..3e01a139 100644
--- a/src/lua.rs
+++ b/src/lua.rs
@@ -210,7 +210,7 @@ impl Lua {
     ///
     /// See [`StdLib`] documentation for a list of unsafe modules that cannot be loaded.
     ///
-    /// [`StdLib`]: struct.StdLib.html
+    /// [`StdLib`]: crate::StdLib
     #[allow(clippy::new_without_default)]
     pub fn new() -> Lua {
         mlua_expect!(
@@ -237,7 +237,7 @@ impl Lua {
     ///
     /// See [`StdLib`] documentation for a list of unsafe modules that cannot be loaded.
     ///
-    /// [`StdLib`]: struct.StdLib.html
+    /// [`StdLib`]: crate::StdLib
     pub fn new_with(libs: StdLib, options: LuaOptions) -> Result<Lua> {
         if libs.contains(StdLib::DEBUG) {
             return Err(Error::SafetyError(
@@ -271,7 +271,7 @@ impl Lua {
     /// # Safety
     /// The created Lua state will not have safety guarantees and allow to load C modules.
     ///
-    /// [`StdLib`]: struct.StdLib.html
+    /// [`StdLib`]: crate::StdLib
     pub unsafe fn unsafe_new_with(libs: StdLib, options: LuaOptions) -> Lua {
         ffi::keep_lua_symbols();
         Self::inner_new(libs, options)
@@ -513,7 +513,7 @@ impl Lua {
     ///
     /// Use the [`StdLib`] flags to specify the libraries you want to load.
     ///
-    /// [`StdLib`]: struct.StdLib.html
+    /// [`StdLib`]: crate::StdLib
     pub fn load_from_std_lib(&self, libs: StdLib) -> Result<()> {
         if self.safe && libs.contains(StdLib::DEBUG) {
             return Err(Error::SafetyError(
@@ -700,8 +700,8 @@ impl Lua {
     /// # }
     /// ```
     ///
-    /// [`HookTriggers`]: struct.HookTriggers.html
-    /// [`HookTriggers.every_nth_instruction`]: struct.HookTriggers.html#field.every_nth_instruction
+    /// [`HookTriggers`]: crate::HookTriggers
+    /// [`HookTriggers.every_nth_instruction`]: crate::HookTriggers::every_nth_instruction
     pub fn set_hook<F>(&self, triggers: HookTriggers, callback: F) -> Result<()>
     where
         F: 'static + MaybeSend + FnMut(&Lua, Debug) -> Result<()>,
@@ -906,10 +906,11 @@ impl Lua {
     /// similar on the returned builder. Code is not even parsed until one of these methods is
     /// called.
     ///
-    /// If this `Lua` was created with `unsafe_new`, `load` will automatically detect and load
+    /// If this `Lua` was created with [`unsafe_new`], `load` will automatically detect and load
     /// chunks of either text or binary type, as if passing `bt` mode to `luaL_loadbufferx`.
     ///
-    /// [`Chunk::exec`]: struct.Chunk.html#method.exec
+    /// [`Chunk::exec`]: crate::Chunk::exec
+    /// [`unsafe_new`]: #method.unsafe_new
     #[track_caller]
     pub fn load<'lua, 'a, S>(&'lua self, source: &'a S) -> Chunk<'lua, 'a>
     where
@@ -1105,8 +1106,8 @@ impl Lua {
     /// # }
     /// ```
     ///
-    /// [`ToLua`]: trait.ToLua.html
-    /// [`ToLuaMulti`]: trait.ToLuaMulti.html
+    /// [`ToLua`]: crate::ToLua
+    /// [`ToLuaMulti`]: crate::ToLuaMulti
     pub fn create_function<'lua, 'callback, A, R, F>(&'lua self, func: F) -> Result<Function<'lua>>
     where
         'lua: 'callback,
@@ -1191,8 +1192,8 @@ impl Lua {
     /// }
     /// ```
     ///
-    /// [`Thread`]: struct.Thread.html
-    /// [`AsyncThread`]: struct.AsyncThread.html
+    /// [`Thread`]: crate::Thread
+    /// [`AsyncThread`]: crate::AsyncThread
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
     pub fn create_async_function<'lua, 'callback, A, R, F, FR>(
@@ -1484,7 +1485,7 @@ impl Lua {
     /// Be warned, garbage collection of values held inside the registry is not automatic, see
     /// [`RegistryKey`] for more details.
     ///
-    /// [`RegistryKey`]: struct.RegistryKey.html
+    /// [`RegistryKey`]: crate::RegistryKey
     pub fn create_registry_value<'lua, T: ToLua<'lua>>(&'lua self, t: T) -> Result<RegistryKey> {
         let t = t.to_lua(self)?;
         unsafe {
@@ -2206,7 +2207,7 @@ impl Lua {
 
 /// Returned from [`Lua::load`] and is used to finalize loading and executing Lua main chunks.
 ///
-/// [`Lua::load`]: struct.Lua.html#method.load
+/// [`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> {
     lua: &'lua Lua,
@@ -2226,7 +2227,7 @@ pub enum ChunkMode {
 /// Trait for types [loadable by Lua] and convertible to a [`Chunk`]
 ///
 /// [loadable by Lua]: https://www.lua.org/manual/5.3/manual.html#3.3.2
-/// [`Chunk`]: struct.Chunk.html
+/// [`Chunk`]: crate::Chunk
 pub trait AsChunk<'lua> {
     /// Returns chunk data (can be text or binary)
     fn source(&self) -> &[u8];
@@ -2284,7 +2285,7 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
     /// Lua does not check the consistency of binary chunks, therefore this mode is allowed only
     /// for instances created with [`Lua::unsafe_new`].
     ///
-    /// [`Lua::unsafe_new`]: struct.Lua.html#method.unsafe_new
+    /// [`Lua::unsafe_new`]: crate::Lua::unsafe_new
     pub fn set_mode(mut self, mode: ChunkMode) -> Chunk<'lua, 'a> {
         self.mode = Some(mode);
         self
@@ -2300,11 +2301,11 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
 
     /// Asynchronously execute this chunk of code.
     ///
-    /// See [`Chunk::exec`] for more details.
+    /// See [`exec`] for more details.
     ///
     /// Requires `feature = "async"`
     ///
-    /// [`Chunk::exec`]: struct.Chunk.html#method.exec
+    /// [`exec`]: #method.exec
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
     pub fn exec_async<'fut>(self) -> LocalBoxFuture<'fut, Result<()>>
@@ -2340,11 +2341,11 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
 
     /// Asynchronously evaluate the chunk as either an expression or block.
     ///
-    /// See [`Chunk::eval`] for more details.
+    /// See [`eval`] for more details.
     ///
     /// Requires `feature = "async"`
     ///
-    /// [`Chunk::eval`]: struct.Chunk.html#method.eval
+    /// [`eval`]: #method.eval
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
     pub fn eval_async<'fut, R>(self) -> LocalBoxFuture<'fut, Result<R>>
@@ -2378,11 +2379,11 @@ impl<'lua, 'a> Chunk<'lua, 'a> {
 
     /// Load the chunk function and asynchronously call it with the given arguments.
     ///
-    /// See [`Chunk::call`] for more details.
+    /// See [`call`] for more details.
     ///
     /// Requires `feature = "async"`
     ///
-    /// [`Chunk::call`]: struct.Chunk.html#method.call
+    /// [`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>>
diff --git a/src/multi.rs b/src/multi.rs
index 07f2fdc4..3377d355 100644
--- a/src/multi.rs
+++ b/src/multi.rs
@@ -76,8 +76,8 @@ impl<'lua> FromLuaMulti<'lua> for MultiValue<'lua> {
 /// # }
 /// ```
 ///
-/// [`FromLua`]: trait.FromLua.html
-/// [`MultiValue`]: struct.MultiValue.html
+/// [`FromLua`]: crate::FromLua
+/// [`MultiValue`]: crate::MultiValue
 #[derive(Debug, Clone)]
 pub struct Variadic<T>(Vec<T>);
 
diff --git a/src/prelude.rs b/src/prelude.rs
index f04f2a78..8cbb2fd7 100644
--- a/src/prelude.rs
+++ b/src/prelude.rs
@@ -1,5 +1,6 @@
 //! Re-exports most types with an extra `Lua*` prefix to prevent name clashes.
 
+#[doc(no_inline)]
 pub use crate::{
     AnyUserData as LuaAnyUserData, Chunk as LuaChunk, Error as LuaError,
     ExternalError as LuaExternalError, ExternalResult as LuaExternalResult, FromLua, FromLuaMulti,
@@ -14,10 +15,11 @@ pub use crate::{
 };
 
 #[cfg(feature = "async")]
+#[doc(no_inline)]
 pub use crate::AsyncThread as LuaAsyncThread;
 
 #[cfg(feature = "serialize")]
-#[doc(inline)]
+#[doc(no_inline)]
 pub use crate::{
     DeserializeOptions as LuaDeserializeOptions, LuaSerdeExt,
     SerializeOptions as LuaSerializeOptions,
diff --git a/src/scope.rs b/src/scope.rs
index e4fd7224..3b1a93ed 100644
--- a/src/scope.rs
+++ b/src/scope.rs
@@ -35,7 +35,7 @@ use {
 ///
 /// See [`Lua::scope`] for more details.
 ///
-/// [`Lua::scope`]: struct.Lua.html#method.scope
+/// [`Lua::scope`]: crate::Lua.html::scope
 pub struct Scope<'lua, 'scope> {
     lua: &'lua Lua,
     destructors: RefCell<Vec<(LuaRef<'lua>, DestructorCallback<'lua>)>>,
@@ -58,8 +58,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
     /// This is a version of [`Lua::create_function`] that creates a callback which expires on
     /// scope drop. See [`Lua::scope`] for more details.
     ///
-    /// [`Lua::create_function`]: struct.Lua.html#method.create_function
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
+    /// [`Lua::create_function`]: crate::Lua::create_function
+    /// [`Lua::scope`]: crate::Lua::scope
     pub fn create_function<'callback, A, R, F>(&'callback self, func: F) -> Result<Function<'lua>>
     where
         A: FromLuaMulti<'callback>,
@@ -87,8 +87,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
     /// This is a version of [`Lua::create_function_mut`] that creates a callback which expires
     /// on scope drop. See [`Lua::scope`] and [`Scope::create_function`] for more details.
     ///
-    /// [`Lua::create_function_mut`]: struct.Lua.html#method.create_function_mut
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
+    /// [`Lua::create_function_mut`]: crate::Lua::create_function_mut
+    /// [`Lua::scope`]: crate::Lua::scope
     /// [`Scope::create_function`]: #method.create_function
     pub fn create_function_mut<'callback, A, R, F>(
         &'callback self,
@@ -114,9 +114,9 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
     ///
     /// Requires `feature = "async"`
     ///
-    /// [`Lua::create_async_function`]: struct.Lua.html#method.create_async_function
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
-    /// [`Lua::async_scope`]: struct.Lua.html#method.async_scope
+    /// [`Lua::create_async_function`]: crate::Lua::create_async_function
+    /// [`Lua::scope`]: crate::Lua::scope
+    /// [`Lua::async_scope`]: crate::Lua::async_scope
     #[cfg(feature = "async")]
     #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
     pub fn create_async_function<'callback, A, R, F, FR>(
@@ -147,8 +147,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
     /// UserData be 'static).
     /// See [`Lua::scope`] for more details.
     ///
-    /// [`Lua::create_userdata`]: struct.Lua.html#method.create_userdata
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
+    /// [`Lua::create_userdata`]: crate::Lua::create_userdata
+    /// [`Lua::scope`]: crate::Lua::scope
     pub fn create_userdata<T>(&self, data: T) -> Result<AnyUserData<'lua>>
     where
         T: 'static + UserData,
@@ -165,8 +165,8 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
     ///
     /// Requires `feature = "serialize"`
     ///
-    /// [`Lua::create_ser_userdata`]: struct.Lua.html#method.create_ser_userdata
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
+    /// [`Lua::create_ser_userdata`]: crate::Lua::create_ser_userdata
+    /// [`Lua::scope`]: crate::Lua::scope
     #[cfg(feature = "serialize")]
     #[cfg_attr(docsrs, doc(cfg(feature = "serialize")))]
     pub fn create_ser_userdata<T>(&self, data: T) -> Result<AnyUserData<'lua>>
@@ -234,9 +234,9 @@ impl<'lua, 'scope> Scope<'lua, 'scope> {
     /// creating the userdata metatable each time a new userdata is created.
     ///
     /// [`Scope::create_userdata`]: #method.create_userdata
-    /// [`Lua::create_userdata`]: struct.Lua.html#method.create_userdata
-    /// [`Lua::scope`]: struct.Lua.html#method.scope
-    /// [`UserDataMethods`]: trait.UserDataMethods.html
+    /// [`Lua::create_userdata`]: crate::Lua::create_userdata
+    /// [`Lua::scope`]:crate::Lua::scope
+    /// [`UserDataMethods`]: crate::UserDataMethods
     pub fn create_nonstatic_userdata<T>(&self, data: T) -> Result<AnyUserData<'lua>>
     where
         T: 'scope + UserData,
diff --git a/src/serde/de.rs b/src/serde/de.rs
index da7fa858..c77ca44d 100644
--- a/src/serde/de.rs
+++ b/src/serde/de.rs
@@ -23,11 +23,16 @@ 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`
-    /// and `Error` will cause an error.
+    /// If true, an attempt to serialize types such as [`Thread`], [`UserData`], [`LightUserData`]
+    /// and [`Error`] will cause an error.
     /// Otherwise these types skipped when iterating or serialized as unit type.
     ///
     /// Default: **true**
+    ///
+    /// [`Thread`]: crate::Thread
+    /// [`UserData`]: crate::UserData
+    /// [`LightUserData`]: crate::LightUserData
+    /// [`Error`]: crate::Error
     pub deny_unsupported_types: bool,
 
     /// If true, an attempt to serialize a recursive table (table that refers to itself)
diff --git a/src/serde/mod.rs b/src/serde/mod.rs
index 1e37c05e..93c592fe 100644
--- a/src/serde/mod.rs
+++ b/src/serde/mod.rs
@@ -69,11 +69,11 @@ pub trait LuaSerdeExt<'lua> {
     /// ```
     fn array_metatable(&'lua self) -> Table<'lua>;
 
-    /// Converts `T` into a `Value` instance.
+    /// Converts `T` into a [`Value`] instance.
     ///
     /// Requires `feature = "serialize"`
     ///
-    /// [`Value`]: enum.Value.html
+    /// [`Value`]: crate::Value
     ///
     /// # Example
     ///
@@ -102,11 +102,11 @@ pub trait LuaSerdeExt<'lua> {
     /// ```
     fn to_value<T: Serialize + ?Sized>(&'lua self, t: &T) -> Result<Value<'lua>>;
 
-    /// Converts `T` into a `Value` instance with options.
+    /// Converts `T` into a [`Value`] instance with options.
     ///
     /// Requires `feature = "serialize"`
     ///
-    /// [`Value`]: enum.Value.html
+    /// [`Value`]: crate::Value
     ///
     /// # Example
     ///
@@ -129,11 +129,11 @@ pub trait LuaSerdeExt<'lua> {
     where
         T: Serialize + ?Sized;
 
-    /// Deserializes a `Value` into any serde deserializable object.
+    /// Deserializes a [`Value`] into any serde deserializable object.
     ///
     /// Requires `feature = "serialize"`
     ///
-    /// [`Value`]: enum.Value.html
+    /// [`Value`]: crate::Value
     ///
     /// # Example
     ///
@@ -159,11 +159,11 @@ pub trait LuaSerdeExt<'lua> {
     /// ```
     fn from_value<T: Deserialize<'lua>>(&'lua self, value: Value<'lua>) -> Result<T>;
 
-    /// Deserializes a `Value` into any serde deserializable object with options.
+    /// Deserializes a [`Value`] into any serde deserializable object with options.
     ///
     /// Requires `feature = "serialize"`
     ///
-    /// [`Value`]: enum.Value.html
+    /// [`Value`]: crate::Value
     ///
     /// # Example
     ///
diff --git a/src/serde/ser.rs b/src/serde/ser.rs
index 8f0cf8fa..e0371e18 100644
--- a/src/serde/ser.rs
+++ b/src/serde/ser.rs
@@ -28,16 +28,16 @@ pub struct Options {
     ///
     /// Default: **true**
     ///
-    /// [`array_metatable`]: ../trait.LuaSerdeExt.html#tymethod.array_metatable
+    /// [`array_metatable`]: crate::LuaSerdeExt::array_metatable
     pub set_array_metatable: bool,
 
-    /// If true, serialize `None` (part of `Option` type) to [`null`].
+    /// If true, serialize `None` (part of the `Option` type) to [`null`].
     /// Otherwise it will be set to Lua [`Nil`].
     ///
     /// Default: **true**
     ///
-    /// [`null`]: ../trait.LuaSerdeExt.html#tymethod.null
-    /// [`Nil`]: ../../enum.Value.html#variant.Nil
+    /// [`null`]: crate::LuaSerdeExt::null
+    /// [`Nil`]: crate::Value::Nil
     pub serialize_none_to_null: bool,
 
     /// If true, serialize `Unit` (type of `()` in Rust) and Unit structs to [`null`].
@@ -45,8 +45,8 @@ pub struct Options {
     ///
     /// Default: **true**
     ///
-    /// [`null`]: ../trait.LuaSerdeExt.html#tymethod.null
-    /// [`Nil`]: ../../enum.Value.html#variant.Nil
+    /// [`null`]: crate::LuaSerdeExt::null
+    /// [`Nil`]: crate::Value::Nil
     pub serialize_unit_to_null: bool,
 }
 
@@ -61,7 +61,7 @@ impl Default for Options {
 }
 
 impl Options {
-    /// Returns a new instance of `Options` with default parameters.
+    /// Returns a new instance of [`Options`] with default parameters.
     pub fn new() -> Self {
         Self::default()
     }
diff --git a/src/table.rs b/src/table.rs
index b684060c..4b2cdfd4 100644
--- a/src/table.rs
+++ b/src/table.rs
@@ -378,7 +378,7 @@ impl<'lua> Table<'lua> {
     /// # }
     /// ```
     ///
-    /// [`Result`]: type.Result.html
+    /// [`Result`]: crate::Result
     /// [Lua manual]: http://www.lua.org/manual/5.3/manual.html#pdf-next
     pub fn pairs<K: FromLua<'lua>, V: FromLua<'lua>>(self) -> TablePairs<'lua, K, V> {
         TablePairs {
@@ -427,7 +427,7 @@ impl<'lua> Table<'lua> {
     /// ```
     ///
     /// [`pairs`]: #method.pairs
-    /// [`Result`]: type.Result.html
+    /// [`Result`]: crate::Result
     /// [Lua manual]: http://www.lua.org/manual/5.3/manual.html#pdf-next
     pub fn sequence_values<V: FromLua<'lua>>(self) -> TableSequence<'lua, V> {
         TableSequence {
@@ -645,7 +645,7 @@ impl<'lua> Serialize for Table<'lua> {
 ///
 /// This struct is created by the [`Table::pairs`] method.
 ///
-/// [`Table::pairs`]: struct.Table.html#method.pairs
+/// [`Table::pairs`]: crate::Table::pairs
 pub struct TablePairs<'lua, K, V> {
     table: LuaRef<'lua>,
     key: Option<Value<'lua>>,
@@ -704,7 +704,7 @@ where
 ///
 /// This struct is created by the [`Table::sequence_values`] method.
 ///
-/// [`Table::sequence_values`]: struct.Table.html#method.sequence_values
+/// [`Table::sequence_values`]: crate::Table::sequence_values
 pub struct TableSequence<'lua, V> {
     table: LuaRef<'lua>,
     index: Option<Integer>,
diff --git a/src/thread.rs b/src/thread.rs
index baea9a79..aad1df2d 100644
--- a/src/thread.rs
+++ b/src/thread.rs
@@ -33,7 +33,7 @@ pub enum ThreadStatus {
     ///
     /// If a thread is in this state, it can be resumed by calling [`Thread::resume`].
     ///
-    /// [`Thread::resume`]: struct.Thread.html#method.resume
+    /// [`Thread::resume`]: crate::Thread::resume
     Resumable,
     /// Either the thread has finished executing, or the thread is currently running.
     Unresumable,
@@ -49,8 +49,8 @@ pub struct Thread<'lua>(pub(crate) LuaRef<'lua>);
 ///
 /// Requires `feature = "async"`
 ///
-/// [`Future`]: ../futures_core/future/trait.Future.html
-/// [`Stream`]: ../futures_core/stream/trait.Stream.html
+/// [`Future`]: futures_core::future::Future
+/// [`Stream`]: futures_core::stream::Stream
 #[cfg(feature = "async")]
 #[cfg_attr(docsrs, doc(cfg(feature = "async")))]
 #[derive(Debug)]
@@ -203,10 +203,10 @@ impl<'lua> Thread<'lua> {
         }
     }
 
-    /// Converts Thread to an AsyncThread which implements Future and Stream traits.
+    /// Converts Thread to an AsyncThread which implements [`Future`] and [`Stream`] traits.
     ///
     /// `args` are passed as arguments to the thread function for first call.
-    /// The object call `resume()` while polling and also allows to run rust futures
+    /// The object calls [`resume()`] while polling and also allows to run rust futures
     /// to completion using an executor.
     ///
     /// Using AsyncThread as a Stream allows to iterate through `coroutine.yield()`
@@ -215,6 +215,10 @@ impl<'lua> Thread<'lua> {
     ///
     /// Requires `feature = "async"`
     ///
+    /// [`Future`]: futures_core::future::Future
+    /// [`Stream`]: futures_core::stream::Stream
+    /// [`resume()`]: https://www.lua.org/manual/5.4/manual.html#lua_resume
+    ///
     /// # Examples
     ///
     /// ```
diff --git a/src/types.rs b/src/types.rs
index 677f0e65..799fda48 100644
--- a/src/types.rs
+++ b/src/types.rs
@@ -71,15 +71,17 @@ pub(crate) struct DestructedUserdataMT;
 /// garbage collected on Drop, but it can be removed with [`Lua::remove_registry_value`],
 /// and instances not manually removed can be garbage collected with [`Lua::expire_registry_values`].
 ///
-/// Be warned, If you place this into Lua via a `UserData` type or a rust callback, it is *very
+/// Be warned, If you place this into Lua via a [`UserData`] type or a rust callback, it is *very
 /// easy* to accidentally cause reference cycles that the Lua garbage collector cannot resolve.
-/// Instead of placing a `RegistryKey` into a `UserData` type, prefer instead to use
-/// [`UserData::set_user_value`] / [`UserData::get_user_value`].
+/// Instead of placing a [`RegistryKey`] into a [`UserData`] type, prefer instead to use
+/// [`AnyUserData::set_user_value`] / [`AnyUserData::get_user_value`].
 ///
-/// [`Lua::remove_registry_value`]: struct.Lua.html#method.remove_registry_value
-/// [`Lua::expire_registry_values`]: struct.Lua.html#method.expire_registry_values
-/// [`UserData::set_user_value`]: struct.UserData.html#method.set_user_value
-/// [`UserData::get_user_value`]: struct.UserData.html#method.get_user_value
+/// [`UserData`]: crate::UserData
+/// [`RegistryKey`]: crate::RegistryKey
+/// [`Lua::remove_registry_value`]: crate::Lua::remove_registry_value
+/// [`Lua::expire_registry_values`]: crate::Lua::expire_registry_values
+/// [`AnyUserData::set_user_value`]: crate::AnyUserData::set_user_value
+/// [`AnyUserData::get_user_value`]: crate::AnyUserData::get_user_value
 pub struct RegistryKey {
     pub(crate) registry_id: c_int,
     pub(crate) unref_list: Arc<Mutex<Option<Vec<c_int>>>>,
diff --git a/src/userdata.rs b/src/userdata.rs
index e54eb33e..f6bc0e64 100644
--- a/src/userdata.rs
+++ b/src/userdata.rs
@@ -34,7 +34,7 @@ use crate::types::AsyncCallback;
 /// Currently, this mechanism does not allow overriding the `__gc` metamethod, since there is
 /// generally no need to do so: [`UserData`] implementors can instead just implement `Drop`.
 ///
-/// [`UserData`]: trait.UserData.html
+/// [`UserData`]: crate::UserData
 #[derive(Debug, Clone)]
 pub enum MetaMethod {
     /// The `+` operator.
@@ -271,7 +271,7 @@ impl From<&str> for MetaMethod {
 
 /// Method registry for [`UserData`] implementors.
 ///
-/// [`UserData`]: trait.UserData.html
+/// [`UserData`]: crate::UserData
 pub trait UserDataMethods<'lua, T: UserData> {
     /// Add a regular method which accepts a `&T` as the first parameter.
     ///
@@ -325,7 +325,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
     ///
     /// Prefer to use [`add_method`] or [`add_method_mut`] as they are easier to use.
     ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
     /// [`add_method`]: #method.add_method
     /// [`add_method_mut`]: #method.add_method_mut
     fn add_function<S, A, R, F>(&mut self, name: &S, function: F)
@@ -436,7 +436,7 @@ pub trait UserDataMethods<'lua, T: UserData> {
 
 /// Field registry for [`UserData`] implementors.
 ///
-/// [`UserData`]: trait.UserData.html
+/// [`UserData`]: crate::UserData
 pub trait UserDataFields<'lua, T: UserData> {
     /// Add a regular field getter as a method which accepts a `&T` as the parameter.
     ///
@@ -469,7 +469,7 @@ pub trait UserDataFields<'lua, T: UserData> {
     ///
     /// Prefer to use [`add_field_method_get`] as it is easier to use.
     ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
     /// [`add_field_method_get`]: #method.add_field_method_get
     fn add_field_function_get<S, R, F>(&mut self, name: &S, function: F)
     where
@@ -482,7 +482,7 @@ pub trait UserDataFields<'lua, T: UserData> {
     ///
     /// Prefer to use [`add_field_method_set`] as it is easier to use.
     ///
-    /// [`AnyUserData`]: struct.AnyUserData.html
+    /// [`AnyUserData`]: crate::AnyUserData
     /// [`add_field_method_set`]: #method.add_field_method_set
     fn add_field_function_set<S, A, F>(&mut self, name: &S, function: F)
     where
@@ -578,10 +578,10 @@ pub trait UserDataFields<'lua, T: UserData> {
 /// # }
 /// ```
 ///
-/// [`ToLua`]: trait.ToLua.html
-/// [`FromLua`]: trait.FromLua.html
-/// [`UserDataFields`]: trait.UserDataFields.html
-/// [`UserDataMethods`]: trait.UserDataMethods.html
+/// [`ToLua`]: crate::ToLua
+/// [`FromLua`]: crate::FromLua
+/// [`UserDataFields`]: crate::UserDataFields
+/// [`UserDataMethods`]: crate::UserDataMethods
 pub trait UserData: Sized {
     /// Adds custom fields specific to this userdata.
     fn add_fields<'lua, F: UserDataFields<'lua, Self>>(_fields: &mut F) {}
@@ -718,9 +718,9 @@ impl Serialize for UserDataSerializeError {
 /// This API should only be used when necessary. Implementing [`UserData`] already allows defining
 /// methods which check the type and acquire a borrow behind the scenes.
 ///
-/// [`UserData`]: trait.UserData.html
-/// [`is`]: #method.is
-/// [`borrow`]: #method.borrow
+/// [`UserData`]: crate::UserData
+/// [`is`]: crate::AnyUserData::is
+/// [`borrow`]: crate::AnyUserData::borrow
 #[derive(Clone, Debug)]
 pub struct AnyUserData<'lua>(pub(crate) LuaRef<'lua>);
 
@@ -845,7 +845,7 @@ impl<'lua> AnyUserData<'lua> {
     ///
     /// For `T: UserData + 'static` returned metatable is shared among all instances of type `T`.
     ///
-    /// [`UserDataMetatable`]: struct.UserDataMetatable.html
+    /// [`UserDataMetatable`]: crate::UserDataMetatable
     pub fn get_metatable(&self) -> Result<UserDataMetatable<'lua>> {
         self.get_raw_metatable().map(UserDataMetatable)
     }
@@ -954,7 +954,7 @@ impl<'lua> UserDataMetatable<'lua> {
     ///
     /// The pairs are wrapped in a [`Result`], since they are lazily converted to `V` type.
     ///
-    /// [`Result`]: type.Result.html
+    /// [`Result`]: crate::Result
     pub fn pairs<V: FromLua<'lua>>(self) -> UserDataMetatablePairs<'lua, V> {
         UserDataMetatablePairs(self.0.pairs())
     }
@@ -966,8 +966,8 @@ impl<'lua> UserDataMetatable<'lua> {
 ///
 /// This struct is created by the [`UserDataMetatable::pairs`] method.
 ///
-/// [`UserData`]: trait.UserData.html
-/// [`UserDataMetatable::pairs`]: struct.UserDataMetatable.html#method.pairs
+/// [`UserData`]: crate::UserData
+/// [`UserDataMetatable::pairs`]: crate::UserDataMetatable::method.pairs
 pub struct UserDataMetatablePairs<'lua, V>(TablePairs<'lua, StdString, V>);
 
 impl<'lua, V> Iterator for UserDataMetatablePairs<'lua, V>
diff --git a/src/value.rs b/src/value.rs
index 2196c6d4..e05fb0a2 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -49,6 +49,7 @@ pub enum Value<'lua> {
     /// `Error` is a special builtin userdata type. When received from Lua it is implicitly cloned.
     Error(Error),
 }
+
 pub use self::Value::Nil;
 
 impl<'lua> Value<'lua> {