diff --git a/Cargo.toml b/Cargo.toml
index cb4aeb47e0..cb4d047f04 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -59,17 +59,17 @@ rhai = ["bevy_mod_scripting_rhai"]
 rhai_script_api=["bevy_script_api/rhai"]
 
 [dependencies]
-bevy = { version = "0.10.1", default-features = false}
+bevy = { version = "0.11", default-features = false}
 bevy_mod_scripting_core = { path = "bevy_mod_scripting_core", version = "0.3.0" }
 bevy_mod_scripting_lua = { path = "languages/bevy_mod_scripting_lua", version = "0.3.0", optional = true }
 bevy_mod_scripting_rhai = { path = "languages/bevy_mod_scripting_rhai", version = "0.3.0", optional = true}
 bevy_script_api = { path = "bevy_script_api", version = "0.3.0", optional = true }
 
 [dev-dependencies]
-bevy = { version = "0.10.1"}
+bevy = { version = "0.11"}
 clap = { version = "4.1", features = ["derive"]}
 rand = "0.8.5"
-bevy_console = "0.7.0"
+bevy_console = "0.8.0"
 rhai-rand = "0.1" 
 
 [workspace]
diff --git a/api_gen_config.toml b/api_gen_config.toml
index 4a8af450e2..7c017f5595 100644
--- a/api_gen_config.toml
+++ b/api_gen_config.toml
@@ -6,12 +6,12 @@ use {
 		tealr::mlu::mlua::MetaMethod, 
 		docs::LuaDocFragment
 	},
-	crate::{common::bevy::GetWorld, lua::{RegisterForeignLuaType}},
+	crate::{common::bevy::GetWorld, lua::{RegisterForeignLuaType, util::LuaIndex}},
 };
 use std::ops::*;
 use crate::{script_ref::{ReflectedValue,ValueIndex},
 	sub_reflect::ReflectPathElem,
-	error::ReflectionError
+	error::ReflectionError,
 };
 use std::sync::Mutex;
 use bevy_mod_scripting_core::prelude::*;
@@ -145,10 +145,6 @@ source="bevy_ui"
 type="CalculatedClip"
 source="bevy_ui"
 
-[[types]]
-type="CalculatedSize"
-source="bevy_ui"
-
 [[types]]
 type="Node"
 source="bevy_ui"
@@ -493,8 +489,8 @@ source="bevy_asset"
 type="Vec2"
 source="bevy_math"
 lua_methods=[
-    "(MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])}",
-    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,f32)| {s.val_mut(|s| Ok(s[idx] = val))?}"
+    "(MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])}",
+    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,f32)| {s.val_mut(|s| Ok(s[*idx] = val))?}"
 ]
 import_path="glam::f32::Vec2"
 
@@ -502,8 +498,8 @@ import_path="glam::f32::Vec2"
 type="Vec3"
 source="bevy_math"
 lua_methods=[
-    "(MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])}",
-    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,f32)| {s.val_mut(|s| Ok(s[idx] = val))?}"
+    "(MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])}",
+    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,f32)| {s.val_mut(|s| Ok(s[*idx] = val))?}"
 ]
 import_path="glam::f32::Vec3"
 
@@ -511,8 +507,8 @@ import_path="glam::f32::Vec3"
 type="Vec3A"
 source="bevy_math"
 lua_methods=[
-    "(MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])}",
-    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,f32)| {s.val_mut(|s| Ok(s[idx] = val))?}"
+    "(MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])}",
+    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,f32)| {s.val_mut(|s| Ok(s[*idx] = val))?}"
 ]
 import_path="glam::f32::Vec3A"
 
@@ -521,8 +517,8 @@ import_path="glam::f32::Vec3A"
 type="Vec4"
 source="bevy_math"
 lua_methods=[
-    "(MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])}",
-    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,f32)| {s.val_mut(|s| Ok(s[idx] = val))?}"
+    "(MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])}",
+    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,f32)| {s.val_mut(|s| Ok(s[*idx] = val))?}"
 ]
 import_path="glam::f32::Vec4"
 
@@ -555,8 +551,8 @@ import_path="glam::bool::BVec4A"
 type="DVec2"
 source="bevy_math"
 lua_methods=[
-    "(MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])}",
-    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,f64)| {s.val_mut(|s| Ok(s[idx] = val))?}"
+    "(MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])}",
+    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,f64)| {s.val_mut(|s| Ok(s[*idx] = val))?}"
 ]
 import_path="glam::f64::DVec2"
 
@@ -564,8 +560,8 @@ import_path="glam::f64::DVec2"
 type="DVec3"
 source="bevy_math"
 lua_methods=[
-    "(MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])}",
-    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,f64)| {s.val_mut(|s| Ok(s[idx] = val))?}"
+    "(MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])}",
+    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,f64)| {s.val_mut(|s| Ok(s[*idx] = val))?}"
 ]
 import_path="glam::f64::DVec3"
 
@@ -573,8 +569,8 @@ import_path="glam::f64::DVec3"
 type="DVec4"
 source="bevy_math"
 lua_methods=[
-    "(MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])}",
-    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,f64)| {s.val_mut(|s| Ok(s[idx] = val))?}"
+    "(MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])}",
+    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,f64)| {s.val_mut(|s| Ok(s[*idx] = val))?}"
 ]
 import_path="glam::f64::DVec4"
 
@@ -582,8 +578,8 @@ import_path="glam::f64::DVec4"
 type="IVec2"
 source="bevy_math"
 lua_methods=[
-    "(MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])}",
-    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,i32)| {s.val_mut(|s| Ok(s[idx] = val))?}"
+    "(MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])}",
+    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,i32)| {s.val_mut(|s| Ok(s[*idx] = val))?}"
 ]
 import_path="glam::i32::IVec2"
 
@@ -591,8 +587,8 @@ import_path="glam::i32::IVec2"
 type="IVec3"
 source="bevy_math"
 lua_methods=[
-    "(MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])}",
-    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,i32)| {s.val_mut(|s| Ok(s[idx] = val))?}"
+    "(MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])}",
+    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,i32)| {s.val_mut(|s| Ok(s[*idx] = val))?}"
 ]
 import_path="glam::i32::IVec3"
 
@@ -600,8 +596,8 @@ import_path="glam::i32::IVec3"
 type="IVec4"
 source="bevy_math"
 lua_methods=[
-    "(MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])}",
-    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,i32)| {s.val_mut(|s| Ok(s[idx] = val))?}"
+    "(MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])}",
+    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,i32)| {s.val_mut(|s| Ok(s[*idx] = val))?}"
 ]
 import_path="glam::i32::IVec4"
 
@@ -609,8 +605,8 @@ import_path="glam::i32::IVec4"
 type="UVec2"
 source="bevy_math"
 lua_methods=[
-    "(MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])}",
-    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,u32)| {s.val_mut(|s| Ok(s[idx] = val))?}"
+    "(MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])}",
+    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,u32)| {s.val_mut(|s| Ok(s[*idx] = val))?}"
 ]
 import_path="glam::u32::UVec2"
 
@@ -618,8 +614,8 @@ import_path="glam::u32::UVec2"
 type="UVec3"
 source="bevy_math"
 lua_methods=[
-    "(MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])}",
-    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,u32)| {s.val_mut(|s| Ok(s[idx] = val))?}"
+    "(MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])}",
+    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,u32)| {s.val_mut(|s| Ok(s[*idx] = val))?}"
 ]
 import_path="glam::u32::UVec3"
 
@@ -627,8 +623,8 @@ import_path="glam::u32::UVec3"
 type="UVec4"
 source="bevy_math"
 lua_methods=[
-    "(MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])}",
-    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,u32)| {s.val_mut(|s| Ok(s[idx] = val))?}"
+    "(MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])}",
+    "mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,u32)| {s.val_mut(|s| Ok(s[*idx] = val))?}"
 ]
 import_path="glam::u32::UVec4"
 
@@ -637,11 +633,11 @@ type="Mat3"
 source="bevy_math"
 lua_methods=[
 """    
-	mut (MetaMethod::Index) => |ctx,s,idx : usize| {
+	mut (MetaMethod::Index) => |ctx,s,idx : LuaIndex| {
 		Ok(LuaVec3::new_ref(
 				s.script_ref(ctx.get_world()?).sub_ref(ReflectPathElem::SubReflectionIndexed{
 					label:"col", 
-					index: idx,
+					index: *idx,
 					get: |idx,ref_| Err(ReflectionError::InsufficientProvenance{
 						path: "".to_owned(), 
 						msg: "Cannot get column of matrix with immutable reference".to_owned()
@@ -668,11 +664,11 @@ type="Mat2"
 source="bevy_math"
 lua_methods=[
 """    
-	mut (MetaMethod::Index) => |ctx,s,idx : usize| {
+	mut (MetaMethod::Index) => |ctx,s,idx : LuaIndex| {
 		Ok(LuaVec2::new_ref(
 				s.script_ref(ctx.get_world()?).sub_ref(ReflectPathElem::SubReflectionIndexed{
 					label:"col", 
-					index: idx,
+					index: *idx,
 					get: |idx,ref_| Err(ReflectionError::InsufficientProvenance{
 						path: "".to_owned(), 
 						msg: "Cannot get column of matrix with immutable reference".to_owned()
@@ -700,11 +696,11 @@ type="Mat3A"
 source="bevy_math"
 lua_methods=[
 """    
-	mut (MetaMethod::Index) => |ctx,s,idx : usize| {
+	mut (MetaMethod::Index) => |ctx,s,idx : LuaIndex| {
 		Ok(LuaVec3A::new_ref(
 				s.script_ref(ctx.get_world()?).sub_ref(ReflectPathElem::SubReflectionIndexed{
 					label:"col", 
-					index: idx,
+					index: *idx,
 					get: |idx,ref_| Err(ReflectionError::InsufficientProvenance{
 						path: "".to_owned(), 
 						msg: "Cannot get column of matrix with immutable reference".to_owned()
@@ -731,11 +727,11 @@ type="Mat4"
 source="bevy_math"
 lua_methods=[
 """    
-	mut (MetaMethod::Index) => |ctx,s,idx : usize| {
+	mut (MetaMethod::Index) => |ctx,s,idx : LuaIndex| {
 		Ok(LuaVec4::new_ref(
 				s.script_ref(ctx.get_world()?).sub_ref(ReflectPathElem::SubReflectionIndexed{
 					label:"col", 
-					index: idx,
+					index: *idx,
 					get: |idx,ref_| Err(ReflectionError::InsufficientProvenance{
 						path: "".to_owned(), 
 						msg: "Cannot get column of matrix with immutable reference".to_owned()
@@ -763,11 +759,11 @@ type="DMat2"
 source="bevy_math"
 lua_methods=[
 """    
-	mut (MetaMethod::Index) => |ctx,s,idx : usize| {
+	mut (MetaMethod::Index) => |ctx,s,idx : LuaIndex| {
 		Ok(LuaDVec2::new_ref(
 				s.script_ref(ctx.get_world()?).sub_ref(ReflectPathElem::SubReflectionIndexed{
 					label:"col", 
-					index: idx,
+					index: *idx,
 					get: |idx,ref_| Err(ReflectionError::InsufficientProvenance{
 						path: "".to_owned(), 
 						msg: "Cannot get column of matrix with immutable reference".to_owned()
@@ -794,11 +790,11 @@ type="DMat3"
 source="bevy_math"
 lua_methods=[
 """    
-	mut (MetaMethod::Index) => |ctx,s,idx : usize| {
+	mut (MetaMethod::Index) => |ctx,s,idx : LuaIndex| {
 		Ok(LuaDVec3::new_ref(
 				s.script_ref(ctx.get_world()?).sub_ref(ReflectPathElem::SubReflectionIndexed{
 					label:"col", 
-					index: idx,
+					index: *idx,
 					get: |idx,ref_| Err(ReflectionError::InsufficientProvenance{
 						path: "".to_owned(), 
 						msg: "Cannot get column of matrix with immutable reference".to_owned()
@@ -825,11 +821,11 @@ type="DMat4"
 source="bevy_math"
 lua_methods=[
 """    
-	mut (MetaMethod::Index) => |ctx,s,idx : usize| {
+	mut (MetaMethod::Index) => |ctx,s,idx : LuaIndex| {
 		Ok(LuaDVec4::new_ref(
 				s.script_ref(ctx.get_world()?).sub_ref(ReflectPathElem::SubReflectionIndexed{
 					label:"col", 
-					index: idx,
+					index: *idx,
 					get: |idx,ref_| Err(ReflectionError::InsufficientProvenance{
 						path: "".to_owned(), 
 						msg: "Cannot get column of matrix with immutable reference".to_owned()
diff --git a/assets/scripts/complex_game_loop.lua b/assets/scripts/complex_game_loop.lua
index 030bc34b64..b5e1b880e4 100644
--- a/assets/scripts/complex_game_loop.lua
+++ b/assets/scripts/complex_game_loop.lua
@@ -1,31 +1,17 @@
 
 
-function on_pre_physics_one(id) 
-    print("on_pre_physics_one, Handling:")
+function on_pre_physics(id) 
+    print("on_pre_physics, Handling:")
     print(string.format("\t-> id: %d",id))
 end
 
-function on_pre_physics_two(id)
-    print("on_pre_physics_two, Handling:")
-    print(string.format("\t-> id: %d",id))
-end
-
-function on_post_physics_one(id)
-    print("on_post_physics_one, Handling:")
+function on_post_physics(id)
+    print("on_post_physics, Handling:")
     print(string.format("\t-> id: %d",id))
 end 
 
-function on_post_physics_two(id)
-    print("on_post_physics_two, Handling:")
-    print(string.format("\t-> id: %d",id))
-end 
 
-function on_post_update_one(id)
-    print("on_post_update_one, Handling:")
+function on_post_update(id)
+    print("on_post_update, Handling:")
     print(string.format("\t-> id: %d",id))
 end
-
-function on_post_update_two(id)
-    print("on_post_update_two, Handling:")
-    print(string.format("\t-> id: %d",id))
-end
\ No newline at end of file
diff --git a/assets/scripts/game_of_life.tl b/assets/scripts/game_of_life.tl
index cae45df9b1..f6db6efc60 100644
--- a/assets/scripts/game_of_life.tl
+++ b/assets/scripts/game_of_life.tl
@@ -30,15 +30,15 @@ global function on_update()
         prev_state[k] = (not(v == 0)) and 1 or 0
     end
 
-    for i=1,(dimensions[0] * dimensions[1]) do 
-        local north = prev_state[i - dimensions[0]] or 1
-        local south = prev_state[i + dimensions[0]] or 1 
+    for i=1,(dimensions[1] * dimensions[2]) do 
+        local north = prev_state[i - dimensions[1]] or 1
+        local south = prev_state[i + dimensions[1]] or 1 
         local east = prev_state[i + 1] or 1 
         local west = prev_state[i - 1] or 1
-        local northeast = prev_state[i - dimensions[0] + 1] or 1
-        local southeast = prev_state[i + dimensions[0] + 1] or 1
-        local northwest = prev_state[i - dimensions[0] - 1] or 1
-        local southwest = prev_state[i + dimensions[0] - 1] or 1
+        local northeast = prev_state[i - dimensions[1] + 1] or 1
+        local southeast = prev_state[i + dimensions[1] + 1] or 1
+        local northwest = prev_state[i - dimensions[1] - 1] or 1
+        local southwest = prev_state[i + dimensions[1] - 1] or 1
 
         local neighbours = north + south + east + west 
             + northeast + southeast + northwest + southwest
diff --git a/bevy_api_gen/Cargo.toml b/bevy_api_gen/Cargo.toml
index 8fa54aee15..b215f1544a 100644
--- a/bevy_api_gen/Cargo.toml
+++ b/bevy_api_gen/Cargo.toml
@@ -26,7 +26,7 @@ path = "src/main.rs"
 
 
 [dependencies]
-rustdoc-types = "0.19.0"
+rustdoc-types = "0.22.0"
 clap = { version = "3.2.6", features = ["derive"] }
 serde_json = "1.0.81"
 toml = "0.5.9"
diff --git a/bevy_api_gen/src/config.rs b/bevy_api_gen/src/config.rs
index 0d802f57e5..7909dbf874 100644
--- a/bevy_api_gen/src/config.rs
+++ b/bevy_api_gen/src/config.rs
@@ -1,5 +1,3 @@
-use std::collections::HashSet;
-
 use clap::Parser;
 use indexmap::{IndexMap, IndexSet};
 use rustdoc_types::{Crate, Item, ItemEnum, Visibility};
diff --git a/bevy_event_priority/Cargo.toml b/bevy_event_priority/Cargo.toml
index ce91bf755a..cc76f9da1f 100644
--- a/bevy_event_priority/Cargo.toml
+++ b/bevy_event_priority/Cargo.toml
@@ -21,5 +21,5 @@ name = "bevy_event_priority"
 path = "src/lib.rs"
 
 [dependencies]
-bevy = { version = "0.10.1", default-features = false}
+bevy = { version = "0.11", default-features = false}
 
diff --git a/bevy_mod_scripting_common/src/input.rs b/bevy_mod_scripting_common/src/input.rs
new file mode 100644
index 0000000000..0ffd756673
--- /dev/null
+++ b/bevy_mod_scripting_common/src/input.rs
@@ -0,0 +1,791 @@
+use std::{
+    collections::{HashMap, VecDeque},
+    str::FromStr,
+};
+
+use indexmap::{IndexMap, IndexSet};
+use proc_macro2::{Ident, Span};
+use quote::{format_ident, ToTokens};
+use strum::{Display, EnumString};
+use syn::{
+    parse::{Nothing, Parse},
+    punctuated::Punctuated,
+    spanned::Spanned,
+    token::{And, Colon2, Gt, Lt, Mut},
+    visit_mut::VisitMut,
+    AngleBracketedGenericArguments, DataStruct, DeriveInput, Error, Fields, GenericArgument, Meta,
+    NestedMeta, PatType, PathArguments, PathSegment, Receiver, TraitItemMethod, Type, TypePath,
+    TypeReference, TypeTuple,
+};
+
+use crate::utils::{attribute_to_string_lit, ident_to_type_path};
+
+/// Convenience structure for holding data relevant to proxy generation
+pub struct DeriveMeta {}
+
+#[derive(Debug)]
+pub struct Language {
+    pub name: String,
+    pub on_feature: Option<String>,
+}
+
+/// Language settings for proxies
+#[derive(Default, Debug)]
+pub struct LanguageMeta {
+    pub languages: Vec<Language>,
+}
+
+impl TryFrom<syn::MetaList> for LanguageMeta {
+    type Error = syn::Error;
+
+    fn try_from(list: syn::MetaList) -> Result<Self, Self::Error> {
+        let mut languages: Vec<Language> = Default::default();
+
+        for nested_meta in list.nested.into_iter() {
+            match nested_meta {
+                syn::NestedMeta::Lit(syn::Lit::Str(_str)) => {
+                    let mut name = _str.value();
+                    let mut on_feature = None;
+                    if let Some(postfix) = name.strip_prefix("on_feature(") {
+                        if let Some(middle) = postfix.strip_suffix(')') {
+                            name = middle.to_owned();
+                            on_feature = Some(name.clone());
+                        }
+                    }
+                    languages.push(Language { name, on_feature })
+                }
+                _ => {
+                    return Err(syn::Error::new_spanned(
+                        nested_meta,
+                        "Expected language name or wrapped language name",
+                    ))
+                }
+            };
+        }
+
+        Ok(Self { languages })
+    }
+}
+
+/// Flags which detail required functionality or additional derivation requirements
+#[derive(Debug, Hash, PartialEq, Eq)]
+pub enum DeriveFlag {
+    Debug,
+    Display,
+    Clone,
+}
+
+impl TryFrom<syn::NestedMeta> for DeriveFlag {
+    type Error = syn::Error;
+
+    fn try_from(value: syn::NestedMeta) -> Result<Self, Self::Error> {
+        match value {
+            NestedMeta::Meta(Meta::Path(p)) if p.is_ident("Clone") => Ok(Self::Clone),
+            NestedMeta::Meta(Meta::Path(p)) if p.is_ident("Debug") => Ok(Self::Debug),
+            NestedMeta::Meta(Meta::Path(p)) if p.is_ident("Display") => Ok(Self::Display),
+            _ => Err(syn::Error::new_spanned(
+                value,
+                "Expected one of `Debug`, `Display`, `Clone`",
+            )),
+        }
+    }
+}
+
+/// Container for proxy flags
+#[derive(Debug, Default)]
+pub struct ProxyFlags {
+    pub flags: IndexSet<DeriveFlag>,
+}
+
+impl TryFrom<syn::MetaList> for ProxyFlags {
+    type Error = syn::Error;
+
+    fn try_from(meta_list: syn::MetaList) -> Result<Self, Self::Error> {
+        let mut derive_flags: IndexSet<DeriveFlag> = Default::default();
+
+        for nested_meta in meta_list.nested {
+            let span = nested_meta.span();
+            let flag: DeriveFlag = nested_meta.try_into()?;
+            if derive_flags.contains(&flag) {
+                return Err(syn::Error::new(
+                    span,
+                    "This flag was already defined, remove duplicate flag",
+                ));
+            } else {
+                derive_flags.insert(flag);
+            }
+        }
+        Ok(Self {
+            flags: derive_flags,
+        })
+    }
+}
+
+pub(crate) struct ZeroOrManyTerminated<T: Parse, S: Parse>(Punctuated<T, S>);
+
+impl<T: Parse, S: Parse> Parse for ZeroOrManyTerminated<T, S> {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        Ok(Self(Punctuated::<T, S>::parse_terminated(input)?))
+    }
+}
+
+/// Enumeration of commonly encountered Rust standard library type identifiers which can be effectively proxied in Lua,
+/// These types are `container` types, which wrap other types rather than standalone and literal types.
+#[derive(EnumString, Debug, Clone, Copy, Display, PartialEq, Eq)]
+pub enum StdTypeIdent {
+    Option,
+    Result,
+    Vec,
+    Box,
+    Rc,
+    Arc,
+    Cow,
+    Cell,
+    RefCell,
+    Mutex,
+    RwLock,
+    Pin,
+}
+
+/// Detailed information about the proxy, here we can access fields/variants etc.
+#[derive(Debug)]
+pub enum ProxyData {
+    Struct { fields: Fields },
+}
+
+/// For types of the form `Option<T>` i.e. an outer identifier with a nested type inside angle brackets.
+/// This type helps us destructure these patterns and unwrap/wrap proxies fully without dealing with the complicated full syn::Type enum
+#[derive(Debug, Clone)]
+pub struct UnitPath {
+    pub std_type_ident: Option<StdTypeIdent>,
+    pub ident: Ident,
+    pub colon2_token: Option<Colon2>,
+    pub lt_token: Lt,
+    pub gt_token: Gt,
+    pub inner: Box<SimpleType>,
+}
+
+/// For types of the form `Result<L, R>` i.e. an outer identifier with two nested types inside angle brackets.
+#[derive(Debug, Clone)]
+pub struct DuoPath {
+    pub std_type_ident: Option<StdTypeIdent>,
+    pub ident: Ident,
+    pub colon2_token: Option<Colon2>,
+    pub lt_token: Lt,
+    pub gt_token: Gt,
+    pub left: Box<SimpleType>,
+    pub right: Box<SimpleType>,
+}
+
+/// Represents a type prefixed with an outer reference, e.g. `&T` or `&mut T`
+#[derive(Debug, Clone)]
+pub struct Reference {
+    pub and_token: And,
+    pub mutability: Option<Mut>,
+    pub inner: Box<SimpleType>,
+}
+
+/// Represents the identifier part of a type which doubles as a proxy type, e.g. `T` in `Option<T>`
+/// Stores both the proxied and proxy identifier i.e. `T` and `LuaT`
+#[derive(Debug, Clone)]
+pub struct ProxyType {
+    pub proxied_ident: Ident,
+    pub proxy_ident: Ident,
+}
+
+/// Proxies can also be returned in "container" types, such as:
+/// - Option
+/// - Result
+/// - Vec
+/// - Tuple
+/// This type helps us destructure these patterns and unwrap/wrap proxies fully without dealing with the full syn::Type enum
+#[derive(Debug, Clone)]
+pub enum SimpleType {
+    /// The unit type `()`
+    Unit,
+    /// A type of the form `Option<T>`
+    UnitPath(UnitPath),
+    /// A type of the form `Result<T, E>` a list containing two elements is referred to as a
+    DuoPath(DuoPath),
+
+    /// A type with an outer reference, e.g. `&T` or `&mut T`
+    Reference(Reference),
+    /// A type which doubles as a proxy type, e.g. `T` in `Option<T>`
+    ProxyType(ProxyType),
+    /// A type which is not a proxy type, e.g. `i32`, required for composite types which can contain both proxy and non-proxy types
+    /// like tuples: `(i32, T)`
+    Type(syn::Type),
+}
+
+impl SimpleType {
+    /// Constructs a new SimpleProxyType from a `syn::FnArg` using contextual resolution for receivers such as `Self` and `self` with the proxied type identifier given.
+    pub fn new_from_fn_arg(
+        proxy_prefix: &'static str,
+        arg: &syn::FnArg,
+        proxied_type_identifier: &Ident,
+        proxied_to_proxy_ident_map: &HashMap<Ident, Option<Ident>>,
+    ) -> Result<SimpleType, Error> {
+        match arg {
+            syn::FnArg::Receiver(Receiver {
+                reference,
+                mutability,
+                ..
+            }) => match reference {
+                Some((and, ..)) => {
+                    let mutability = mutability.as_ref().copied();
+                    let inner = Box::new(SimpleType::new_from_contextual_type(
+                        proxy_prefix,
+                        &Type::Path(ident_to_type_path(proxied_type_identifier.clone())),
+                        proxied_type_identifier,
+                        proxied_to_proxy_ident_map,
+                    )?);
+                    Ok(Self::Reference(Reference {
+                        and_token: *and,
+                        mutability,
+                        inner,
+                    }))
+                }
+                None => Self::new_from_contextual_type(
+                    proxy_prefix,
+                    &Type::Path(ident_to_type_path(proxied_type_identifier.clone())),
+                    proxied_type_identifier,
+                    proxied_to_proxy_ident_map,
+                ),
+            },
+            syn::FnArg::Typed(PatType { ty, .. }) => Self::new_from_contextual_type(
+                proxy_prefix,
+                ty.as_ref(),
+                proxied_type_identifier,
+                proxied_to_proxy_ident_map,
+            ),
+        }
+    }
+
+    /// Constructs a new SimpleProxyType from a `syn::Type`, contextual receivers such as `Self` and `self` will cause an error
+    /// to be returned.
+    pub fn new_from_fully_specified_type(
+        proxy_prefix: &'static str,
+        proxied_type: &Type,
+        proxied_to_proxy_ident_map: &HashMap<Ident, Option<Ident>>,
+    ) -> Result<SimpleType, Error> {
+        Self::new_from_type(proxy_prefix, proxied_type, None, proxied_to_proxy_ident_map)
+    }
+
+    /// Constructs a new SimpleProxyType from a `syn::Type`, contextual receivers such as `Self` and `self` will be replaced
+    /// with the given identifier prefixed with the proxy_prefix
+    pub fn new_from_contextual_type(
+        proxy_prefix: &'static str,
+        proxied_type: &Type,
+        proxied_type_identifier: &Ident,
+        proxied_to_proxy_ident_map: &HashMap<Ident, Option<Ident>>,
+    ) -> Result<SimpleType, Error> {
+        Self::new_from_type(
+            proxy_prefix,
+            proxied_type,
+            Some(proxied_type_identifier),
+            proxied_to_proxy_ident_map,
+        )
+    }
+
+    /// Builds a SimpleType::ProxyType or SimpleType::Type depending on the passed data,
+    /// - if the proxied type identifier has a Some value in the proxied_to_proxy_ident_map map then the proxy_ident will be set to the value in the map,
+    /// - if it has a None value it will be set to the proxied type identifier prefixed with the proxy_prefix,
+    /// - If it's not in the map it's built as a SimpleType::Type
+    fn new_proxied_type_or_type(
+        proxy_prefix: &'static str,
+        proxied_ident: &Ident,
+        proxied_to_proxy_ident_map: &HashMap<Ident, Option<Ident>>,
+    ) -> SimpleType {
+        if let Some((original_ident, replacement_ident)) =
+            proxied_to_proxy_ident_map.get_key_value(proxied_ident)
+        {
+            let proxy_ident = replacement_ident
+                .as_ref()
+                .unwrap_or(&format_ident!("{proxy_prefix}{original_ident}"))
+                .clone();
+
+            SimpleType::ProxyType(ProxyType {
+                proxied_ident: original_ident.clone(),
+                proxy_ident,
+            })
+        } else {
+            Self::Type(syn::Type::Path(ident_to_type_path(proxied_ident.clone())))
+        }
+    }
+
+    /// Constructs a new SimpleProxyType from a `syn::Type`, if `proxied_type_identifier` is given then contextual
+    /// receivers such as `Self` and `self` will be replaced with the given identifier prefixed with the proxy_prefix, otherwise an error will be returned.
+    /// types with base identifiers not in the proxied_to_proxy_ident_map list are treated as non-proxy types and will be wrapped in a SimpleProxyType::Type
+    fn new_from_type(
+        proxy_prefix: &'static str,
+        proxied_type: &Type,
+        proxied_type_identifier: Option<&Ident>,
+        proxied_to_proxy_ident_map: &HashMap<Ident, Option<Ident>>,
+    ) -> Result<SimpleType, Error> {
+        match proxied_type {
+            Type::Path(p) if p.path.is_ident("self") || p.path.is_ident("Self") => {
+                let proxied_ident: &Ident = proxied_type_identifier.ok_or_else(|| {
+                    Error::new_spanned(
+                        proxied_type,
+                        "Did not expect contextual receiver in constructing simple proxy type"
+                            .to_owned(),
+                    )
+                })?;
+                Ok(Self::new_proxied_type_or_type(proxy_prefix, proxied_ident, proxied_to_proxy_ident_map))
+            }
+            Type::Path(p) if !p.path.segments.is_empty() => {
+                let last_segment = p.path.segments.last().unwrap();
+                if last_segment.arguments.is_empty() {
+                    return Ok(Self::new_proxied_type_or_type(proxy_prefix,&last_segment.ident, proxied_to_proxy_ident_map));
+                } else if let PathArguments::AngleBracketed(args) = &last_segment.arguments {
+                    if args.args.len() == 1 {
+                        if let GenericArgument::Type(arg_type) = args.args.first().unwrap() {
+                            let inner = Box::new(Self::new_from_type(
+                                proxy_prefix,
+                                arg_type,
+                                proxied_type_identifier,
+                                proxied_to_proxy_ident_map
+                            )?);
+                            return Ok(SimpleType::UnitPath(UnitPath {
+                                std_type_ident: StdTypeIdent::from_str(&last_segment.ident.to_string()).ok(),
+                                ident: last_segment.ident.clone(),
+                                colon2_token: args.colon2_token,
+                                lt_token: args.lt_token,
+                                gt_token: args.gt_token,
+                                inner,
+                            }));
+                        }
+                    } else if args.args.len() == 2 {
+                        let mut args_iter = args.args.iter();
+                        if let (GenericArgument::Type(left), GenericArgument::Type(right)) =
+                            (args_iter.next().unwrap(), args_iter.next().unwrap())
+                        {
+                            let left = Box::new(Self::new_from_type(
+                                proxy_prefix,
+                                left,
+                                proxied_type_identifier,
+                                proxied_to_proxy_ident_map
+                            )?);
+                            let right = Box::new(Self::new_from_type(
+                                proxy_prefix,
+                                right,
+                                proxied_type_identifier,
+                                proxied_to_proxy_ident_map
+                            )?);
+                            return Ok(SimpleType::DuoPath(DuoPath {
+                                std_type_ident: StdTypeIdent::from_str(&last_segment.ident.to_string()).ok(),
+                                ident: last_segment.ident.clone(),
+                                colon2_token: args.colon2_token,
+                                lt_token: args.lt_token,
+                                gt_token: args.gt_token,
+                                left,
+                                right,
+                            }));
+                        }
+                    }
+                }
+                Err(Error::new_spanned(proxied_type, "Unsupported type".to_owned()))
+            }
+            Type::Reference(tr) => Ok(SimpleType::Reference(Reference {
+                and_token: tr.and_token,
+                mutability: tr.mutability,
+                inner: Box::new(Self::new_from_type(
+                    proxy_prefix,
+                    &tr.elem,
+                    proxied_type_identifier,
+                    proxied_to_proxy_ident_map
+                )?),
+            })),
+            Type::Infer(_) => Ok(SimpleType::Type(proxied_type.clone())),
+            Type::Tuple(TypeTuple { elems , ..}) if elems.is_empty() => {
+                Ok(SimpleType::Unit)
+            },
+            _ => Err(Error::new_spanned(
+                proxied_type,
+                format!("Expected simple type with one identifier and possible reference for proxy type, got {}", proxied_type.to_token_stream()),
+            )),
+        }
+    }
+
+    /// Returns true if the type has an outer reference, (e.g. `&Type`)
+    pub fn has_outer_ref(&self) -> bool {
+        matches!(self, SimpleType::Reference { .. })
+    }
+
+    pub fn has_outer_mut_ref(&self) -> bool {
+        matches!(self, SimpleType::Reference (Reference{ mutability, .. }) if mutability.is_some())
+    }
+
+    /// Returns true if the type has an inner reference, (e.g. `Type<&T>`)
+    pub fn has_ref(&self) -> bool {
+        match self {
+            SimpleType::Unit => false,
+            SimpleType::UnitPath(UnitPath { inner, .. }) => inner.has_ref(),
+            SimpleType::DuoPath(DuoPath { left, right, .. }) => left.has_ref() || right.has_ref(),
+            SimpleType::Reference(_) => true,
+            SimpleType::ProxyType(ProxyType { .. }) => false,
+            SimpleType::Type(_) => false,
+        }
+    }
+
+    /// Returns true if the type has an inner proxy type
+    pub fn contains_proxy_type(&self) -> bool {
+        match self {
+            SimpleType::Unit => false,
+            SimpleType::UnitPath(UnitPath { inner, .. }) => inner.contains_proxy_type(),
+            SimpleType::DuoPath(DuoPath { left, right, .. }) => {
+                left.contains_proxy_type() || right.contains_proxy_type()
+            }
+            SimpleType::Reference(Reference { inner, .. }) => inner.contains_proxy_type(),
+            SimpleType::ProxyType(_) => true,
+            SimpleType::Type(_) => false,
+        }
+    }
+}
+
+pub trait VisitSimpleType<T>
+where
+    T: std::fmt::Debug,
+{
+    fn visit(&mut self, simple_type: &SimpleType) -> T {
+        self.visit_simple_type(simple_type, false)
+    }
+
+    fn visit_simple_type(&mut self, simple_type: &SimpleType, is_child_of_reference: bool) -> T {
+        match simple_type {
+            SimpleType::Unit => self.visit_unit(is_child_of_reference),
+            SimpleType::UnitPath(unit_path) => {
+                self.visit_unit_path(unit_path, is_child_of_reference)
+            }
+            SimpleType::DuoPath(duo_path) => self.visit_duo_path(duo_path, is_child_of_reference),
+            SimpleType::Reference(reference) => {
+                self.visit_reference(reference, is_child_of_reference)
+            }
+            SimpleType::ProxyType(proxy_type) => {
+                self.visit_proxy_type(proxy_type, is_child_of_reference)
+            }
+            SimpleType::Type(_type) => self.visit_type(_type, is_child_of_reference),
+        }
+    }
+    fn visit_unit_path(&mut self, unit_path: &UnitPath, _is_child_of_reference: bool) -> T {
+        self.visit_simple_type(&unit_path.inner, false)
+    }
+
+    fn visit_duo_path(&mut self, duo_path: &DuoPath, _is_child_of_reference: bool) -> T {
+        self.visit_simple_type(&duo_path.left, false);
+        self.visit_simple_type(&duo_path.right, false)
+    }
+
+    fn visit_reference(&mut self, reference: &Reference, _is_child_of_reference: bool) -> T {
+        self.visit_simple_type(&reference.inner, true)
+    }
+    fn visit_unit(&mut self, is_child_of_reference: bool) -> T;
+    fn visit_proxy_type(&mut self, proxy_type: &ProxyType, is_child_of_reference: bool) -> T;
+    fn visit_type(&mut self, _type: &Type, is_child_of_reference: bool) -> T;
+}
+
+pub struct TypeConstructorVisitor {
+    /// if true then leaf proxies will be converted to their proxy type, otherwise they will be converted to their proxied type
+    pub generate_proxy_type: bool,
+    pub strip_outer_ref: bool,
+}
+
+impl TypeConstructorVisitor {
+    pub fn new(generate_proxy_type: bool, strip_outer_ref: bool) -> Self {
+        Self {
+            generate_proxy_type,
+            strip_outer_ref,
+        }
+    }
+}
+
+impl VisitSimpleType<Type> for TypeConstructorVisitor {
+    fn visit_unit(&mut self, _: bool) -> Type {
+        Type::Tuple(TypeTuple {
+            paren_token: Default::default(),
+            elems: Default::default(),
+        })
+    }
+
+    fn visit_unit_path(&mut self, unit_path: &UnitPath, _: bool) -> Type {
+        Type::Path(TypePath {
+            qself: None,
+            path: PathSegment {
+                ident: unit_path.ident.clone(),
+                arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
+                    colon2_token: unit_path.colon2_token,
+                    lt_token: unit_path.lt_token,
+                    args: Punctuated::from_iter(
+                        [GenericArgument::Type(
+                            self.visit_simple_type(&unit_path.inner, false),
+                        )]
+                        .into_iter(),
+                    ),
+                    gt_token: unit_path.gt_token,
+                }),
+            }
+            .into(),
+        })
+    }
+
+    fn visit_duo_path(&mut self, duo_path: &DuoPath, _: bool) -> Type {
+        let left = self.visit_simple_type(&duo_path.left, false);
+        let right = self.visit_simple_type(&duo_path.right, false);
+
+        Type::Path(TypePath {
+            qself: None,
+            path: PathSegment {
+                ident: duo_path.ident.clone(),
+                arguments: PathArguments::AngleBracketed(AngleBracketedGenericArguments {
+                    colon2_token: duo_path.colon2_token,
+                    lt_token: duo_path.lt_token,
+                    args: Punctuated::from_iter(
+                        [GenericArgument::Type(left), GenericArgument::Type(right)].into_iter(),
+                    ),
+                    gt_token: duo_path.gt_token,
+                }),
+            }
+            .into(),
+        })
+    }
+
+    fn visit_proxy_type(&mut self, proxy_type: &ProxyType, _: bool) -> Type {
+        if self.generate_proxy_type {
+            Type::Path(ident_to_type_path(proxy_type.proxy_ident.clone()))
+        } else {
+            Type::Path(ident_to_type_path(proxy_type.proxied_ident.clone()))
+        }
+    }
+
+    fn visit_type(&mut self, _type: &Type, _: bool) -> Type {
+        _type.clone()
+    }
+
+    fn visit_reference(&mut self, reference: &Reference, _: bool) -> Type {
+        if self.strip_outer_ref {
+            self.visit_simple_type(&reference.inner, false)
+        } else {
+            self.strip_outer_ref = false;
+            Type::Reference(TypeReference {
+                and_token: reference.and_token,
+                lifetime: None,
+                mutability: reference.mutability,
+                elem: Box::new(self.visit_simple_type(&reference.inner, true)),
+            })
+        }
+    }
+}
+
+/// Attributes relating to the proxy as a whole
+#[derive(Debug)]
+pub struct ProxyMeta {
+    /// the identifier of the proxied type
+    pub proxied_name: Ident,
+    /// the identifier for the proxy type
+    pub proxy_name: Option<Ident>,
+    /// language derivation settings
+    pub language_meta: LanguageMeta,
+    /// additional flags for the proxy
+    pub proxy_flags: ProxyFlags,
+    /// functions to be proxied
+    pub functions: IndexMap<Ident, TraitItemMethod>,
+    /// the inner type data
+    pub data: ProxyData,
+    /// the derive input span
+    pub span: Span,
+    /// docstrings
+    pub docstrings: Vec<proc_macro2::TokenStream>,
+}
+
+impl TryFrom<DeriveInput> for ProxyMeta {
+    type Error = syn::Error;
+
+    fn try_from(derive_input: DeriveInput) -> Result<Self, Self::Error> {
+        let mut proxy_name = None;
+        let span = derive_input.span();
+
+        // helper for collecting errors which are not fatal to the logic flow
+        // simplifies logical flow
+        let mut accumulated_errors = VecDeque::<Self::Error>::default();
+
+        let docstrings = derive_input
+            .attrs
+            .iter()
+            .map(attribute_to_string_lit)
+            .filter(|s| !s.is_empty())
+            .collect();
+
+        let proxy_meta = derive_input
+            .attrs
+            .iter()
+            .find(|attr| attr.path.is_ident("proxy"))
+            .ok_or_else(|| syn::Error::new_spanned(&derive_input, "`proxy` meta missing"))
+            .and_then(|attr| attr.parse_meta())?;
+
+        let functions = derive_input
+            .attrs
+            .into_iter()
+            .find(|attr| attr.path.is_ident("functions"))
+            .map_or(Ok(IndexMap::default()), |attr| {
+                attr.parse_args::<ZeroOrManyTerminated<TraitItemMethod, Nothing>>()
+                    .map(|fns| {
+                        let mut fn_map = IndexMap::default();
+                        fns.0
+                            .into_iter()
+                            .map(|_fn| (_fn.sig.ident.clone(), _fn))
+                            .for_each(|(name, body)| {
+                                if let Some(old_val) = fn_map.insert(name, body) {
+                                    accumulated_errors.push_back(syn::Error::new_spanned(
+                                        old_val.sig.ident, // old == new ident
+                                        "duplicate Lua proxy function, re-name this function",
+                                    ))
+                                }
+                            });
+                        fn_map
+                    })
+            })?;
+
+        let mut language_meta = Default::default();
+        let mut proxy_flags: ProxyFlags = Default::default();
+
+        if let syn::Meta::List(list) = proxy_meta {
+            for attr in list.nested.into_iter() {
+                match attr {
+                    NestedMeta::Meta(Meta::NameValue(pair)) => {
+                        let ident = pair.path.get_ident().ok_or_else(|| {
+                            syn::Error::new_spanned(&pair, "Keys must be identifiers")
+                        })?;
+
+                        match (ident.to_string().as_str(), pair.lit) {
+                            ("name", syn::Lit::Str(_str)) => {
+                                proxy_name = Some(Ident::new(&_str.value(), _str.span()))
+                            }
+                            _ => {
+                                return Err(syn::Error::new_spanned(ident, "Unrecognized argument"))
+                            }
+                        }
+                    }
+                    NestedMeta::Meta(Meta::List(list)) => {
+                        let ident = list
+                            .path
+                            .get_ident()
+                            .ok_or_else(|| syn::Error::new_spanned(&list, "Expected identifier"))?;
+
+                        match ident.to_string().as_str() {
+                            "languages" => language_meta = list.try_into()?,
+                            "derive" => proxy_flags = list.try_into()?,
+                            _ => return Err(syn::Error::new_spanned(list, "")),
+                        }
+                    }
+                    _ => return Err(syn::Error::new_spanned(attr, "Expected key value pair")),
+                }
+            }
+        } else {
+            return Err(syn::Error::new_spanned(
+                proxy_meta,
+                "Expected list of key value pairs",
+            ));
+        }
+
+        let data = match derive_input.data {
+            syn::Data::Struct(DataStruct { fields, .. }) => ProxyData::Struct { fields },
+            syn::Data::Enum(_) => todo!(),
+            syn::Data::Union(_) => todo!(),
+        };
+
+        let proxied_name = derive_input.ident;
+
+        if let Some(first_err) = accumulated_errors.pop_front() {
+            return Err(first_err);
+        }
+
+        Ok(ProxyMeta {
+            proxied_name,
+            proxy_name,
+            proxy_flags,
+            language_meta,
+            functions,
+            data,
+            span,
+            docstrings,
+        })
+    }
+}
+
+/// Replaces every occurence of an identifier with
+/// the given string while preserving the original span
+pub struct IdentifierRenamingVisitor<'a> {
+    pub target: &'a str,
+    pub replacement: &'a str,
+}
+
+impl VisitMut for IdentifierRenamingVisitor<'_> {
+    fn visit_ident_mut(&mut self, i: &mut Ident) {
+        if *i == self.target {
+            *i = Ident::new(self.replacement, i.span());
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::VisitSimpleType;
+
+    struct TestVisitor;
+    impl VisitSimpleType<bool> for TestVisitor {
+        fn visit_unit(&mut self, is_child_of_reference: bool) -> bool {
+            is_child_of_reference
+        }
+        fn visit_proxy_type(&mut self, _: &super::ProxyType, is_child_of_reference: bool) -> bool {
+            is_child_of_reference
+        }
+        fn visit_type(&mut self, _: &syn::Type, is_child_of_reference: bool) -> bool {
+            is_child_of_reference
+        }
+    }
+
+    #[test]
+    pub fn test_child_of_reference() {
+        let mut visitor = TestVisitor;
+        assert!(!visitor.visit(&super::SimpleType::Unit));
+        assert!(
+            !visitor.visit(&super::SimpleType::ProxyType(super::ProxyType {
+                proxied_ident: syn::Ident::new("T", proc_macro2::Span::call_site()),
+                proxy_ident: syn::Ident::new("LuaT", proc_macro2::Span::call_site()),
+            }))
+        );
+        assert!(
+            !visitor.visit(&super::SimpleType::Type(syn::Type::Path(syn::TypePath {
+                qself: None,
+                path: syn::Path::from(syn::Ident::new("T", proc_macro2::Span::call_site())),
+            })))
+        );
+        assert!(
+            visitor.visit(&super::SimpleType::Reference(super::Reference {
+                and_token: syn::Token![&](proc_macro2::Span::call_site()),
+                mutability: None,
+                inner: Box::new(super::SimpleType::Unit),
+            }))
+        );
+        assert!(
+            visitor.visit(&super::SimpleType::Reference(super::Reference {
+                and_token: syn::Token![&](proc_macro2::Span::call_site()),
+                mutability: None,
+                inner: Box::new(super::SimpleType::ProxyType(super::ProxyType {
+                    proxied_ident: syn::Ident::new("T", proc_macro2::Span::call_site()),
+                    proxy_ident: syn::Ident::new("LuaT", proc_macro2::Span::call_site()),
+                })),
+            }))
+        );
+        assert!(
+            visitor.visit(&super::SimpleType::Reference(super::Reference {
+                and_token: syn::Token![&](proc_macro2::Span::call_site()),
+                mutability: None,
+                inner: Box::new(super::SimpleType::Type(syn::Type::Path(syn::TypePath {
+                    qself: None,
+                    path: syn::Path::from(syn::Ident::new("T", proc_macro2::Span::call_site())),
+                }))),
+            }))
+        );
+    }
+}
diff --git a/bevy_mod_scripting_core/Cargo.toml b/bevy_mod_scripting_core/Cargo.toml
index 3a4700f4ab..3641e84033 100644
--- a/bevy_mod_scripting_core/Cargo.toml
+++ b/bevy_mod_scripting_core/Cargo.toml
@@ -29,7 +29,7 @@ doc_always = []
 
 
 [dependencies]
-bevy = { version = "0.10.1", default-features = false, features=["bevy_asset","bevy_gltf","bevy_animation","bevy_core_pipeline","bevy_ui","bevy_pbr","bevy_render","bevy_text","bevy_sprite","filesystem_watcher"]}
+bevy = { version = "0.11", default-features = false, features=["bevy_asset","bevy_gltf","bevy_animation","bevy_core_pipeline","bevy_ui","bevy_pbr","bevy_render","bevy_text","bevy_sprite","filesystem_watcher"]}
 bevy_event_priority = {path = "../bevy_event_priority", version = "0.3.0" }
 thiserror = "1.0.31"
 paste = "1.0.7"
diff --git a/bevy_mod_scripting_core/src/error.rs b/bevy_mod_scripting_core/src/error.rs
index f32dea81d2..3f0dd2be2b 100644
--- a/bevy_mod_scripting_core/src/error.rs
+++ b/bevy_mod_scripting_core/src/error.rs
@@ -4,8 +4,8 @@ use thiserror::Error;
 pub enum ScriptError {
     #[error("Runtime error in script `{script}` {msg}")]
     RuntimeError { script: String, msg: String },
-    #[error("Failed to load script asset for `{script}`")]
-    FailedToLoad { script: String },
+    #[error("Failed to load script asset for `{script}` {msg}")]
+    FailedToLoad { script: String, msg: String },
     #[error("Syntax error for script `{script}` {msg}")]
     SyntaxError { script: String, msg: String },
     #[error("Callback method `{callback}` invalid for script `{script}` {msg}")]
diff --git a/bevy_mod_scripting_core/src/event.rs b/bevy_mod_scripting_core/src/event.rs
index d7946fe484..7ba3470709 100644
--- a/bevy_mod_scripting_core/src/event.rs
+++ b/bevy_mod_scripting_core/src/event.rs
@@ -1,20 +1,22 @@
+use bevy::prelude::Event;
+
 use crate::{error::ScriptError, hosts::Recipients};
 
 /// An error coming from a script
-#[derive(Debug)]
+#[derive(Debug, Event)]
 pub struct ScriptErrorEvent {
     pub error: ScriptError,
 }
 
 /// An event emitted when a script was loaded or re-loaded (with a hot-reload),
 /// guaranteed to be sent for every script at least once and immediately after it's loaded.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Event)]
 pub struct ScriptLoaded {
     pub sid: u32,
 }
 
 /// A trait for events to be handled by scripts
-pub trait ScriptEvent: Send + Sync + Clone + 'static {
+pub trait ScriptEvent: Send + Sync + Clone + Event + 'static {
     /// Retrieves the recipient scripts for this event
     fn recipients(&self) -> &Recipients;
 }
diff --git a/bevy_mod_scripting_core/src/hosts.rs b/bevy_mod_scripting_core/src/hosts.rs
index ea253ab866..6e53a025a8 100644
--- a/bevy_mod_scripting_core/src/hosts.rs
+++ b/bevy_mod_scripting_core/src/hosts.rs
@@ -1,10 +1,5 @@
 //! All script host related stuff
-use bevy::{
-    asset::Asset,
-    ecs::schedule::{BaseSystemSet, FreeSystemSet},
-    prelude::*,
-    reflect::FromReflect,
-};
+use bevy::{asset::Asset, ecs::schedule::ScheduleLabel, prelude::*};
 use std::{
     collections::HashMap,
     iter::once,
@@ -131,13 +126,16 @@ pub trait ScriptHost: Send + Sync + 'static + Default + Resource {
 
     /// Registers the script host with the given app, and attaches handlers to deal with spawning/removing scripts in the given System Set.
     ///
-    /// Ideally place after any game logic which can spawn/remove/modify scripts to avoid frame lag. (typically `CoreSet::Post_Update`)
-    fn register_with_app_in_set(app: &mut App, set: impl FreeSystemSet);
+    /// Ideally place after any game logic which can spawn/remove/modify scripts to avoid frame lag. (typically `PostUpdate`)
+    fn register_with_app(app: &mut App, schedule: impl ScheduleLabel) {
+        #[derive(SystemSet, Hash, Debug, Eq, PartialEq, Clone, Copy)]
+        struct DummySet;
 
-    /// Registers the script host with the given app, and attaches handlers to deal with spawning/removing scripts in the given Base System Set.
-    ///
-    /// Ideally place after any game logic which can spawn/remove/modify scripts to avoid frame lag. (typically `CoreSet::Post_Update`)
-    fn register_with_app_in_base_set(app: &mut App, set: impl BaseSystemSet);
+        Self::register_with_app_in_set(app, schedule, DummySet);
+    }
+
+    /// Similar to `register_with_app` but allows you to specify a system set to add the handler to.
+    fn register_with_app_in_set(app: &mut App, schedule: impl ScheduleLabel, set: impl SystemSet);
 }
 
 /// Implementors can modify a script context in order to enable
@@ -307,7 +305,7 @@ impl<C> ScriptContexts<C> {
 
 /// A struct defining an instance of a script asset.
 /// Multiple instances of the same script can exist on the same entity
-#[derive(Debug, Reflect, FromReflect)]
+#[derive(Debug, Reflect)]
 pub struct Script<T: Asset> {
     /// a strong handle to the script asset
     handle: Handle<T>,
@@ -428,7 +426,7 @@ impl<T: Asset> Script<T> {
     }
 }
 
-#[derive(Component, Debug, FromReflect, Reflect)]
+#[derive(Component, Debug, Reflect)]
 #[reflect(Component, Default)]
 /// The component storing many scripts.
 /// Scripts receive information about the entity they are attached to
diff --git a/bevy_mod_scripting_core/src/lib.rs b/bevy_mod_scripting_core/src/lib.rs
index b26f4f5b99..617571c83f 100644
--- a/bevy_mod_scripting_core/src/lib.rs
+++ b/bevy_mod_scripting_core/src/lib.rs
@@ -2,10 +2,7 @@ use crate::{
     event::ScriptErrorEvent,
     hosts::{APIProvider, APIProviders, ScriptHost},
 };
-use bevy::{
-    ecs::schedule::{BaseSystemSet, FreeSystemSet},
-    prelude::*,
-};
+use bevy::{ecs::schedule::ScheduleLabel, prelude::*};
 use event::ScriptLoaded;
 use systems::script_event_handler;
 
@@ -77,39 +74,38 @@ pub trait AddScriptHost {
     /// registers the given script host with your app,
     /// the given system set will contain systems handling script loading, re-loading, removal etc.
     /// This system set will also send events related to the script lifecycle.
-    /// Any systems which need to run the same frame a script is loaded must run after this set.
-    fn add_script_host_to_set<T: ScriptHost, S: FreeSystemSet + Clone>(
-        &mut self,
-        set: S,
-    ) -> &mut Self;
+    ///
+    /// Note: any systems which need to run the same frame a script is loaded must run after this set.
+    fn add_script_host<T: ScriptHost>(&mut self, schedule: impl ScheduleLabel) -> &mut Self;
 
-    /// registers the given script host with your app,
-    /// the given base set will contain systems handling script loading, re-loading, removal etc.
-    /// This set will also send events related to the script lifecycle.
-    /// Any systems which need to run the same frame a script is loaded must run after this set.
-    fn add_script_host_to_base_set<T: ScriptHost, S: BaseSystemSet + Clone>(
+    /// Similar to `add_script_host` but allows you to specify a system set to add the script host to.
+    fn add_script_host_to_set<T: ScriptHost>(
         &mut self,
-        set: S,
+        schedule: impl ScheduleLabel,
+        set: impl SystemSet,
     ) -> &mut Self;
 }
 
 impl AddScriptHost for App {
-    fn add_script_host_to_set<T, S>(&mut self, set: S) -> &mut Self
+    fn add_script_host_to_set<T>(
+        &mut self,
+        schedule: impl ScheduleLabel,
+        set: impl SystemSet,
+    ) -> &mut Self
     where
         T: ScriptHost,
-        S: FreeSystemSet + Clone,
     {
-        T::register_with_app_in_set(self, set);
+        T::register_with_app_in_set(self, schedule, set);
         self.init_resource::<T>();
         self.add_event::<ScriptLoaded>();
         self
     }
-    fn add_script_host_to_base_set<T, S>(&mut self, set: S) -> &mut Self
+
+    fn add_script_host<T>(&mut self, schedule: impl ScheduleLabel) -> &mut Self
     where
         T: ScriptHost,
-        S: BaseSystemSet + Clone,
     {
-        T::register_with_app_in_base_set(self, set);
+        T::register_with_app(self, schedule);
         self.init_resource::<T>();
         self.add_event::<ScriptLoaded>();
         self
@@ -152,70 +148,64 @@ pub trait AddScriptHostHandler {
     /// Enables this script host to handle events with priorities in the range [0,min_prio] (inclusive),
     /// during from within the given set.
     ///
-    /// Note: this is identical to adding the script_event_handler system manually, so if you require setting schedules etc, you should use that directly.
+    /// Note: this is identical to adding the script_event_handler system manually, so if you require more complex setup, you can use the following:
     /// ```rust,ignore
-    /// self.add_system(
-    ///     script_event_handler::<T, MAX, MIN>.in_set(set).in_schedule(MySchedule::SomeSchedule)
+    /// self.add_systems(
+    ///     MySchedule,
+    ///     script_event_handler::<T, MAX, MIN>
     /// );
     /// ```
-    /// Think of handler system sets as a way to run certain types of events at specific points in your engine.
+    ///
+    /// Think of event handler systems as event sinks, which collect and "unpack" the instructions in each event every frame.
+    /// Because events are also prioritised, you can enforce a particular order of execution for your events (within each frame)
+    /// regardless of where they were fired from.
+    ///
     /// A good example of this is Unity [game loop's](https://docs.unity3d.com/Manual/ExecutionOrder.html) `onUpdate` and `onFixedUpdate`.
     /// FixedUpdate runs *before* any physics while Update runs after physics and input events.
     ///
-    /// A similar setup can be achieved by using a separate system set before and after your physics,
-    /// then assigning event priorities such that your events are forced to run at a particular system set, for example:
+    /// In this crate you can achieve this by using a separate system set before and after your physics,
+    /// then assigning event priorities such that your events are forced to run at the points you want them to, for example:
     ///
-    /// PrePhysics: min_prio = 1
-    /// PostPhysics: min_prio = 4
+    /// PrePhysics priority range [0,1]
+    /// PostPhysics priority range [2,4]
     ///
-    /// | Priority | Handler     | Event        |
-    /// | -------- | ----------- | ------------ |
-    /// | 0        | PrePhysics  | Start        |
-    /// | 1        | PrePhysics  | FixedUpdate  |
-    /// | 2        | PostPhysics | OnCollision  |
-    /// | 3        | PostPhysics | OnMouse      |
-    /// | 4        | PostPhysics | Update       |
+    /// | Priority | Handler     | Event         |
+    /// | -------- | ----------- | ------------  |
+    /// | 0        | PrePhysics  | Start       0 |
+    /// | 1        | PrePhysics  | FixedUpdate 1 |
+    /// | 2        | PostPhysics | OnCollision 2 |
+    /// | 3        | PostPhysics | OnMouse     3 |
+    /// | 4        | PostPhysics | Update      4 |
     ///
-    /// The *frequency* of running these events, is controlled by your systems, if the event is not emitted, it cannot be handled.
-    /// Of course there is nothing stopping your from emitting a single event type at varying priorities.
-    fn add_script_handler_to_set<T: ScriptHost, S: FreeSystemSet, const MAX: u32, const MIN: u32>(
+    /// Note: in this example, if your FixedUpdate event is fired *after* the handler system set has run, it will be discarded (since other handlers discard events of higher priority).
+    fn add_script_handler<T: ScriptHost, const MAX: u32, const MIN: u32>(
         &mut self,
-        set: S,
+        schedule: impl ScheduleLabel,
     ) -> &mut Self;
-    fn add_script_handler_to_base_set<
-        T: ScriptHost,
-        S: BaseSystemSet,
-        const MAX: u32,
-        const MIN: u32,
-    >(
+
+    /// The same as `add_script_handler` but allows you to specify a system set to add the handler to.
+    fn add_script_handler_to_set<T: ScriptHost, const MAX: u32, const MIN: u32>(
         &mut self,
-        set: S,
+        schedule: impl ScheduleLabel,
+        set: impl SystemSet,
     ) -> &mut Self;
 }
 
 impl AddScriptHostHandler for App {
-    fn add_script_handler_to_set<
-        T: ScriptHost,
-        S: FreeSystemSet,
-        const MAX: u32,
-        const MIN: u32,
-    >(
+    fn add_script_handler_to_set<T: ScriptHost, const MAX: u32, const MIN: u32>(
         &mut self,
-        set: S,
+        schedule: impl ScheduleLabel,
+        set: impl SystemSet,
     ) -> &mut Self {
-        self.add_system(script_event_handler::<T, MAX, MIN>.in_set(set));
+        self.add_systems(schedule, script_event_handler::<T, MAX, MIN>.in_set(set));
         self
     }
-    fn add_script_handler_to_base_set<
-        T: ScriptHost,
-        S: BaseSystemSet,
-        const MAX: u32,
-        const MIN: u32,
-    >(
+
+    fn add_script_handler<T: ScriptHost, const MAX: u32, const MIN: u32>(
         &mut self,
-        set: S,
+        schedule: impl ScheduleLabel,
     ) -> &mut Self {
-        self.add_system(script_event_handler::<T, MAX, MIN>.in_base_set(set));
+        self.add_systems(schedule, script_event_handler::<T, MAX, MIN>);
         self
     }
 }
diff --git a/bevy_mod_scripting_core/src/systems.rs b/bevy_mod_scripting_core/src/systems.rs
index 26dfab86b6..14ccebd46a 100644
--- a/bevy_mod_scripting_core/src/systems.rs
+++ b/bevy_mod_scripting_core/src/systems.rs
@@ -146,7 +146,6 @@ pub fn script_hot_reload_handler<H: ScriptHost>(
 /// Lets the script host handle all script events
 pub fn script_event_handler<H: ScriptHost, const MAX: u32, const MIN: u32>(world: &mut World) {
     // we need to collect the events to drop the borrow of the world
-
     let mut state: CachedScriptState<H> = world.remove_resource().unwrap();
 
     let events = state
diff --git a/bevy_script_api/Cargo.toml b/bevy_script_api/Cargo.toml
index 66f1bb441d..978c407564 100644
--- a/bevy_script_api/Cargo.toml
+++ b/bevy_script_api/Cargo.toml
@@ -26,7 +26,7 @@ lua = ["bevy_mod_scripting_lua","bevy_mod_scripting_lua_derive"]
 rhai = ["bevy_mod_scripting_rhai"]
 
 [dependencies]
-bevy = { version = "0.10.1", default-features = false, features=["bevy_asset","bevy_gltf","bevy_animation","bevy_core_pipeline","bevy_ui","bevy_pbr","bevy_render","bevy_text","bevy_sprite","filesystem_watcher"]}
+bevy = { version = "0.11", default-features = false, features=["bevy_asset","bevy_gltf","bevy_animation","bevy_core_pipeline","bevy_ui","bevy_pbr","bevy_render","bevy_text","bevy_sprite","filesystem_watcher"]}
 bevy_mod_scripting_derive = { path="../bevy_mod_scripting_derive", version = "0.3.0" }
 bevy_mod_scripting_core = { path="../bevy_mod_scripting_core", version = "0.3.0" }
 parking_lot="0.12.1"
diff --git a/bevy_script_api/src/common/bevy/mod.rs b/bevy_script_api/src/common/bevy/mod.rs
index 93a97b6ed8..3128d6312f 100644
--- a/bevy_script_api/src/common/bevy/mod.rs
+++ b/bevy_script_api/src/common/bevy/mod.rs
@@ -141,12 +141,12 @@ impl ScriptWorld {
 
     pub fn despawn_children_recursive(&self, entity: Entity) {
         let mut w = self.write();
-        DespawnChildrenRecursive { entity }.write(&mut w);
+        DespawnChildrenRecursive { entity }.apply(&mut w);
     }
 
     pub fn despawn_recursive(&self, entity: Entity) {
         let mut w = self.write();
-        DespawnRecursive { entity }.write(&mut w);
+        DespawnRecursive { entity }.apply(&mut w);
     }
 
     pub fn get_type_by_name(&self, type_name: &str) -> Option<ScriptTypeRegistration> {
@@ -183,8 +183,7 @@ impl ScriptWorld {
             bevy::reflect::TypeInfo::List(_) => component_data.insert(&mut w.entity_mut(entity), &DynamicList::default()),
             bevy::reflect::TypeInfo::Array(_) => component_data.insert(&mut w.entity_mut(entity), &DynamicArray::new(Box::new([]))),
             bevy::reflect::TypeInfo::Map(_) => component_data.insert(&mut w.entity_mut(entity), &DynamicMap::default()),
-            bevy::reflect::TypeInfo::Value(_) |
-            bevy::reflect::TypeInfo::Dynamic(_) => component_data.insert(&mut w.entity_mut(entity),
+            bevy::reflect::TypeInfo::Value(_) => component_data.insert(&mut w.entity_mut(entity),
                 comp_type.data::<ReflectDefault>().ok_or_else(||
                     ScriptError::Other(format!("Component {} is a value or dynamic type with no `ReflectDefault` type_data, cannot instantiate sensible value",comp_type.short_name())))?
                     .default()
diff --git a/bevy_script_api/src/common/std.rs b/bevy_script_api/src/common/std.rs
index ff4b4b469c..b22ea73cbc 100644
--- a/bevy_script_api/src/common/std.rs
+++ b/bevy_script_api/src/common/std.rs
@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
 
-use bevy::reflect::FromReflect;
+use bevy::reflect::{FromReflect, TypePath};
 
 use crate::{error::ReflectionError, ScriptRef, ValueIndex};
 
@@ -26,7 +26,7 @@ impl<T> std::fmt::Debug for ScriptVec<T> {
     }
 }
 
-impl<T: std::fmt::Display + FromReflect> std::fmt::Display for ScriptVec<T> {
+impl<T: std::fmt::Display + FromReflect + TypePath> std::fmt::Display for ScriptVec<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let str = self
             .ref_
@@ -39,7 +39,7 @@ impl<T: std::fmt::Display + FromReflect> std::fmt::Display for ScriptVec<T> {
     }
 }
 
-impl<T: FromReflect> ScriptVec<T> {
+impl<T: FromReflect + TypePath> ScriptVec<T> {
     pub fn new_ref(ref_: ScriptRef) -> Self {
         Self {
             ref_,
@@ -116,7 +116,7 @@ impl<T: FromReflect> Iterator for ScriptVecIterator<T> {
     }
 }
 
-impl<T: FromReflect> IntoIterator for ScriptVec<T> {
+impl<T: FromReflect + TypePath> IntoIterator for ScriptVec<T> {
     type Item = ScriptRef;
 
     type IntoIter = ScriptVecIterator<T>;
diff --git a/bevy_script_api/src/generated.rs b/bevy_script_api/src/generated.rs
index cba47d9105..72ff7394bc 100644
--- a/bevy_script_api/src/generated.rs
+++ b/bevy_script_api/src/generated.rs
@@ -104,7 +104,6 @@ use bevy::ui::AlignContent;
 use bevy::ui::AlignItems;
 use bevy::ui::AlignSelf;
 use bevy::ui::CalculatedClip;
-use bevy::ui::CalculatedSize;
 use bevy::ui::Direction;
 use bevy::ui::Display;
 use bevy::ui::FlexDirection;
@@ -124,7 +123,10 @@ use std::ops::*;
 use std::sync::Mutex;
 #[cfg(feature = "lua")]
 use {
-    crate::{common::bevy::GetWorld, lua::RegisterForeignLuaType},
+    crate::{
+        common::bevy::GetWorld,
+        lua::{util::LuaIndex, RegisterForeignLuaType},
+    },
     bevy_mod_scripting_lua::{docs::LuaDocFragment, tealr::mlu::mlua::MetaMethod},
     bevy_mod_scripting_lua_derive::impl_lua_newtype,
 };
@@ -352,9 +354,28 @@ impl_script_newtype! {
     Debug +
     Methods
     (
+        ///Show overflowing items on both axes
+        visible() -> self,
+
+        ///Clip overflowing items on both axes
+        clip() -> self,
+
+        ///Clip overflowing items on the x axis
+        clip_x() -> self,
+
+        ///Clip overflowing items on the y axis
+        clip_y() -> self,
+
+        ///Overflow is visible on both axes
+        is_visible(&self:) -> Raw(bool),
+
     )
     + Fields
     (
+        /// Whether to show or clip overflowing items on the x axis
+        x: Raw(ReflectedValue),
+        /// Whether to show or clip overflowing items on the y axis
+        y: Raw(ReflectedValue),
     )
     + BinOps
     (
@@ -390,7 +411,10 @@ impl_script_newtype! {
 }
 impl_script_newtype! {
     #[languages(on_feature(lua))]
-    ///An enum that describes possible types of value in flexbox layout options
+    ///Represents the possible value types for layout properties.
+    ///
+    ///This enum allows specifying values for various [`Style`] properties in different units,
+    ///such as logical pixels, percentages, or automatically determined values.
     bevy_ui::Val :
     Clone +
     Debug +
@@ -436,32 +460,6 @@ impl_script_newtype! {
     {
     }
 }
-impl_script_newtype! {
-    #[languages(on_feature(lua))]
-    ///The calculated size of the node
-    bevy_ui::CalculatedSize :
-    Clone +
-    Debug +
-    Methods
-    (
-    )
-    + Fields
-    (
-        /// The size of the node in logical pixels
-        size: Wrapped(Vec2),
-        /// Whether to attempt to preserve the aspect ratio when determining the layout for this item
-        preserve_aspect_ratio: Raw(bool),
-    )
-    + BinOps
-    (
-    )
-    + UnaryOps
-    (
-    )
-    lua impl
-    {
-    }
-}
 impl_script_newtype! {
     #[languages(on_feature(lua))]
     ///Describes the size of a UI node
@@ -471,9 +469,18 @@ impl_script_newtype! {
     Methods
     (
         ///The calculated node size as width and height in logical pixels
-        ///automatically calculated by [`super::flex::flex_node_system`]
+        ///automatically calculated by [`super::layout::ui_layout_system`]
         size(&self:) -> Wrapped(Vec2),
 
+        ///Returns the size of the node in physical pixels based on the given scale factor and `UiScale`.
+        physical_size(&self:Raw(f64),Raw(f64)) -> Wrapped(Vec2),
+
+        ///Returns the logical pixel coordinates of the UI node, based on its [`GlobalTransform`].
+        logical_rect(&self:Wrapped(&GlobalTransform)) -> Wrapped(Rect),
+
+        ///Returns the physical pixel coordinates of the UI node, based on its [`GlobalTransform`] and the scale factor.
+        physical_rect(&self:Wrapped(&GlobalTransform),Raw(f64),Raw(f64)) -> Wrapped(Rect),
+
     )
     + Fields
     (
@@ -490,9 +497,22 @@ impl_script_newtype! {
 }
 impl_script_newtype! {
     #[languages(on_feature(lua))]
-    ///Describes the style of a UI node
+    ///Describes the style of a UI container node
+    ///
+    ///Node's can be laid out using either Flexbox or CSS Grid Layout.<br />
+    ///See below for general learning resources and for documentation on the individual style properties.
+    ///
+    ///### Flexbox
+    ///
+    ///- [MDN: Basic Concepts of Grid Layout](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Grid_Layout/Basic_Concepts_of_Grid_Layout)
+    ///- [A Complete Guide To Flexbox](https://css-tricks.com/snippets/css/a-guide-to-flexbox/) by CSS Tricks. This is detailed guide with illustrations and comphrehensive written explanation of the different Flexbox properties and how they work.
+    ///- [Flexbox Froggy](https://flexboxfroggy.com/). An interactive tutorial/game that teaches the essential parts of Flebox in a fun engaging way.
+    ///
+    ///### CSS Grid
     ///
-    ///It uses the [Flexbox](https://cssreference.io/flexbox/) system.
+    ///- [MDN: Basic Concepts of Flexbox](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Flexible_Box_Layout/Basic_Concepts_of_Flexbox)
+    ///- [A Complete Guide To CSS Grid](https://css-tricks.com/snippets/css/complete-guide-grid/) by CSS Tricks. This is detailed guide with illustrations and comphrehensive written explanation of the different CSS Grid properties and how they work.
+    ///- [CSS Grid Garden](https://cssgridgarden.com/). An interactive tutorial/game that teaches the essential parts of CSS Grid in a fun engaging way.
     bevy_ui::Style :
     Clone +
     Debug +
@@ -501,30 +521,130 @@ impl_script_newtype! {
     )
     + Fields
     (
-        /// Whether to arrange this node and its children with flexbox layout
+        /// Which layout algorithm to use when laying out this node's contents:
+        ///   - [`Display::Flex`]: Use the Flexbox layout algorithm
+        ///   - [`Display::Grid`]: Use the CSS Grid layout algorithm
+        ///   - [`Display::None`]: Hide this node and perform layout as if it does not exist.
         ///
-        /// If this is set to [`Display::None`], this node will be collapsed.
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/display>
         display: Wrapped(Display),
-        /// Whether to arrange this node relative to other nodes, or positioned absolutely
+        /// Whether a node should be laid out in-flow with, or independently of it's siblings:
+        ///  - [`PositionType::Relative`]: Layout this node in-flow with other nodes using the usual (flexbox/grid) layout algorithm.
+        ///  - [`PositionType::Absolute`]: Layout this node on top and independently of other nodes.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/position>
         position_type: Wrapped(PositionType),
-        /// Which direction the content of this node should go
+        /// Whether overflowing content should be displayed or clipped.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/overflow>
+        overflow: Wrapped(Overflow),
+        /// Defines the text direction. For example English is written LTR (left-to-right) while Arabic is written RTL (right-to-left).
+        ///
+        /// Note: the corresponding CSS property also affects box layout order, but this isn't yet implemented in bevy.
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/direction>
         direction: Wrapped(Direction),
-        /// Whether to use column or row layout
-        flex_direction: Wrapped(FlexDirection),
-        /// How to wrap nodes
-        flex_wrap: Wrapped(FlexWrap),
-        /// How items are aligned according to the cross axis
+        /// The horizontal position of the left edge of the node.
+        ///  - For relatively positioned nodes, this is relative to the node's position as computed during regular layout.
+        ///  - For absolutely positioned nodes, this is relative to the *parent* node's bounding box.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/left>
+        left: Wrapped(Val),
+        /// The horizontal position of the right edge of the node.
+        ///  - For relatively positioned nodes, this is relative to the node's position as computed during regular layout.
+        ///  - For absolutely positioned nodes, this is relative to the *parent* node's bounding box.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/right>
+        right: Wrapped(Val),
+        /// The vertical position of the top edge of the node.
+        ///  - For relatively positioned nodes, this is relative to the node's position as computed during regular layout.
+        ///  - For absolutely positioned nodes, this is relative to the *parent* node's bounding box.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/top>
+        top: Wrapped(Val),
+        /// The vertical position of the bottom edge of the node.
+        ///  - For relatively positioned nodes, this is relative to the node's position as computed during regular layout.
+        ///  - For absolutely positioned nodes, this is relative to the *parent* node's bounding box.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/bottom>
+        bottom: Wrapped(Val),
+        /// The ideal width of the node. `width` is used when it is within the bounds defined by `min_width` and `max_width`.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/width>
+        width: Wrapped(Val),
+        /// The ideal height of the node. `height` is used when it is within the bounds defined by `min_height` and `max_height`.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/height>
+        height: Wrapped(Val),
+        /// The minimum width of the node. `min_width` is used if it is greater than either `width` and/or `max_width`.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/min-width>
+        min_width: Wrapped(Val),
+        /// The minimum height of the node. `min_height` is used if it is greater than either `height` and/or `max_height`.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/min-height>
+        min_height: Wrapped(Val),
+        /// The maximum width of the node. `max_width` is used if it is within the bounds defined by `min_width` and `width`.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/max-width>
+        max_width: Wrapped(Val),
+        /// The maximum height of the node. `max_height` is used if it is within the bounds defined by `min_height` and `height`.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/max-height>
+        max_height: Wrapped(Val),
+        /// The aspect ratio of the node (defined as `width / height`)
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/aspect-ratio>
+        aspect_ratio: Raw(ReflectedValue),
+        /// For Flexbox containers:
+        ///   - Sets default cross-axis alignment of the child items.
+        /// For CSS Grid containers:
+        ///   - Controls block (vertical) axis alignment of children of this grid container within their grid areas
+        ///
+        /// This value is overriden [`JustifySelf`] on the child node is set.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/align-items>
         align_items: Wrapped(AlignItems),
-        /// How this item is aligned according to the cross axis.
-        /// Overrides [`AlignItems`].
+        /// For Flexbox containers:
+        ///   - This property has no effect. See `justify_content` for main-axis alignment of flex items.
+        /// For CSS Grid containers:
+        ///   - Sets default inline (horizontal) axis alignment of child items within their grid areas
+        ///
+        /// This value is overriden [`JustifySelf`] on the child node is set.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/justify-items>
+        justify_items: Raw(ReflectedValue),
+        /// For Flexbox items:
+        ///   - Controls cross-axis alignment of the item.
+        /// For CSS Grid items:
+        ///   - Controls block (vertical) axis alignment of a grid item within it's grid area
+        ///
+        /// If set to `Auto`, alignment is inherited from the value of [`AlignItems`] set on the parent node.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/align-self>
         align_self: Wrapped(AlignSelf),
-        /// How to align each line, only applies if flex_wrap is set to
-        /// [`FlexWrap::Wrap`] and there are multiple lines of items
+        /// For Flexbox items:
+        ///   - This property has no effect. See `justify_content` for main-axis alignment of flex items.
+        /// For CSS Grid items:
+        ///   - Controls inline (horizontal) axis alignment of a grid item within it's grid area.
+        ///
+        /// If set to `Auto`, alignment is inherited from the value of [`JustifyItems`] set on the parent node.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/justify-items>
+        justify_self: Raw(ReflectedValue),
+        /// For Flexbox containers:
+        ///   - Controls alignment of lines if flex_wrap is set to [`FlexWrap::Wrap`] and there are multiple lines of items
+        /// For CSS Grid container:
+        ///   - Controls alignment of grid rows
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/align-content>
         align_content: Wrapped(AlignContent),
-        /// How items align according to the main axis
+        /// For Flexbox containers:
+        ///   - Controls alignment of items in the main axis
+        /// For CSS Grid containers:
+        ///   - Controls alignment of grid columns
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/justify-content>
         justify_content: Wrapped(JustifyContent),
-        /// The position of the node as described by its Rect
-        position: Raw(ReflectedValue),
         /// The amount of space around a node outside its border.
         ///
         /// If a percentage value is used, the percentage is calculated based on the width of the parent node.
@@ -542,7 +662,9 @@ impl_script_newtype! {
         ///     ..Default::default()
         /// };
         /// ```
-        /// A node with this style and a parent with dimensions of 100px by 300px, will have calculated margins of 10px on both left and right edges, and 15px on both top and bottom egdes.
+        /// A node with this style and a parent with dimensions of 100px by 300px, will have calculated margins of 10px on both left and right edges, and 15px on both top and bottom edges.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/margin>
         margin: Raw(ReflectedValue),
         /// The amount of space between the edges of a node and its contents.
         ///
@@ -562,6 +684,8 @@ impl_script_newtype! {
         /// };
         /// ```
         /// A node with this style and a parent with dimensions of 300px by 100px, will have calculated padding of 3px on the left, 6px on the right, 9px on the top and 12px on the bottom.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/padding>
         padding: Raw(ReflectedValue),
         /// The amount of space between the margins of a node and its padding.
         ///
@@ -570,38 +694,76 @@ impl_script_newtype! {
         /// The size of the node will be expanded if there are constraints that prevent the layout algorithm from placing the border within the existing node boundary.
         ///
         /// Rendering for borders is not yet implemented.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/border-width>
         border: Raw(ReflectedValue),
-        /// Defines how much a flexbox item should grow if there's space available
+        /// Whether a Flexbox container should be a row or a column. This property has no effect of Grid nodes.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/flex-direction>
+        flex_direction: Wrapped(FlexDirection),
+        /// Whether a Flexbox container should wrap it's contents onto multiple line wrap if they overflow. This property has no effect of Grid nodes.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/flex-wrap>
+        flex_wrap: Wrapped(FlexWrap),
+        /// Defines how much a flexbox item should grow if there's space available. Defaults to 0 (don't grow at all).
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/flex-grow>
         flex_grow: Raw(f32),
-        /// How to shrink if there's not enough space available
+        /// Defines how much a flexbox item should shrink if there's not enough space available. Defaults to 1.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/flex-shrink>
         flex_shrink: Raw(f32),
-        /// The initial length of the main axis, before other properties are applied.
+        /// The initial length of a flexbox in the main axis, before flex growing/shrinking properties are applied.
         ///
-        /// If both are set, `flex_basis` overrides `size` on the main axis but it obeys the bounds defined by `min_size` and `max_size`.
+        /// `flex_basis` overrides `size` on the main axis if both are set,  but it obeys the bounds defined by `min_size` and `max_size`.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/flex-basis>
         flex_basis: Wrapped(Val),
-        /// The ideal size of the flexbox
-        ///
-        /// `size.width` is used when it is within the bounds defined by `min_size.width` and `max_size.width`.
-        /// `size.height` is used when it is within the bounds defined by `min_size.height` and `max_size.height`.
-        size: Raw(ReflectedValue),
-        /// The minimum size of the flexbox
-        ///
-        /// `min_size.width` is used if it is greater than either `size.width` or `max_size.width`, or both.
-        /// `min_size.height` is used if it is greater than either `size.height` or `max_size.height`, or both.
-        min_size: Raw(ReflectedValue),
-        /// The maximum size of the flexbox
-        ///
-        /// `max_size.width` is used if it is within the bounds defined by `min_size.width` and `size.width`.
-        /// `max_size.height` is used if it is within the bounds defined by `min_size.height` and `size.height.
-        max_size: Raw(ReflectedValue),
-        /// The aspect ratio of the flexbox
-        aspect_ratio: Raw(ReflectedValue),
-        /// How to handle overflow
-        overflow: Wrapped(Overflow),
-        /// The size of the gutters between the rows and columns of the flexbox layout
+        /// The size of the gutters between items in a vertical flexbox layout or between rows in a grid layout
+        ///
+        /// Note: Values of `Val::Auto` are not valid and are treated as zero.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/row-gap>
+        row_gap: Wrapped(Val),
+        /// The size of the gutters between items in a horizontal flexbox layout or between column in a grid layout
+        ///
+        /// Note: Values of `Val::Auto` are not valid and are treated as zero.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/column-gap>
+        column_gap: Wrapped(Val),
+        /// Controls whether automatically placed grid items are placed row-wise or column-wise. And whether the sparse or dense packing algorithm is used.
+        /// Only affect Grid layouts
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/grid-auto-flow>
+        grid_auto_flow: Raw(ReflectedValue),
+        /// Defines the number of rows a grid has and the sizes of those rows. If grid items are given explicit placements then more rows may
+        /// be implicitly generated by items that are placed out of bounds. The sizes of those rows are controlled by `grid_auto_rows` property.
         ///
-        /// Values of `Size::UNDEFINED` and `Size::AUTO` are treated as zero.
-        gap: Raw(ReflectedValue),
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/grid-template-rows>
+        grid_template_rows: Raw(ReflectedValue),
+        /// Defines the number of columns a grid has and the sizes of those columns. If grid items are given explicit placements then more columns may
+        /// be implicitly generated by items that are placed out of bounds. The sizes of those columns are controlled by `grid_auto_columns` property.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/grid-template-columns>
+        grid_template_columns: Raw(ReflectedValue),
+        /// Defines the size of implicitly created rows. Rows are created implicitly when grid items are given explicit placements that are out of bounds
+        /// of the rows explicitly created using `grid_template_rows`.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/grid-auto-rows>
+        grid_auto_rows: Raw(ReflectedValue),
+        /// Defines the size of implicitly created columns. Columns are created implicitly when grid items are given explicit placements that are out of bounds
+        /// of the columns explicitly created using `grid_template_columms`.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/grid-template-columns>
+        grid_auto_columns: Raw(ReflectedValue),
+        /// The row in which a grid item starts and how many rows it spans.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/grid-row>
+        grid_row: Raw(ReflectedValue),
+        /// The column in which a grid item starts and how many columns it spans.
+        ///
+        /// <https://developer.mozilla.org/en-US/docs/Web/CSS/grid-column>
+        grid_column: Raw(ReflectedValue),
     )
     + BinOps
     (
@@ -621,6 +783,12 @@ impl_script_newtype! {
     Debug +
     Methods
     (
+        ///flip the image along its x-axis
+        with_flip_x(self:) -> self,
+
+        ///flip the image along its y-axis
+        with_flip_y(self:) -> self,
+
     )
     + Fields
     (
@@ -835,7 +1003,7 @@ impl_script_newtype! {
     #[languages(on_feature(lua))]
     ///The maximum width and height of text. The text will wrap according to the specified size.
     ///Characters out of the bounds after wrapping will be truncated. Text is aligned according to the
-    ///specified `TextAlignment`.
+    ///specified [`TextAlignment`](crate::text::TextAlignment).
     ///
     ///Note: only characters that are completely out of the bounds will be truncated, so this is not a
     ///reliable limit if it is necessary to contain the text strictly in the bounds. Currently this
@@ -870,6 +1038,10 @@ impl_script_newtype! {
         ///Returns this [`Text`] with a new [`TextAlignment`].
         with_alignment(self:Wrapped(TextAlignment)) -> self,
 
+        ///Returns this [`Text`] with soft wrapping disabled.
+        ///Hard wrapping, where text contains an explicit linebreak such as the escape sequence `\n`, will still occur.
+        with_no_wrap(self:) -> self,
+
     )
     + Fields
     (
@@ -878,7 +1050,7 @@ impl_script_newtype! {
         /// Should not affect its position within a container.
         alignment: Wrapped(TextAlignment),
         /// How the text should linebreak when running out of the bounds determined by max_size
-        linebreak_behaviour: Raw(ReflectedValue),
+        linebreak_behavior: Raw(ReflectedValue),
     )
     + BinOps
     (
@@ -1420,7 +1592,7 @@ impl_script_newtype! {
     ///[`GlobalTransform`] is updated from [`Transform`] by systems in the system set
     ///[`TransformPropagate`](crate::TransformSystem::TransformPropagate).
     ///
-    ///This system runs during [`CoreSet::PostUpdate`](crate::CoreSet::PostUpdate). If you
+    ///This system runs during [`PostUpdate`](bevy_app::PostUpdate). If you
     ///update the [`Transform`] of an entity during this set or after, you will notice a 1 frame lag
     ///before the [`GlobalTransform`] is updated.
     ///
@@ -1460,10 +1632,20 @@ impl_script_newtype! {
 
         ///Returns this [`Transform`] with a new rotation so that [`Transform::forward`]
         ///points towards the `target` position and [`Transform::up`] points towards `up`.
+        ///
+        ///In some cases it's not possible to construct a rotation. Another axis will be picked in those cases:
+        ///* if `target` is the same as the transform translation, `Vec3::Z` is used instead
+        ///* if `up` is zero, `Vec3::Y` is used instead
+        ///* if the resulting forward direction is parallel with `up`, an orthogonal vector is used as the "right" direction
         looking_at(self:Wrapped(Vec3),Wrapped(Vec3)) -> self,
 
         ///Returns this [`Transform`] with a new rotation so that [`Transform::forward`]
         ///points in the given `direction` and [`Transform::up`] points towards `up`.
+        ///
+        ///In some cases it's not possible to construct a rotation. Another axis will be picked in those cases:
+        ///* if `direction` is zero, `Vec3::Z` is used instead
+        ///* if `up` is zero, `Vec3::Y` is used instead
+        ///* if `direction` is parallel with `up`, an orthogonal vector is used as the "right" direction
         looking_to(self:Wrapped(Vec3),Wrapped(Vec3)) -> self,
 
         ///Returns this [`Transform`] with a new translation.
@@ -1570,10 +1752,20 @@ impl_script_newtype! {
 
         ///Rotates this [`Transform`] so that [`Transform::forward`] points towards the `target` position,
         ///and [`Transform::up`] points towards `up`.
+        ///
+        ///In some cases it's not possible to construct a rotation. Another axis will be picked in those cases:
+        ///* if `target` is the same as the transtorm translation, `Vec3::Z` is used instead
+        ///* if `up` is zero, `Vec3::Y` is used instead
+        ///* if the resulting forward direction is parallel with `up`, an orthogonal vector is used as the "right" direction
         look_at(&mut self:Wrapped(Vec3),Wrapped(Vec3)),
 
         ///Rotates this [`Transform`] so that [`Transform::forward`] points in the given `direction`
         ///and [`Transform::up`] points towards `up`.
+        ///
+        ///In some cases it's not possible to construct a rotation. Another axis will be picked in those cases:
+        ///* if `direction` is zero, `Vec3::NEG_Z` is used instead
+        ///* if `up` is zero, `Vec3::Y` is used instead
+        ///* if `direction` is parallel with `up`, an orthogonal vector is used as the "right" direction
         look_to(&mut self:Wrapped(Vec3),Wrapped(Vec3)),
 
         ///Multiplies `self` with `transform` component by component, returning the
@@ -1647,8 +1839,8 @@ impl_script_newtype! {
     ///[`GlobalTransform`] is updated from [`Transform`] by systems in the system set
     ///[`TransformPropagate`](crate::TransformSystem::TransformPropagate).
     ///
-    ///This system runs during [`CoreSet::PostUpdate`](crate::CoreSet::PostUpdate). If you
-    ///update the [`Transform`] of an entity in this stage or after, you will notice a 1 frame lag
+    ///This system runs during [`PostUpdate`](bevy_app::PostUpdate). If you
+    ///update the [`Transform`] of an entity in this schedule or after, you will notice a 1 frame lag
     ///before the [`GlobalTransform`] is updated.
     ///
     ///# Examples
@@ -1676,9 +1868,9 @@ impl_script_newtype! {
         ///Returns the [`Transform`] `self` would have if it was a child of an entity
         ///with the `parent` [`GlobalTransform`].
         ///
-        ///This is useful if you want to "reparent" an `Entity`. Say you have an entity
-        ///`e1` that you want to turn into a child of `e2`, but you want `e1` to keep the
-        ///same global transform, even after re-parenting. You would use:
+        ///This is useful if you want to "reparent" an [`Entity`](bevy_ecs::entity::Entity).
+        ///Say you have an entity `e1` that you want to turn into a child of `e2`,
+        ///but you want `e1` to keep the same global transform, even after re-parenting. You would use:
         ///
         ///```rust
         ///# use bevy_transform::prelude::{GlobalTransform, Transform};
@@ -1750,8 +1942,8 @@ impl_script_newtype! {
     )
     + BinOps
     (
-        self Mul Wrapped(GlobalTransform) -> Wrapped(GlobalTransform),
         self Mul Wrapped(Transform) -> Wrapped(GlobalTransform),
+        self Mul Wrapped(GlobalTransform) -> Wrapped(GlobalTransform),
         self Mul Wrapped(Vec3) -> Wrapped(Vec3),
     )
     + UnaryOps
@@ -2186,6 +2378,8 @@ impl_script_newtype! {
         clear_color: Wrapped(ClearColorConfig),
         /// The depth clear operation to perform for the main 3d pass.
         depth_load_op: Wrapped(Camera3dDepthLoadOp),
+        /// The texture usages for the depth texture created for the main 3d pass.
+        depth_texture_usages: Raw(ReflectedValue),
     )
     + BinOps
     (
@@ -2372,7 +2566,7 @@ impl_script_newtype! {
     ///User indication of whether an entity is visible. Propagates down the entity hierarchy.
     ///
     ///If an entity is hidden in this way, all [`Children`] (and all of their children and so on) who
-    ///are set to `Inherited` will also be hidden.
+    ///are set to [`Inherited`](Self::Inherited) will also be hidden.
     ///
     ///This is done by the `visibility_propagate_system` which uses the entity hierarchy and
     ///`Visibility` to set the values of each entity's [`ComputedVisibility`] component.
@@ -2442,20 +2636,20 @@ impl_script_newtype! {
     (
         ///Whether this entity is visible to something this frame. This is true if and only if [`Self::is_visible_in_hierarchy`] and [`Self::is_visible_in_view`]
         ///are true. This is the canonical method to call to determine if an entity should be drawn.
-        ///This value is updated in [`CoreSet::PostUpdate`] by the [`VisibilitySystems::CheckVisibility`] system set.
-        ///Reading it during [`CoreSet::Update`] will yield the value from the previous frame.
+        ///This value is updated in [`PostUpdate`] by the [`VisibilitySystems::CheckVisibility`] system set.
+        ///Reading it during [`Update`](bevy_app::Update) will yield the value from the previous frame.
         is_visible(&self:) -> Raw(bool),
 
         ///Whether this entity is visible in the entity hierarchy, which is determined by the [`Visibility`] component.
         ///This takes into account "visibility inheritance". If any of this entity's ancestors (see [`Parent`]) are hidden, this entity
-        ///will be hidden as well. This value is updated in the [`VisibilitySystems::VisibilityPropagate`], which lives under the [`CoreSet::PostUpdate`] set.
+        ///will be hidden as well. This value is updated in the [`VisibilitySystems::VisibilityPropagate`], which lives in the [`PostUpdate`] schedule.
         is_visible_in_hierarchy(&self:) -> Raw(bool),
 
         ///Whether this entity is visible in _any_ view (Cameras, Lights, etc). Each entity type (and view type) should choose how to set this
         ///value. For cameras and drawn entities, this will take into account [`RenderLayers`].
         ///
-        ///This value is reset to `false` every frame in [`VisibilitySystems::VisibilityPropagate`] during [`CoreSet::PostUpdate`].
-        ///Each entity type then chooses how to set this field in the [`VisibilitySystems::CheckVisibility`] system set, under [`CoreSet::PostUpdate`].
+        ///This value is reset to `false` every frame in [`VisibilitySystems::VisibilityPropagate`] during [`PostUpdate`].
+        ///Each entity type then chooses how to set this field in the [`VisibilitySystems::CheckVisibility`] system set, in [`PostUpdate`].
         ///Meshes might use frustum culling to decide if they are visible in a view.
         ///Other entities might just set this to `true` every frame.
         is_visible_in_view(&self:) -> Raw(bool),
@@ -2600,6 +2794,29 @@ impl_script_newtype! {
         ///See also [`Color::hsl`].
         hsla(Raw(f32),Raw(f32),Raw(f32),Raw(f32)) -> Wrapped(Color),
 
+        ///New `Color` with LCH representation in sRGB colorspace.
+        ///
+        ///# Arguments
+        ///
+        ///* `lightness` - Lightness channel. [0.0, 1.5]
+        ///* `chroma` - Chroma channel. [0.0, 1.5]
+        ///* `hue` - Hue channel. [0.0, 360.0]
+        ///
+        ///See also [`Color::lcha`].
+        lch(Raw(f32),Raw(f32),Raw(f32)) -> Wrapped(Color),
+
+        ///New `Color` with LCH representation in sRGB colorspace.
+        ///
+        ///# Arguments
+        ///
+        ///* `lightness` - Lightness channel. [0.0, 1.5]
+        ///* `chroma` - Chroma channel. [0.0, 1.5]
+        ///* `hue` - Hue channel. [0.0, 360.0]
+        ///* `alpha` - Alpha channel. [0.0, 1.0]
+        ///
+        ///See also [`Color::lch`].
+        lcha(Raw(f32),Raw(f32),Raw(f32),Raw(f32)) -> Wrapped(Color),
+
         ///New `Color` from sRGB colorspace.
         ///
         ///# Arguments
@@ -2677,11 +2894,11 @@ impl_script_newtype! {
     )
     + BinOps
     (
-        self Add Wrapped(Color) -> Wrapped(Color),
         self Add Wrapped(Vec4) -> Wrapped(Color),
+        self Add Wrapped(Color) -> Wrapped(Color),
+        self Mul Wrapped(Vec3) -> Wrapped(Color),
         self Mul Raw(f32) -> Wrapped(Color),
         self Mul Wrapped(Vec4) -> Wrapped(Color),
-        self Mul Wrapped(Vec3) -> Wrapped(Color),
     )
     + UnaryOps
     (
@@ -2742,9 +2959,9 @@ impl_script_newtype! {
 }
 impl_script_newtype! {
     #[languages(on_feature(lua))]
-    ///A frustum defined by the 6 containing planes
-    ///Planes are ordered left, right, top, bottom, near, far
-    ///Normals point into the contained volume
+    ///A frustum made up of the 6 defining half spaces.
+    ///Half spaces are ordered left, right, top, bottom, near, far.
+    ///The normal vectors of the half spaces point towards the interior of the frustum.
     bevy_render::primitives::Frustum :
     Clone +
     Debug +
@@ -2753,10 +2970,11 @@ impl_script_newtype! {
         ///Returns a frustum derived from `view_projection`.
         from_view_projection(Wrapped(&Mat4)) -> self,
 
-        ///Returns a frustum derived from `view_projection`, but with a custom
-        ///far plane.
+        ///Returns a frustum derived from `view_projection`,
+        ///but with a custom far plane.
         from_view_projection_custom_far(Wrapped(&Mat4),Wrapped(&Vec3),Wrapped(&Vec3),Raw(f32)) -> self,
 
+        ///Checks if an Oriented Bounding Box (obb) intersects the frustum.
         intersects_obb(&self:Wrapped(&Aabb),Wrapped(&Mat4),Raw(bool),Raw(bool)) -> Raw(bool),
 
     )
@@ -2793,6 +3011,7 @@ impl_script_newtype! {
     ///```
     bevy_render::view::Msaa :
     Clone +
+    Debug +
     Methods
     (
         samples(&self:) -> Raw(u32),
@@ -2813,8 +3032,8 @@ impl_script_newtype! {
 }
 impl_script_newtype! {
     #[languages(on_feature(lua))]
-    ///The defining component for camera entities, storing information about how and what to render
-    ///through this camera.
+    ///The defining [`Component`] for camera entities,
+    ///storing information about how and what to render through this camera.
     ///
     ///The [`Camera`] component is added to an entity to define the properties of the viewpoint from
     ///which rendering occurs. It defines the position of the view to render, the projection method
@@ -2844,9 +3063,7 @@ impl_script_newtype! {
         /// The "target" that this camera will render to.
         target: Wrapped(RenderTarget),
         /// If this is set to `true`, the camera will use an intermediate "high dynamic range" render texture.
-        /// Warning: we are still working on this feature. If MSAA is enabled, there will be artifacts in
-        /// some cases. When rendering with WebGL, this will crash if MSAA is enabled.
-        /// See <https://github.com/bevyengine/bevy/pull/3425> for details.
+        /// This allows rendering with a wider range of lighting values.
         hdr: Raw(bool),
         /// If this is enabled, a previous camera exists that shares this camera's render target, and this camera has MSAA enabled, then the previous camera's
         /// outputs will be written to the intermediate multi-sampled render target textures for this camera. This enables cameras with MSAA enabled to
@@ -3349,7 +3566,7 @@ impl_script_newtype! {
         ///
         ///For valid results, `self` must _not_ be of length zero, nor very close to zero.
         ///
-        ///See also [`Self::try_normalize`] and [`Self::normalize_or_zero`].
+        ///See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].
         ///
         ///Panics
         ///
@@ -3361,7 +3578,7 @@ impl_script_newtype! {
         ///In particular, if the input is zero (or very close to zero), or non-finite,
         ///the result of this operation will be zero.
         ///
-        ///See also [`Self::try_normalize`].
+        ///See also [`Self::try_normalize()`].
         normalize_or_zero(self:) -> self,
 
         ///Returns whether `self` is length `1.0` or not.
@@ -3423,6 +3640,10 @@ impl_script_newtype! {
         ///each element of `self`.
         ceil(self:) -> self,
 
+        ///Returns a vector containing the integer part each element of `self`. This means numbers are
+        ///always truncated towards zero.
+        trunc(self:) -> self,
+
         ///Returns a vector containing the fractional part of the vector, e.g. `self -
         ///self.floor()`.
         ///
@@ -3480,13 +3701,14 @@ impl_script_newtype! {
         mul_add(self:self,self) -> self,
 
         ///Creates a 2D vector containing `[angle.cos(), angle.sin()]`. This can be used in
-        ///conjunction with the `rotate` method, e.g. `Vec2::from_angle(PI).rotate(Vec2::Y)` will
-        ///create the vector [-1, 0] and rotate `Vec2::Y` around it returning `-Vec2::Y`.
+        ///conjunction with the [`rotate()`][Self::rotate()] method, e.g.
+        ///`Vec2::from_angle(PI).rotate(Vec2::Y)` will create the vector `[-1, 0]`
+        ///and rotate [`Vec2::Y`] around it returning `-Vec2::Y`.
         from_angle(Raw(f32)) -> self,
 
-        ///Returns the angle (in radians) between `self` and `rhs`.
+        ///Returns the angle (in radians) between `self` and `rhs` in the range `[-π, +π]`.
         ///
-        ///The input vectors do not need to be unit length however they must be non-zero.
+        ///The inputs do not need to be unit vectors however they must be non-zero.
         angle_between(self:self) -> Raw(f32),
 
         ///Returns a vector that is equal to `self` rotated by 90 degrees.
@@ -3518,18 +3740,18 @@ impl_script_newtype! {
     )
     + BinOps
     (
-        self Add self -> Wrapped(Vec2),
         self Add Raw(f32) -> Wrapped(Vec2),
         self Add Wrapped(Vec2) -> Wrapped(Vec2),
-        self Sub self -> Wrapped(Vec2),
-        self Sub Raw(f32) -> Wrapped(Vec2),
+        self Add self -> Wrapped(Vec2),
         self Sub Wrapped(Vec2) -> Wrapped(Vec2),
-        self Div self -> Wrapped(Vec2),
-        self Div Raw(f32) -> Wrapped(Vec2),
+        self Sub Raw(f32) -> Wrapped(Vec2),
+        self Sub self -> Wrapped(Vec2),
         self Div Wrapped(Vec2) -> Wrapped(Vec2),
-        self Mul self -> Wrapped(Vec2),
+        self Div Raw(f32) -> Wrapped(Vec2),
+        self Div self -> Wrapped(Vec2),
         self Mul Raw(f32) -> Wrapped(Vec2),
         self Mul Wrapped(Vec2) -> Wrapped(Vec2),
+        self Mul self -> Wrapped(Vec2),
         self Rem self -> Wrapped(Vec2),
         self Rem Raw(f32) -> Wrapped(Vec2),
         self Rem Wrapped(Vec2) -> Wrapped(Vec2),
@@ -3540,8 +3762,8 @@ impl_script_newtype! {
     )
     lua impl
     {
-        (MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])};
-        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,f32)| {s.val_mut(|s| Ok(s[idx] = val))?};
+        (MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])};
+        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,f32)| {s.val_mut(|s| Ok(s[*idx] = val))?};
     }
 }
 impl_script_newtype! {
@@ -3570,7 +3792,7 @@ impl_script_newtype! {
 
         ///Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`.
         ///
-        ///Truncation may also be performed by using `self.xy()` or `Vec2::from()`.
+        ///Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()].
         truncate(self:) -> Wrapped(Vec2),
 
         ///Computes the dot product of `self` and `rhs`.
@@ -3707,7 +3929,7 @@ impl_script_newtype! {
         ///
         ///For valid results, `self` must _not_ be of length zero, nor very close to zero.
         ///
-        ///See also [`Self::try_normalize`] and [`Self::normalize_or_zero`].
+        ///See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].
         ///
         ///Panics
         ///
@@ -3719,7 +3941,7 @@ impl_script_newtype! {
         ///In particular, if the input is zero (or very close to zero), or non-finite,
         ///the result of this operation will be zero.
         ///
-        ///See also [`Self::try_normalize`].
+        ///See also [`Self::try_normalize()`].
         normalize_or_zero(self:) -> self,
 
         ///Returns whether `self` is length `1.0` or not.
@@ -3781,6 +4003,10 @@ impl_script_newtype! {
         ///each element of `self`.
         ceil(self:) -> self,
 
+        ///Returns a vector containing the integer part each element of `self`. This means numbers are
+        ///always truncated towards zero.
+        trunc(self:) -> self,
+
         ///Returns a vector containing the fractional part of the vector, e.g. `self -
         ///self.floor()`.
         ///
@@ -3839,19 +4065,20 @@ impl_script_newtype! {
 
         ///Returns the angle (in radians) between two vectors.
         ///
-        ///The input vectors do not need to be unit length however they must be non-zero.
+        ///The inputs do not need to be unit vectors however they must be non-zero.
         angle_between(self:self) -> Raw(f32),
 
         ///Returns some vector that is orthogonal to the given one.
         ///
         ///The input vector must be finite and non-zero.
         ///
-        ///The output vector is not necessarily unit-length.
-        ///For that use [`Self::any_orthonormal_vector`] instead.
+        ///The output vector is not necessarily unit length. For that use
+        ///[`Self::any_orthonormal_vector()`] instead.
         any_orthogonal_vector(&self:) -> self,
 
-        ///Returns any unit-length vector that is orthogonal to the given one.
-        ///The input vector must be finite and non-zero.
+        ///Returns any unit vector that is orthogonal to the given one.
+        ///
+        ///The input vector must be unit length.
         ///
         ///# Panics
         ///
@@ -3877,20 +4104,20 @@ impl_script_newtype! {
     + BinOps
     (
         self Add self -> Wrapped(Vec3),
-        self Add Raw(f32) -> Wrapped(Vec3),
         self Add Wrapped(Vec3) -> Wrapped(Vec3),
-        self Sub self -> Wrapped(Vec3),
+        self Add Raw(f32) -> Wrapped(Vec3),
         self Sub Raw(f32) -> Wrapped(Vec3),
+        self Sub self -> Wrapped(Vec3),
         self Sub Wrapped(Vec3) -> Wrapped(Vec3),
-        self Div self -> Wrapped(Vec3),
-        self Div Raw(f32) -> Wrapped(Vec3),
         self Div Wrapped(Vec3) -> Wrapped(Vec3),
+        self Div Raw(f32) -> Wrapped(Vec3),
+        self Div self -> Wrapped(Vec3),
         self Mul self -> Wrapped(Vec3),
-        self Mul Raw(f32) -> Wrapped(Vec3),
         self Mul Wrapped(Vec3) -> Wrapped(Vec3),
+        self Mul Raw(f32) -> Wrapped(Vec3),
         self Rem self -> Wrapped(Vec3),
-        self Rem Raw(f32) -> Wrapped(Vec3),
         self Rem Wrapped(Vec3) -> Wrapped(Vec3),
+        self Rem Raw(f32) -> Wrapped(Vec3),
     )
     + UnaryOps
     (
@@ -3898,18 +4125,21 @@ impl_script_newtype! {
     )
     lua impl
     {
-        (MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])};
-        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,f32)| {s.val_mut(|s| Ok(s[idx] = val))?};
+        (MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])};
+        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,f32)| {s.val_mut(|s| Ok(s[*idx] = val))?};
     }
 }
 impl_script_newtype! {
     #[languages(on_feature(lua))]
-    ///A 3-dimensional vector with SIMD support.
+    ///A 3-dimensional vector.
     ///
-    ///This type is 16 byte aligned. A SIMD vector type is used for storage on supported platforms for
-    ///better performance than the `Vec3` type.
+    ///SIMD vector types are used for storage on supported platforms for better
+    ///performance than the [`Vec3`] type.
     ///
-    ///It is possible to convert between `Vec3` and `Vec3A` types using `From` trait implementations.
+    ///It is possible to convert between [`Vec3`] and [`Vec3A`] types using [`From`]
+    ///or [`Into`] trait implementations.
+    ///
+    ///This type is 16 byte aligned.
     glam::f32::Vec3A :
     Clone +
     Debug +
@@ -3933,7 +4163,7 @@ impl_script_newtype! {
 
         ///Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`.
         ///
-        ///Truncation may also be performed by using `self.xy()` or `Vec2::from()`.
+        ///Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()].
         truncate(self:) -> Wrapped(Vec2),
 
         ///Computes the dot product of `self` and `rhs`.
@@ -4070,7 +4300,7 @@ impl_script_newtype! {
         ///
         ///For valid results, `self` must _not_ be of length zero, nor very close to zero.
         ///
-        ///See also [`Self::try_normalize`] and [`Self::normalize_or_zero`].
+        ///See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].
         ///
         ///Panics
         ///
@@ -4082,7 +4312,7 @@ impl_script_newtype! {
         ///In particular, if the input is zero (or very close to zero), or non-finite,
         ///the result of this operation will be zero.
         ///
-        ///See also [`Self::try_normalize`].
+        ///See also [`Self::try_normalize()`].
         normalize_or_zero(self:) -> self,
 
         ///Returns whether `self` is length `1.0` or not.
@@ -4144,6 +4374,10 @@ impl_script_newtype! {
         ///each element of `self`.
         ceil(self:) -> self,
 
+        ///Returns a vector containing the integer part each element of `self`. This means numbers are
+        ///always truncated towards zero.
+        trunc(self:) -> self,
+
         ///Returns a vector containing the fractional part of the vector, e.g. `self -
         ///self.floor()`.
         ///
@@ -4202,19 +4436,20 @@ impl_script_newtype! {
 
         ///Returns the angle (in radians) between two vectors.
         ///
-        ///The input vectors do not need to be unit length however they must be non-zero.
+        ///The inputs do not need to be unit vectors however they must be non-zero.
         angle_between(self:self) -> Raw(f32),
 
         ///Returns some vector that is orthogonal to the given one.
         ///
         ///The input vector must be finite and non-zero.
         ///
-        ///The output vector is not necessarily unit-length.
-        ///For that use [`Self::any_orthonormal_vector`] instead.
+        ///The output vector is not necessarily unit length. For that use
+        ///[`Self::any_orthonormal_vector()`] instead.
         any_orthogonal_vector(&self:) -> self,
 
-        ///Returns any unit-length vector that is orthogonal to the given one.
-        ///The input vector must be finite and non-zero.
+        ///Returns any unit vector that is orthogonal to the given one.
+        ///
+        ///The input vector must be unit length.
         ///
         ///# Panics
         ///
@@ -4236,21 +4471,21 @@ impl_script_newtype! {
     )
     + BinOps
     (
-        self Add self -> Wrapped(Vec3A),
-        self Add Raw(f32) -> Wrapped(Vec3A),
         self Add Wrapped(Vec3A) -> Wrapped(Vec3A),
+        self Add Raw(f32) -> Wrapped(Vec3A),
+        self Add self -> Wrapped(Vec3A),
+        self Sub Wrapped(Vec3A) -> Wrapped(Vec3A),
         self Sub self -> Wrapped(Vec3A),
         self Sub Raw(f32) -> Wrapped(Vec3A),
-        self Sub Wrapped(Vec3A) -> Wrapped(Vec3A),
-        self Div self -> Wrapped(Vec3A),
         self Div Raw(f32) -> Wrapped(Vec3A),
+        self Div self -> Wrapped(Vec3A),
         self Div Wrapped(Vec3A) -> Wrapped(Vec3A),
         self Mul self -> Wrapped(Vec3A),
-        self Mul Raw(f32) -> Wrapped(Vec3A),
         self Mul Wrapped(Vec3A) -> Wrapped(Vec3A),
-        self Rem self -> Wrapped(Vec3A),
-        self Rem Raw(f32) -> Wrapped(Vec3A),
+        self Mul Raw(f32) -> Wrapped(Vec3A),
         self Rem Wrapped(Vec3A) -> Wrapped(Vec3A),
+        self Rem Raw(f32) -> Wrapped(Vec3A),
+        self Rem self -> Wrapped(Vec3A),
     )
     + UnaryOps
     (
@@ -4258,15 +4493,17 @@ impl_script_newtype! {
     )
     lua impl
     {
-        (MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])};
-        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,f32)| {s.val_mut(|s| Ok(s[idx] = val))?};
+        (MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])};
+        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,f32)| {s.val_mut(|s| Ok(s[*idx] = val))?};
     }
 }
 impl_script_newtype! {
     #[languages(on_feature(lua))]
-    ///A 4-dimensional vector with SIMD support.
+    ///A 4-dimensional vector.
     ///
-    ///This type uses 16 byte aligned SIMD vector type for storage.
+    ///SIMD vector types are used for storage on supported platforms.
+    ///
+    ///This type is 16 byte aligned.
     glam::f32::Vec4 :
     Clone +
     Debug +
@@ -4287,9 +4524,9 @@ impl_script_newtype! {
 
         ///Creates a 2D vector from the `x`, `y` and `z` elements of `self`, discarding `w`.
         ///
-        ///Truncation to `Vec3` may also be performed by using `self.xyz()` or `Vec3::from()`.
+        ///Truncation to [`Vec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()].
         ///
-        ///To truncate to `Vec3A` use `Vec3A::from()`.
+        ///To truncate to [`Vec3A`] use [`Vec3A::from()`].
         truncate(self:) -> Wrapped(Vec3),
 
         ///Computes the dot product of `self` and `rhs`.
@@ -4423,7 +4660,7 @@ impl_script_newtype! {
         ///
         ///For valid results, `self` must _not_ be of length zero, nor very close to zero.
         ///
-        ///See also [`Self::try_normalize`] and [`Self::normalize_or_zero`].
+        ///See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].
         ///
         ///Panics
         ///
@@ -4435,7 +4672,7 @@ impl_script_newtype! {
         ///In particular, if the input is zero (or very close to zero), or non-finite,
         ///the result of this operation will be zero.
         ///
-        ///See also [`Self::try_normalize`].
+        ///See also [`Self::try_normalize()`].
         normalize_or_zero(self:) -> self,
 
         ///Returns whether `self` is length `1.0` or not.
@@ -4497,6 +4734,10 @@ impl_script_newtype! {
         ///each element of `self`.
         ceil(self:) -> self,
 
+        ///Returns a vector containing the integer part each element of `self`. This means numbers are
+        ///always truncated towards zero.
+        trunc(self:) -> self,
+
         ///Returns a vector containing the fractional part of the vector, e.g. `self -
         ///self.floor()`.
         ///
@@ -4568,21 +4809,21 @@ impl_script_newtype! {
     )
     + BinOps
     (
-        self Add self -> Wrapped(Vec4),
         self Add Raw(f32) -> Wrapped(Vec4),
         self Add Wrapped(Vec4) -> Wrapped(Vec4),
-        self Sub self -> Wrapped(Vec4),
+        self Add self -> Wrapped(Vec4),
         self Sub Raw(f32) -> Wrapped(Vec4),
+        self Sub self -> Wrapped(Vec4),
         self Sub Wrapped(Vec4) -> Wrapped(Vec4),
-        self Div self -> Wrapped(Vec4),
         self Div Raw(f32) -> Wrapped(Vec4),
+        self Div self -> Wrapped(Vec4),
         self Div Wrapped(Vec4) -> Wrapped(Vec4),
-        self Mul self -> Wrapped(Vec4),
         self Mul Raw(f32) -> Wrapped(Vec4),
+        self Mul self -> Wrapped(Vec4),
         self Mul Wrapped(Vec4) -> Wrapped(Vec4),
         self Rem self -> Wrapped(Vec4),
-        self Rem Raw(f32) -> Wrapped(Vec4),
         self Rem Wrapped(Vec4) -> Wrapped(Vec4),
+        self Rem Raw(f32) -> Wrapped(Vec4),
     )
     + UnaryOps
     (
@@ -4590,8 +4831,8 @@ impl_script_newtype! {
     )
     lua impl
     {
-        (MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])};
-        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,f32)| {s.val_mut(|s| Ok(s[idx] = val))?};
+        (MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])};
+        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,f32)| {s.val_mut(|s| Ok(s[*idx] = val))?};
     }
 }
 impl_script_newtype! {
@@ -4620,6 +4861,16 @@ impl_script_newtype! {
         ///Returns true if all the elements are true, false otherwise.
         all(self:) -> Raw(bool),
 
+        ///Tests the value at `index`.
+        ///
+        ///Panics if `index` is greater than 1.
+        test(&self:Raw(usize)) -> Raw(bool),
+
+        ///Sets the element at `index`.
+        ///
+        ///Panics if `index` is greater than 1.
+        set(&mut self:Raw(usize),Raw(bool)),
+
     )
     + Fields
     (
@@ -4662,6 +4913,16 @@ impl_script_newtype! {
         ///Returns true if all the elements are true, false otherwise.
         all(self:) -> Raw(bool),
 
+        ///Tests the value at `index`.
+        ///
+        ///Panics if `index` is greater than 2.
+        test(&self:Raw(usize)) -> Raw(bool),
+
+        ///Sets the element at `index`.
+        ///
+        ///Panics if `index` is greater than 2.
+        set(&mut self:Raw(usize),Raw(bool)),
+
     )
     + Fields
     (
@@ -4705,6 +4966,16 @@ impl_script_newtype! {
         ///Returns true if all the elements are true, false otherwise.
         all(self:) -> Raw(bool),
 
+        ///Tests the value at `index`.
+        ///
+        ///Panics if `index` is greater than 3.
+        test(&self:Raw(usize)) -> Raw(bool),
+
+        ///Sets the element at `index`.
+        ///
+        ///Panics if `index` is greater than 3.
+        set(&mut self:Raw(usize),Raw(bool)),
+
     )
     + Fields
     (
@@ -4727,8 +4998,7 @@ impl_script_newtype! {
     #[languages(on_feature(lua))]
     ///A 3-dimensional SIMD vector mask.
     ///
-    ///This type is 16 byte aligned and is backed by a SIMD vector. If SIMD is not available
-    ///`BVec3A` will be a type alias for `BVec3`.
+    ///This type is 16 byte aligned.
     glam::bool::BVec3A :
     Clone +
     Debug +
@@ -4752,6 +5022,16 @@ impl_script_newtype! {
         ///Returns true if all the elements are true, false otherwise.
         all(self:) -> Raw(bool),
 
+        ///Tests the value at `index`.
+        ///
+        ///Panics if `index` is greater than 2.
+        test(&self:Raw(usize)) -> Raw(bool),
+
+        ///Sets the element at `index`.
+        ///
+        ///Panics if `index` is greater than 2.
+        set(&mut self:Raw(usize),Raw(bool)),
+
     )
     + Fields
     (
@@ -4770,8 +5050,7 @@ impl_script_newtype! {
     #[languages(on_feature(lua))]
     ///A 4-dimensional SIMD vector mask.
     ///
-    ///This type is 16 byte aligned and is backed by a SIMD vector. If SIMD is not available
-    ///`BVec4A` will be a type alias for `BVec4`.
+    ///This type is 16 byte aligned.
     glam::bool::BVec4A :
     Clone +
     Debug +
@@ -4795,6 +5074,16 @@ impl_script_newtype! {
         ///Returns true if all the elements are true, false otherwise.
         all(self:) -> Raw(bool),
 
+        ///Tests the value at `index`.
+        ///
+        ///Panics if `index` is greater than 3.
+        test(&self:Raw(usize)) -> Raw(bool),
+
+        ///Sets the element at `index`.
+        ///
+        ///Panics if `index` is greater than 3.
+        set(&mut self:Raw(usize),Raw(bool)),
+
     )
     + Fields
     (
@@ -4964,7 +5253,7 @@ impl_script_newtype! {
         ///
         ///For valid results, `self` must _not_ be of length zero, nor very close to zero.
         ///
-        ///See also [`Self::try_normalize`] and [`Self::normalize_or_zero`].
+        ///See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].
         ///
         ///Panics
         ///
@@ -4976,7 +5265,7 @@ impl_script_newtype! {
         ///In particular, if the input is zero (or very close to zero), or non-finite,
         ///the result of this operation will be zero.
         ///
-        ///See also [`Self::try_normalize`].
+        ///See also [`Self::try_normalize()`].
         normalize_or_zero(self:) -> self,
 
         ///Returns whether `self` is length `1.0` or not.
@@ -5038,6 +5327,10 @@ impl_script_newtype! {
         ///each element of `self`.
         ceil(self:) -> self,
 
+        ///Returns a vector containing the integer part each element of `self`. This means numbers are
+        ///always truncated towards zero.
+        trunc(self:) -> self,
+
         ///Returns a vector containing the fractional part of the vector, e.g. `self -
         ///self.floor()`.
         ///
@@ -5095,13 +5388,14 @@ impl_script_newtype! {
         mul_add(self:self,self) -> self,
 
         ///Creates a 2D vector containing `[angle.cos(), angle.sin()]`. This can be used in
-        ///conjunction with the `rotate` method, e.g. `Vec2::from_angle(PI).rotate(Vec2::Y)` will
-        ///create the vector [-1, 0] and rotate `Vec2::Y` around it returning `-Vec2::Y`.
+        ///conjunction with the [`rotate()`][Self::rotate()] method, e.g.
+        ///`DVec2::from_angle(PI).rotate(DVec2::Y)` will create the vector `[-1, 0]`
+        ///and rotate [`DVec2::Y`] around it returning `-DVec2::Y`.
         from_angle(Raw(f64)) -> self,
 
-        ///Returns the angle (in radians) between `self` and `rhs`.
+        ///Returns the angle (in radians) between `self` and `rhs` in the range `[-π, +π]`.
         ///
-        ///The input vectors do not need to be unit length however they must be non-zero.
+        ///The inputs do not need to be unit vectors however they must be non-zero.
         angle_between(self:self) -> Raw(f64),
 
         ///Returns a vector that is equal to `self` rotated by 90 degrees.
@@ -5136,15 +5430,15 @@ impl_script_newtype! {
         self Add self -> Wrapped(DVec2),
         self Add Raw(f64) -> Wrapped(DVec2),
         self Add Wrapped(DVec2) -> Wrapped(DVec2),
-        self Sub self -> Wrapped(DVec2),
         self Sub Raw(f64) -> Wrapped(DVec2),
         self Sub Wrapped(DVec2) -> Wrapped(DVec2),
+        self Sub self -> Wrapped(DVec2),
         self Div self -> Wrapped(DVec2),
-        self Div Raw(f64) -> Wrapped(DVec2),
         self Div Wrapped(DVec2) -> Wrapped(DVec2),
+        self Div Raw(f64) -> Wrapped(DVec2),
+        self Mul Wrapped(DVec2) -> Wrapped(DVec2),
         self Mul self -> Wrapped(DVec2),
         self Mul Raw(f64) -> Wrapped(DVec2),
-        self Mul Wrapped(DVec2) -> Wrapped(DVec2),
         self Rem self -> Wrapped(DVec2),
         self Rem Raw(f64) -> Wrapped(DVec2),
         self Rem Wrapped(DVec2) -> Wrapped(DVec2),
@@ -5155,8 +5449,8 @@ impl_script_newtype! {
     )
     lua impl
     {
-        (MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])};
-        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,f64)| {s.val_mut(|s| Ok(s[idx] = val))?};
+        (MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])};
+        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,f64)| {s.val_mut(|s| Ok(s[*idx] = val))?};
     }
 }
 impl_script_newtype! {
@@ -5185,7 +5479,7 @@ impl_script_newtype! {
 
         ///Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`.
         ///
-        ///Truncation may also be performed by using `self.xy()` or `DVec2::from()`.
+        ///Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()].
         truncate(self:) -> Wrapped(DVec2),
 
         ///Computes the dot product of `self` and `rhs`.
@@ -5322,7 +5616,7 @@ impl_script_newtype! {
         ///
         ///For valid results, `self` must _not_ be of length zero, nor very close to zero.
         ///
-        ///See also [`Self::try_normalize`] and [`Self::normalize_or_zero`].
+        ///See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].
         ///
         ///Panics
         ///
@@ -5334,7 +5628,7 @@ impl_script_newtype! {
         ///In particular, if the input is zero (or very close to zero), or non-finite,
         ///the result of this operation will be zero.
         ///
-        ///See also [`Self::try_normalize`].
+        ///See also [`Self::try_normalize()`].
         normalize_or_zero(self:) -> self,
 
         ///Returns whether `self` is length `1.0` or not.
@@ -5396,6 +5690,10 @@ impl_script_newtype! {
         ///each element of `self`.
         ceil(self:) -> self,
 
+        ///Returns a vector containing the integer part each element of `self`. This means numbers are
+        ///always truncated towards zero.
+        trunc(self:) -> self,
+
         ///Returns a vector containing the fractional part of the vector, e.g. `self -
         ///self.floor()`.
         ///
@@ -5454,19 +5752,20 @@ impl_script_newtype! {
 
         ///Returns the angle (in radians) between two vectors.
         ///
-        ///The input vectors do not need to be unit length however they must be non-zero.
+        ///The inputs do not need to be unit vectors however they must be non-zero.
         angle_between(self:self) -> Raw(f64),
 
         ///Returns some vector that is orthogonal to the given one.
         ///
         ///The input vector must be finite and non-zero.
         ///
-        ///The output vector is not necessarily unit-length.
-        ///For that use [`Self::any_orthonormal_vector`] instead.
+        ///The output vector is not necessarily unit length. For that use
+        ///[`Self::any_orthonormal_vector()`] instead.
         any_orthogonal_vector(&self:) -> self,
 
-        ///Returns any unit-length vector that is orthogonal to the given one.
-        ///The input vector must be finite and non-zero.
+        ///Returns any unit vector that is orthogonal to the given one.
+        ///
+        ///The input vector must be unit length.
         ///
         ///# Panics
         ///
@@ -5494,20 +5793,20 @@ impl_script_newtype! {
     )
     + BinOps
     (
-        self Add self -> Wrapped(DVec3),
         self Add Raw(f64) -> Wrapped(DVec3),
         self Add Wrapped(DVec3) -> Wrapped(DVec3),
+        self Add self -> Wrapped(DVec3),
+        self Sub Wrapped(DVec3) -> Wrapped(DVec3),
         self Sub self -> Wrapped(DVec3),
         self Sub Raw(f64) -> Wrapped(DVec3),
-        self Sub Wrapped(DVec3) -> Wrapped(DVec3),
-        self Div self -> Wrapped(DVec3),
         self Div Raw(f64) -> Wrapped(DVec3),
         self Div Wrapped(DVec3) -> Wrapped(DVec3),
-        self Mul self -> Wrapped(DVec3),
+        self Div self -> Wrapped(DVec3),
         self Mul Raw(f64) -> Wrapped(DVec3),
+        self Mul self -> Wrapped(DVec3),
         self Mul Wrapped(DVec3) -> Wrapped(DVec3),
-        self Rem self -> Wrapped(DVec3),
         self Rem Raw(f64) -> Wrapped(DVec3),
+        self Rem self -> Wrapped(DVec3),
         self Rem Wrapped(DVec3) -> Wrapped(DVec3),
     )
     + UnaryOps
@@ -5516,8 +5815,8 @@ impl_script_newtype! {
     )
     lua impl
     {
-        (MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])};
-        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,f64)| {s.val_mut(|s| Ok(s[idx] = val))?};
+        (MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])};
+        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,f64)| {s.val_mut(|s| Ok(s[*idx] = val))?};
     }
 }
 impl_script_newtype! {
@@ -5543,7 +5842,7 @@ impl_script_newtype! {
 
         ///Creates a 2D vector from the `x`, `y` and `z` elements of `self`, discarding `w`.
         ///
-        ///Truncation to `DVec3` may also be performed by using `self.xyz()` or `DVec3::from()`.
+        ///Truncation to [`DVec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()].
         truncate(self:) -> Wrapped(DVec3),
 
         ///Computes the dot product of `self` and `rhs`.
@@ -5677,7 +5976,7 @@ impl_script_newtype! {
         ///
         ///For valid results, `self` must _not_ be of length zero, nor very close to zero.
         ///
-        ///See also [`Self::try_normalize`] and [`Self::normalize_or_zero`].
+        ///See also [`Self::try_normalize()`] and [`Self::normalize_or_zero()`].
         ///
         ///Panics
         ///
@@ -5689,7 +5988,7 @@ impl_script_newtype! {
         ///In particular, if the input is zero (or very close to zero), or non-finite,
         ///the result of this operation will be zero.
         ///
-        ///See also [`Self::try_normalize`].
+        ///See also [`Self::try_normalize()`].
         normalize_or_zero(self:) -> self,
 
         ///Returns whether `self` is length `1.0` or not.
@@ -5751,6 +6050,10 @@ impl_script_newtype! {
         ///each element of `self`.
         ceil(self:) -> self,
 
+        ///Returns a vector containing the integer part each element of `self`. This means numbers are
+        ///always truncated towards zero.
+        trunc(self:) -> self,
+
         ///Returns a vector containing the fractional part of the vector, e.g. `self -
         ///self.floor()`.
         ///
@@ -5826,20 +6129,20 @@ impl_script_newtype! {
     )
     + BinOps
     (
-        self Add self -> Wrapped(DVec4),
         self Add Raw(f64) -> Wrapped(DVec4),
+        self Add self -> Wrapped(DVec4),
         self Add Wrapped(DVec4) -> Wrapped(DVec4),
-        self Sub self -> Wrapped(DVec4),
         self Sub Raw(f64) -> Wrapped(DVec4),
         self Sub Wrapped(DVec4) -> Wrapped(DVec4),
+        self Sub self -> Wrapped(DVec4),
+        self Div Wrapped(DVec4) -> Wrapped(DVec4),
         self Div self -> Wrapped(DVec4),
         self Div Raw(f64) -> Wrapped(DVec4),
-        self Div Wrapped(DVec4) -> Wrapped(DVec4),
-        self Mul self -> Wrapped(DVec4),
-        self Mul Raw(f64) -> Wrapped(DVec4),
         self Mul Wrapped(DVec4) -> Wrapped(DVec4),
-        self Rem self -> Wrapped(DVec4),
+        self Mul Raw(f64) -> Wrapped(DVec4),
+        self Mul self -> Wrapped(DVec4),
         self Rem Raw(f64) -> Wrapped(DVec4),
+        self Rem self -> Wrapped(DVec4),
         self Rem Wrapped(DVec4) -> Wrapped(DVec4),
     )
     + UnaryOps
@@ -5848,8 +6151,8 @@ impl_script_newtype! {
     )
     lua impl
     {
-        (MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])};
-        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,f64)| {s.val_mut(|s| Ok(s[idx] = val))?};
+        (MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])};
+        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,f64)| {s.val_mut(|s| Ok(s[*idx] = val))?};
     }
 }
 impl_script_newtype! {
@@ -5963,15 +6266,18 @@ impl_script_newtype! {
         /// - `-1` if the number is negative
         signum(self:) -> self,
 
-        ///Returns a vector with signs of `rhs` and the magnitudes of `self`.
-        copysign(self:self) -> self,
-
         ///Returns a bitmask with the lowest 2 bits set to the sign bits from the elements of `self`.
         ///
         ///A negative element results in a `1` bit and a positive element in a `0` bit.  Element `x` goes
         ///into the first lowest bit, element `y` into the second, etc.
         is_negative_bitmask(self:) -> Raw(u32),
 
+        ///Computes the squared length of `self`.
+        length_squared(self:) -> Raw(i32),
+
+        ///Compute the squared euclidean distance between two points in space.
+        distance_squared(self:self) -> Raw(i32),
+
         ///Returns a vector that is equal to `self` rotated by 90 degrees.
         perp(self:) -> self,
 
@@ -6002,17 +6308,17 @@ impl_script_newtype! {
     + BinOps
     (
         self Add self -> Wrapped(IVec2),
-        self Add Raw(i32) -> Wrapped(IVec2),
         self Add Wrapped(IVec2) -> Wrapped(IVec2),
-        self Sub self -> Wrapped(IVec2),
-        self Sub Raw(i32) -> Wrapped(IVec2),
+        self Add Raw(i32) -> Wrapped(IVec2),
         self Sub Wrapped(IVec2) -> Wrapped(IVec2),
-        self Div self -> Wrapped(IVec2),
+        self Sub Raw(i32) -> Wrapped(IVec2),
+        self Sub self -> Wrapped(IVec2),
         self Div Raw(i32) -> Wrapped(IVec2),
         self Div Wrapped(IVec2) -> Wrapped(IVec2),
+        self Div self -> Wrapped(IVec2),
         self Mul self -> Wrapped(IVec2),
-        self Mul Raw(i32) -> Wrapped(IVec2),
         self Mul Wrapped(IVec2) -> Wrapped(IVec2),
+        self Mul Raw(i32) -> Wrapped(IVec2),
         self Rem self -> Wrapped(IVec2),
         self Rem Raw(i32) -> Wrapped(IVec2),
         self Rem Wrapped(IVec2) -> Wrapped(IVec2),
@@ -6023,8 +6329,8 @@ impl_script_newtype! {
     )
     lua impl
     {
-        (MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])};
-        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,i32)| {s.val_mut(|s| Ok(s[idx] = val))?};
+        (MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])};
+        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,i32)| {s.val_mut(|s| Ok(s[*idx] = val))?};
     }
 }
 impl_script_newtype! {
@@ -6053,7 +6359,7 @@ impl_script_newtype! {
 
         ///Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`.
         ///
-        ///Truncation may also be performed by using `self.xy()` or `IVec2::from()`.
+        ///Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()].
         truncate(self:) -> Wrapped(IVec2),
 
         ///Computes the dot product of `self` and `rhs`.
@@ -6146,15 +6452,18 @@ impl_script_newtype! {
         /// - `-1` if the number is negative
         signum(self:) -> self,
 
-        ///Returns a vector with signs of `rhs` and the magnitudes of `self`.
-        copysign(self:self) -> self,
-
         ///Returns a bitmask with the lowest 3 bits set to the sign bits from the elements of `self`.
         ///
         ///A negative element results in a `1` bit and a positive element in a `0` bit.  Element `x` goes
         ///into the first lowest bit, element `y` into the second, etc.
         is_negative_bitmask(self:) -> Raw(u32),
 
+        ///Computes the squared length of `self`.
+        length_squared(self:) -> Raw(i32),
+
+        ///Compute the squared euclidean distance between two points in space.
+        distance_squared(self:self) -> Raw(i32),
+
         ///Casts all elements of `self` to `f32`.
         as_vec3(&self:) -> Wrapped(Vec3),
 
@@ -6176,21 +6485,21 @@ impl_script_newtype! {
     )
     + BinOps
     (
-        self Add self -> Wrapped(IVec3),
         self Add Raw(i32) -> Wrapped(IVec3),
         self Add Wrapped(IVec3) -> Wrapped(IVec3),
-        self Sub self -> Wrapped(IVec3),
+        self Add self -> Wrapped(IVec3),
         self Sub Raw(i32) -> Wrapped(IVec3),
+        self Sub self -> Wrapped(IVec3),
         self Sub Wrapped(IVec3) -> Wrapped(IVec3),
-        self Div self -> Wrapped(IVec3),
         self Div Raw(i32) -> Wrapped(IVec3),
+        self Div self -> Wrapped(IVec3),
         self Div Wrapped(IVec3) -> Wrapped(IVec3),
+        self Mul Wrapped(IVec3) -> Wrapped(IVec3),
         self Mul self -> Wrapped(IVec3),
         self Mul Raw(i32) -> Wrapped(IVec3),
-        self Mul Wrapped(IVec3) -> Wrapped(IVec3),
-        self Rem self -> Wrapped(IVec3),
         self Rem Raw(i32) -> Wrapped(IVec3),
         self Rem Wrapped(IVec3) -> Wrapped(IVec3),
+        self Rem self -> Wrapped(IVec3),
     )
     + UnaryOps
     (
@@ -6198,8 +6507,8 @@ impl_script_newtype! {
     )
     lua impl
     {
-        (MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])};
-        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,i32)| {s.val_mut(|s| Ok(s[idx] = val))?};
+        (MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])};
+        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,i32)| {s.val_mut(|s| Ok(s[*idx] = val))?};
     }
 }
 impl_script_newtype! {
@@ -6225,7 +6534,7 @@ impl_script_newtype! {
 
         ///Creates a 2D vector from the `x`, `y` and `z` elements of `self`, discarding `w`.
         ///
-        ///Truncation to `IVec3` may also be performed by using `self.xyz()` or `IVec3::from()`.
+        ///Truncation to [`IVec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()].
         truncate(self:) -> Wrapped(IVec3),
 
         ///Computes the dot product of `self` and `rhs`.
@@ -6315,15 +6624,18 @@ impl_script_newtype! {
         /// - `-1` if the number is negative
         signum(self:) -> self,
 
-        ///Returns a vector with signs of `rhs` and the magnitudes of `self`.
-        copysign(self:self) -> self,
-
         ///Returns a bitmask with the lowest 4 bits set to the sign bits from the elements of `self`.
         ///
         ///A negative element results in a `1` bit and a positive element in a `0` bit.  Element `x` goes
         ///into the first lowest bit, element `y` into the second, etc.
         is_negative_bitmask(self:) -> Raw(u32),
 
+        ///Computes the squared length of `self`.
+        length_squared(self:) -> Raw(i32),
+
+        ///Compute the squared euclidean distance between two points in space.
+        distance_squared(self:self) -> Raw(i32),
+
         ///Casts all elements of `self` to `f32`.
         as_vec4(&self:) -> Wrapped(Vec4),
 
@@ -6343,21 +6655,21 @@ impl_script_newtype! {
     )
     + BinOps
     (
+        self Add Wrapped(IVec4) -> Wrapped(IVec4),
         self Add self -> Wrapped(IVec4),
         self Add Raw(i32) -> Wrapped(IVec4),
-        self Add Wrapped(IVec4) -> Wrapped(IVec4),
         self Sub self -> Wrapped(IVec4),
-        self Sub Raw(i32) -> Wrapped(IVec4),
         self Sub Wrapped(IVec4) -> Wrapped(IVec4),
+        self Sub Raw(i32) -> Wrapped(IVec4),
         self Div self -> Wrapped(IVec4),
-        self Div Raw(i32) -> Wrapped(IVec4),
         self Div Wrapped(IVec4) -> Wrapped(IVec4),
+        self Div Raw(i32) -> Wrapped(IVec4),
         self Mul self -> Wrapped(IVec4),
-        self Mul Raw(i32) -> Wrapped(IVec4),
         self Mul Wrapped(IVec4) -> Wrapped(IVec4),
-        self Rem self -> Wrapped(IVec4),
+        self Mul Raw(i32) -> Wrapped(IVec4),
         self Rem Raw(i32) -> Wrapped(IVec4),
         self Rem Wrapped(IVec4) -> Wrapped(IVec4),
+        self Rem self -> Wrapped(IVec4),
     )
     + UnaryOps
     (
@@ -6365,8 +6677,8 @@ impl_script_newtype! {
     )
     lua impl
     {
-        (MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])};
-        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,i32)| {s.val_mut(|s| Ok(s[idx] = val))?};
+        (MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])};
+        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,i32)| {s.val_mut(|s| Ok(s[*idx] = val))?};
     }
 }
 impl_script_newtype! {
@@ -6470,6 +6782,9 @@ impl_script_newtype! {
         ///elements.
         cmplt(self:self) -> Wrapped(BVec2),
 
+        ///Computes the squared length of `self`.
+        length_squared(self:) -> Raw(u32),
+
         ///Casts all elements of `self` to `f32`.
         as_vec2(&self:) -> Wrapped(Vec2),
 
@@ -6487,18 +6802,18 @@ impl_script_newtype! {
     )
     + BinOps
     (
-        self Add self -> Wrapped(UVec2),
         self Add Raw(u32) -> Wrapped(UVec2),
         self Add Wrapped(UVec2) -> Wrapped(UVec2),
+        self Add self -> Wrapped(UVec2),
         self Sub self -> Wrapped(UVec2),
-        self Sub Raw(u32) -> Wrapped(UVec2),
         self Sub Wrapped(UVec2) -> Wrapped(UVec2),
+        self Sub Raw(u32) -> Wrapped(UVec2),
         self Div self -> Wrapped(UVec2),
         self Div Raw(u32) -> Wrapped(UVec2),
         self Div Wrapped(UVec2) -> Wrapped(UVec2),
-        self Mul self -> Wrapped(UVec2),
-        self Mul Raw(u32) -> Wrapped(UVec2),
         self Mul Wrapped(UVec2) -> Wrapped(UVec2),
+        self Mul Raw(u32) -> Wrapped(UVec2),
+        self Mul self -> Wrapped(UVec2),
         self Rem self -> Wrapped(UVec2),
         self Rem Raw(u32) -> Wrapped(UVec2),
         self Rem Wrapped(UVec2) -> Wrapped(UVec2),
@@ -6508,8 +6823,8 @@ impl_script_newtype! {
     )
     lua impl
     {
-        (MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])};
-        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,u32)| {s.val_mut(|s| Ok(s[idx] = val))?};
+        (MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])};
+        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,u32)| {s.val_mut(|s| Ok(s[*idx] = val))?};
     }
 }
 impl_script_newtype! {
@@ -6538,7 +6853,7 @@ impl_script_newtype! {
 
         ///Creates a 2D vector from the `x` and `y` elements of `self`, discarding `z`.
         ///
-        ///Truncation may also be performed by using `self.xy()` or `UVec2::from()`.
+        ///Truncation may also be performed by using [`self.xy()`][crate::swizzles::Vec3Swizzles::xy()].
         truncate(self:) -> Wrapped(UVec2),
 
         ///Computes the dot product of `self` and `rhs`.
@@ -6621,6 +6936,9 @@ impl_script_newtype! {
         ///elements.
         cmplt(self:self) -> Wrapped(BVec3),
 
+        ///Computes the squared length of `self`.
+        length_squared(self:) -> Raw(u32),
+
         ///Casts all elements of `self` to `f32`.
         as_vec3(&self:) -> Wrapped(Vec3),
 
@@ -6642,20 +6960,20 @@ impl_script_newtype! {
     )
     + BinOps
     (
-        self Add self -> Wrapped(UVec3),
-        self Add Raw(u32) -> Wrapped(UVec3),
         self Add Wrapped(UVec3) -> Wrapped(UVec3),
-        self Sub self -> Wrapped(UVec3),
-        self Sub Raw(u32) -> Wrapped(UVec3),
+        self Add Raw(u32) -> Wrapped(UVec3),
+        self Add self -> Wrapped(UVec3),
         self Sub Wrapped(UVec3) -> Wrapped(UVec3),
+        self Sub Raw(u32) -> Wrapped(UVec3),
+        self Sub self -> Wrapped(UVec3),
         self Div self -> Wrapped(UVec3),
         self Div Raw(u32) -> Wrapped(UVec3),
         self Div Wrapped(UVec3) -> Wrapped(UVec3),
-        self Mul self -> Wrapped(UVec3),
-        self Mul Raw(u32) -> Wrapped(UVec3),
         self Mul Wrapped(UVec3) -> Wrapped(UVec3),
-        self Rem self -> Wrapped(UVec3),
+        self Mul Raw(u32) -> Wrapped(UVec3),
+        self Mul self -> Wrapped(UVec3),
         self Rem Raw(u32) -> Wrapped(UVec3),
+        self Rem self -> Wrapped(UVec3),
         self Rem Wrapped(UVec3) -> Wrapped(UVec3),
     )
     + UnaryOps
@@ -6663,8 +6981,8 @@ impl_script_newtype! {
     )
     lua impl
     {
-        (MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])};
-        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,u32)| {s.val_mut(|s| Ok(s[idx] = val))?};
+        (MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])};
+        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,u32)| {s.val_mut(|s| Ok(s[*idx] = val))?};
     }
 }
 impl_script_newtype! {
@@ -6690,7 +7008,7 @@ impl_script_newtype! {
 
         ///Creates a 2D vector from the `x`, `y` and `z` elements of `self`, discarding `w`.
         ///
-        ///Truncation to `UVec3` may also be performed by using `self.xyz()` or `UVec3::from()`.
+        ///Truncation to [`UVec3`] may also be performed by using [`self.xyz()`][crate::swizzles::Vec4Swizzles::xyz()].
         truncate(self:) -> Wrapped(UVec3),
 
         ///Computes the dot product of `self` and `rhs`.
@@ -6770,6 +7088,9 @@ impl_script_newtype! {
         ///elements.
         cmplt(self:self) -> Wrapped(BVec4),
 
+        ///Computes the squared length of `self`.
+        length_squared(self:) -> Raw(u32),
+
         ///Casts all elements of `self` to `f32`.
         as_vec4(&self:) -> Wrapped(Vec4),
 
@@ -6790,17 +7111,17 @@ impl_script_newtype! {
     + BinOps
     (
         self Add self -> Wrapped(UVec4),
-        self Add Raw(u32) -> Wrapped(UVec4),
         self Add Wrapped(UVec4) -> Wrapped(UVec4),
+        self Add Raw(u32) -> Wrapped(UVec4),
         self Sub self -> Wrapped(UVec4),
-        self Sub Raw(u32) -> Wrapped(UVec4),
         self Sub Wrapped(UVec4) -> Wrapped(UVec4),
+        self Sub Raw(u32) -> Wrapped(UVec4),
         self Div self -> Wrapped(UVec4),
         self Div Raw(u32) -> Wrapped(UVec4),
         self Div Wrapped(UVec4) -> Wrapped(UVec4),
+        self Mul Wrapped(UVec4) -> Wrapped(UVec4),
         self Mul self -> Wrapped(UVec4),
         self Mul Raw(u32) -> Wrapped(UVec4),
-        self Mul Wrapped(UVec4) -> Wrapped(UVec4),
         self Rem self -> Wrapped(UVec4),
         self Rem Raw(u32) -> Wrapped(UVec4),
         self Rem Wrapped(UVec4) -> Wrapped(UVec4),
@@ -6810,8 +7131,8 @@ impl_script_newtype! {
     )
     lua impl
     {
-        (MetaMethod::Index) => |_,s,idx: usize| {Ok(s.inner()?[idx])};
-        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (usize,u32)| {s.val_mut(|s| Ok(s[idx] = val))?};
+        (MetaMethod::Index) => |_,s,idx: LuaIndex| {Ok(s.inner()?[*idx])};
+        mut (MetaMethod::NewIndex) => |_,s,(idx,val): (LuaIndex,u32)| {s.val_mut(|s| Ok(s[*idx] = val))?};
     }
 }
 impl_script_newtype! {
@@ -6845,7 +7166,7 @@ impl_script_newtype! {
     Debug +
     Methods
     (
-        ///Creates a 3x3 matrix from two column vectors.
+        ///Creates a 3x3 matrix from three column vectors.
         from_cols(Wrapped(Vec3),Wrapped(Vec3),Wrapped(Vec3)) -> self,
 
         ///Creates a 3x3 matrix with its diagonal set to `diagonal` and all other entries set to 0.
@@ -6979,7 +7300,7 @@ impl_script_newtype! {
         ///Transforms a 3D vector.
         mul_vec3(&self:Wrapped(Vec3)) -> Wrapped(Vec3),
 
-        ///Transforms a `Vec3A`.
+        ///Transforms a [`Vec3A`].
         mul_vec3a(&self:Wrapped(Vec3A)) -> Wrapped(Vec3A),
 
         ///Multiplies two 3x3 matrices.
@@ -7018,11 +7339,11 @@ impl_script_newtype! {
     (
         self Add self -> Wrapped(Mat3),
         self Sub self -> Wrapped(Mat3),
+        self Mul Wrapped(Mat3) -> Wrapped(Mat3),
         self Mul Wrapped(Affine2) -> Wrapped(Mat3),
+        self Mul Raw(f32) -> Wrapped(Mat3),
         self Mul self -> Wrapped(Mat3),
         self Mul Wrapped(Vec3) -> Wrapped(Vec3),
-        self Mul Wrapped(Mat3) -> Wrapped(Mat3),
-        self Mul Raw(f32) -> Wrapped(Mat3),
         self Mul Wrapped(Vec3A) -> Wrapped(Vec3A),
     )
     + UnaryOps
@@ -7032,11 +7353,11 @@ impl_script_newtype! {
     lua impl
     {
 
-    mut (MetaMethod::Index) => |ctx,s,idx : usize| {
+    mut (MetaMethod::Index) => |ctx,s,idx : LuaIndex| {
         Ok(LuaVec3::new_ref(
                 s.script_ref(ctx.get_world()?).sub_ref(ReflectPathElem::SubReflectionIndexed{
                     label:"col",
-                    index: idx,
+                    index: *idx,
                     get: |idx,ref_| Err(ReflectionError::InsufficientProvenance{
                         path: "".to_owned(),
                         msg: "Cannot get column of matrix with immutable reference".to_owned()
@@ -7060,6 +7381,10 @@ impl_script_newtype! {
 impl_script_newtype! {
     #[languages(on_feature(lua))]
     ///A 2x2 column major matrix.
+    ///
+    ///SIMD vector types are used for storage on supported platforms.
+    ///
+    ///This type is 16 byte aligned.
     glam::f32::Mat2 :
     Clone +
     Debug +
@@ -7156,10 +7481,10 @@ impl_script_newtype! {
     (
         self Add self -> Wrapped(Mat2),
         self Sub self -> Wrapped(Mat2),
-        self Mul self -> Wrapped(Mat2),
         self Mul Wrapped(Vec2) -> Wrapped(Vec2),
         self Mul Wrapped(Mat2) -> Wrapped(Mat2),
         self Mul Raw(f32) -> Wrapped(Mat2),
+        self Mul self -> Wrapped(Mat2),
     )
     + UnaryOps
     (
@@ -7168,11 +7493,11 @@ impl_script_newtype! {
     lua impl
     {
 
-    mut (MetaMethod::Index) => |ctx,s,idx : usize| {
+    mut (MetaMethod::Index) => |ctx,s,idx : LuaIndex| {
         Ok(LuaVec2::new_ref(
                 s.script_ref(ctx.get_world()?).sub_ref(ReflectPathElem::SubReflectionIndexed{
                     label:"col",
-                    index: idx,
+                    index: *idx,
                     get: |idx,ref_| Err(ReflectionError::InsufficientProvenance{
                         path: "".to_owned(),
                         msg: "Cannot get column of matrix with immutable reference".to_owned()
@@ -7224,7 +7549,7 @@ impl_script_newtype! {
     Debug +
     Methods
     (
-        ///Creates a 3x3 matrix from two column vectors.
+        ///Creates a 3x3 matrix from three column vectors.
         from_cols(Wrapped(Vec3A),Wrapped(Vec3A),Wrapped(Vec3A)) -> self,
 
         ///Creates a 3x3 matrix with its diagonal set to `diagonal` and all other entries set to 0.
@@ -7358,7 +7683,7 @@ impl_script_newtype! {
         ///Transforms a 3D vector.
         mul_vec3(&self:Wrapped(Vec3)) -> Wrapped(Vec3),
 
-        ///Transforms a `Vec3A`.
+        ///Transforms a [`Vec3A`].
         mul_vec3a(&self:Wrapped(Vec3A)) -> Wrapped(Vec3A),
 
         ///Multiplies two 3x3 matrices.
@@ -7397,12 +7722,12 @@ impl_script_newtype! {
     (
         self Add self -> Wrapped(Mat3A),
         self Sub self -> Wrapped(Mat3A),
+        self Mul Wrapped(Mat3A) -> Wrapped(Mat3A),
         self Mul Wrapped(Affine2) -> Wrapped(Mat3A),
+        self Mul Wrapped(Vec3) -> Wrapped(Vec3),
+        self Mul Raw(f32) -> Wrapped(Mat3A),
         self Mul self -> Wrapped(Mat3A),
         self Mul Wrapped(Vec3A) -> Wrapped(Vec3A),
-        self Mul Wrapped(Mat3A) -> Wrapped(Mat3A),
-        self Mul Raw(f32) -> Wrapped(Mat3A),
-        self Mul Wrapped(Vec3) -> Wrapped(Vec3),
     )
     + UnaryOps
     (
@@ -7411,11 +7736,11 @@ impl_script_newtype! {
     lua impl
     {
 
-    mut (MetaMethod::Index) => |ctx,s,idx : usize| {
+    mut (MetaMethod::Index) => |ctx,s,idx : LuaIndex| {
         Ok(LuaVec3A::new_ref(
                 s.script_ref(ctx.get_world()?).sub_ref(ReflectPathElem::SubReflectionIndexed{
                     label:"col",
-                    index: idx,
+                    index: *idx,
                     get: |idx,ref_| Err(ReflectionError::InsufficientProvenance{
                         path: "".to_owned(),
                         msg: "Cannot get column of matrix with immutable reference".to_owned()
@@ -7449,7 +7774,7 @@ impl_script_newtype! {
     ///using methods such as [`Self::from_translation()`], [`Self::from_quat()`],
     ///[`Self::from_scale()`] and [`Self::from_scale_rotation_translation()`].
     ///
-    ///Othographic projections can be created using the methods [`Self::orthographic_lh()`] for
+    ///Orthographic projections can be created using the methods [`Self::orthographic_lh()`] for
     ///left-handed coordinate systems and [`Self::orthographic_rh()`] for right-handed
     ///systems. The resulting matrix is also an affine transformation.
     ///
@@ -7472,7 +7797,7 @@ impl_script_newtype! {
     Debug +
     Methods
     (
-        ///Creates a 4x4 matrix from two column vectors.
+        ///Creates a 4x4 matrix from four column vectors.
         from_cols(Wrapped(Vec4),Wrapped(Vec4),Wrapped(Vec4),Wrapped(Vec4)) -> self,
 
         ///Creates a 4x4 matrix with its diagonal set to `diagonal` and all other entries set to 0.
@@ -7733,14 +8058,14 @@ impl_script_newtype! {
         ///Will panic if the 3rd row of `self` is not `(0, 0, 0, 1)` when `glam_assert` is enabled.
         transform_vector3(&self:Wrapped(Vec3)) -> Wrapped(Vec3),
 
-        ///Transforms the given `Vec3A` as 3D point.
+        ///Transforms the given [`Vec3A`] as 3D point.
         ///
-        ///This is the equivalent of multiplying the `Vec3A` as a 4D vector where `w` is `1.0`.
+        ///This is the equivalent of multiplying the [`Vec3A`] as a 4D vector where `w` is `1.0`.
         transform_point3a(&self:Wrapped(Vec3A)) -> Wrapped(Vec3A),
 
-        ///Transforms the give `Vec3A` as 3D vector.
+        ///Transforms the give [`Vec3A`] as 3D vector.
         ///
-        ///This is the equivalent of multiplying the `Vec3A` as a 4D vector where `w` is `0.0`.
+        ///This is the equivalent of multiplying the [`Vec3A`] as a 4D vector where `w` is `0.0`.
         transform_vector3a(&self:Wrapped(Vec3A)) -> Wrapped(Vec3A),
 
         ///Transforms a 4D vector.
@@ -7783,11 +8108,11 @@ impl_script_newtype! {
     (
         self Add self -> Wrapped(Mat4),
         self Sub self -> Wrapped(Mat4),
-        self Mul Wrapped(Affine3A) -> Wrapped(Mat4),
         self Mul self -> Wrapped(Mat4),
-        self Mul Wrapped(Vec4) -> Wrapped(Vec4),
-        self Mul Wrapped(Mat4) -> Wrapped(Mat4),
         self Mul Raw(f32) -> Wrapped(Mat4),
+        self Mul Wrapped(Mat4) -> Wrapped(Mat4),
+        self Mul Wrapped(Affine3A) -> Wrapped(Mat4),
+        self Mul Wrapped(Vec4) -> Wrapped(Vec4),
     )
     + UnaryOps
     (
@@ -7796,11 +8121,11 @@ impl_script_newtype! {
     lua impl
     {
 
-    mut (MetaMethod::Index) => |ctx,s,idx : usize| {
+    mut (MetaMethod::Index) => |ctx,s,idx : LuaIndex| {
         Ok(LuaVec4::new_ref(
                 s.script_ref(ctx.get_world()?).sub_ref(ReflectPathElem::SubReflectionIndexed{
                     label:"col",
-                    index: idx,
+                    index: *idx,
                     get: |idx,ref_| Err(ReflectionError::InsufficientProvenance{
                         path: "".to_owned(),
                         msg: "Cannot get column of matrix with immutable reference".to_owned()
@@ -7919,10 +8244,10 @@ impl_script_newtype! {
     (
         self Add self -> Wrapped(DMat2),
         self Sub self -> Wrapped(DMat2),
-        self Mul self -> Wrapped(DMat2),
+        self Mul Raw(f64) -> Wrapped(DMat2),
         self Mul Wrapped(DVec2) -> Wrapped(DVec2),
+        self Mul self -> Wrapped(DMat2),
         self Mul Wrapped(DMat2) -> Wrapped(DMat2),
-        self Mul Raw(f64) -> Wrapped(DMat2),
     )
     + UnaryOps
     (
@@ -7931,11 +8256,11 @@ impl_script_newtype! {
     lua impl
     {
 
-    mut (MetaMethod::Index) => |ctx,s,idx : usize| {
+    mut (MetaMethod::Index) => |ctx,s,idx : LuaIndex| {
         Ok(LuaDVec2::new_ref(
                 s.script_ref(ctx.get_world()?).sub_ref(ReflectPathElem::SubReflectionIndexed{
                     label:"col",
-                    index: idx,
+                    index: *idx,
                     get: |idx,ref_| Err(ReflectionError::InsufficientProvenance{
                         path: "".to_owned(),
                         msg: "Cannot get column of matrix with immutable reference".to_owned()
@@ -7987,7 +8312,7 @@ impl_script_newtype! {
     Debug +
     Methods
     (
-        ///Creates a 3x3 matrix from two column vectors.
+        ///Creates a 3x3 matrix from three column vectors.
         from_cols(Wrapped(DVec3),Wrapped(DVec3),Wrapped(DVec3)) -> self,
 
         ///Creates a 3x3 matrix with its diagonal set to `diagonal` and all other entries set to 0.
@@ -8157,11 +8482,11 @@ impl_script_newtype! {
     (
         self Add self -> Wrapped(DMat3),
         self Sub self -> Wrapped(DMat3),
-        self Mul Wrapped(DAffine2) -> Wrapped(DMat3),
         self Mul self -> Wrapped(DMat3),
         self Mul Wrapped(DVec3) -> Wrapped(DVec3),
         self Mul Wrapped(DMat3) -> Wrapped(DMat3),
         self Mul Raw(f64) -> Wrapped(DMat3),
+        self Mul Wrapped(DAffine2) -> Wrapped(DMat3),
     )
     + UnaryOps
     (
@@ -8170,11 +8495,11 @@ impl_script_newtype! {
     lua impl
     {
 
-    mut (MetaMethod::Index) => |ctx,s,idx : usize| {
+    mut (MetaMethod::Index) => |ctx,s,idx : LuaIndex| {
         Ok(LuaDVec3::new_ref(
                 s.script_ref(ctx.get_world()?).sub_ref(ReflectPathElem::SubReflectionIndexed{
                     label:"col",
-                    index: idx,
+                    index: *idx,
                     get: |idx,ref_| Err(ReflectionError::InsufficientProvenance{
                         path: "".to_owned(),
                         msg: "Cannot get column of matrix with immutable reference".to_owned()
@@ -8208,7 +8533,7 @@ impl_script_newtype! {
     ///using methods such as [`Self::from_translation()`], [`Self::from_quat()`],
     ///[`Self::from_scale()`] and [`Self::from_scale_rotation_translation()`].
     ///
-    ///Othographic projections can be created using the methods [`Self::orthographic_lh()`] for
+    ///Orthographic projections can be created using the methods [`Self::orthographic_lh()`] for
     ///left-handed coordinate systems and [`Self::orthographic_rh()`] for right-handed
     ///systems. The resulting matrix is also an affine transformation.
     ///
@@ -8231,7 +8556,7 @@ impl_script_newtype! {
     Debug +
     Methods
     (
-        ///Creates a 4x4 matrix from two column vectors.
+        ///Creates a 4x4 matrix from four column vectors.
         from_cols(Wrapped(DVec4),Wrapped(DVec4),Wrapped(DVec4),Wrapped(DVec4)) -> self,
 
         ///Creates a 4x4 matrix with its diagonal set to `diagonal` and all other entries set to 0.
@@ -8526,10 +8851,10 @@ impl_script_newtype! {
         self Add self -> Wrapped(DMat4),
         self Sub self -> Wrapped(DMat4),
         self Mul Wrapped(DAffine3) -> Wrapped(DMat4),
+        self Mul Raw(f64) -> Wrapped(DMat4),
         self Mul self -> Wrapped(DMat4),
-        self Mul Wrapped(DVec4) -> Wrapped(DVec4),
         self Mul Wrapped(DMat4) -> Wrapped(DMat4),
-        self Mul Raw(f64) -> Wrapped(DMat4),
+        self Mul Wrapped(DVec4) -> Wrapped(DVec4),
     )
     + UnaryOps
     (
@@ -8538,11 +8863,11 @@ impl_script_newtype! {
     lua impl
     {
 
-    mut (MetaMethod::Index) => |ctx,s,idx : usize| {
+    mut (MetaMethod::Index) => |ctx,s,idx : LuaIndex| {
         Ok(LuaDVec4::new_ref(
                 s.script_ref(ctx.get_world()?).sub_ref(ReflectPathElem::SubReflectionIndexed{
                     label:"col",
-                    index: idx,
+                    index: *idx,
                     get: |idx,ref_| Err(ReflectionError::InsufficientProvenance{
                         path: "".to_owned(),
                         msg: "Cannot get column of matrix with immutable reference".to_owned()
@@ -8610,7 +8935,7 @@ impl_script_newtype! {
         ///The given `Mat3` must be an affine transform,
         from_mat3(Wrapped(Mat3)) -> self,
 
-        ///The given `Mat3A` must be an affine transform,
+        ///The given [`Mat3A`] must be an affine transform,
         from_mat3a(Wrapped(Mat3A)) -> self,
 
         ///Transforms the given 2D point, applying shear, scale, rotation and translation.
@@ -8619,7 +8944,7 @@ impl_script_newtype! {
         ///Transforms the given 2D vector, applying shear, scale and rotation (but NOT
         ///translation).
         ///
-        ///To also apply translation, use [`Self::transform_point2`] instead.
+        ///To also apply translation, use [`Self::transform_point2()`] instead.
         transform_vector2(&self:Wrapped(Vec2)) -> Wrapped(Vec2),
 
         ///Returns `true` if, and only if, all elements are finite.
@@ -8655,9 +8980,9 @@ impl_script_newtype! {
     )
     + BinOps
     (
-        self Mul Wrapped(Affine2) -> Wrapped(Affine2),
-        self Mul Wrapped(Mat3) -> Wrapped(Mat3),
         self Mul Wrapped(Mat3A) -> Wrapped(Mat3A),
+        self Mul Wrapped(Mat3) -> Wrapped(Mat3),
+        self Mul Wrapped(Affine2) -> Wrapped(Affine2),
     )
     + UnaryOps
     (
@@ -8669,6 +8994,8 @@ impl_script_newtype! {
 impl_script_newtype! {
     #[languages(on_feature(lua))]
     ///A 3D affine transform, which can represent translation, rotation, scaling and shear.
+    ///
+    ///This type is 16 byte aligned.
     glam::f32::Affine3A :
     Clone +
     Debug +
@@ -8765,16 +9092,16 @@ impl_script_newtype! {
         ///Transforms the given 3D vector, applying shear, scale and rotation (but NOT
         ///translation).
         ///
-        ///To also apply translation, use [`Self::transform_point3`] instead.
+        ///To also apply translation, use [`Self::transform_point3()`] instead.
         transform_vector3(&self:Wrapped(Vec3)) -> Wrapped(Vec3),
 
-        ///Transforms the given `Vec3A`, applying shear, scale, rotation and translation.
+        ///Transforms the given [`Vec3A`], applying shear, scale, rotation and translation.
         transform_point3a(&self:Wrapped(Vec3A)) -> Wrapped(Vec3A),
 
-        ///Transforms the given `Vec3A`, applying shear, scale and rotation (but NOT
+        ///Transforms the given [`Vec3A`], applying shear, scale and rotation (but NOT
         ///translation).
         ///
-        ///To also apply translation, use [`Self::transform_point3a`] instead.
+        ///To also apply translation, use [`Self::transform_point3a()`] instead.
         transform_vector3a(&self:Wrapped(Vec3A)) -> Wrapped(Vec3A),
 
         ///Returns `true` if, and only if, all elements are finite.
@@ -8810,8 +9137,8 @@ impl_script_newtype! {
     )
     + BinOps
     (
-        self Mul Wrapped(Affine3A) -> Wrapped(Affine3A),
         self Mul Wrapped(Mat4) -> Wrapped(Mat4),
+        self Mul Wrapped(Affine3A) -> Wrapped(Affine3A),
     )
     + UnaryOps
     (
@@ -8873,7 +9200,7 @@ impl_script_newtype! {
         ///Transforms the given 2D vector, applying shear, scale and rotation (but NOT
         ///translation).
         ///
-        ///To also apply translation, use [`Self::transform_point2`] instead.
+        ///To also apply translation, use [`Self::transform_point2()`] instead.
         transform_vector2(&self:Wrapped(DVec2)) -> Wrapped(DVec2),
 
         ///Returns `true` if, and only if, all elements are finite.
@@ -8909,8 +9236,8 @@ impl_script_newtype! {
     )
     + BinOps
     (
-        self Mul Wrapped(DAffine2) -> Wrapped(DAffine2),
         self Mul Wrapped(DMat3) -> Wrapped(DMat3),
+        self Mul Wrapped(DAffine2) -> Wrapped(DAffine2),
     )
     + UnaryOps
     (
@@ -9018,7 +9345,7 @@ impl_script_newtype! {
         ///Transforms the given 3D vector, applying shear, scale and rotation (but NOT
         ///translation).
         ///
-        ///To also apply translation, use [`Self::transform_point3`] instead.
+        ///To also apply translation, use [`Self::transform_point3()`] instead.
         transform_vector3(&self:Wrapped(DVec3)) -> Wrapped(DVec3),
 
         ///Returns `true` if, and only if, all elements are finite.
@@ -9054,8 +9381,8 @@ impl_script_newtype! {
     )
     + BinOps
     (
-        self Mul Wrapped(DAffine3) -> Wrapped(DAffine3),
         self Mul Wrapped(DMat4) -> Wrapped(DMat4),
+        self Mul Wrapped(DAffine3) -> Wrapped(DAffine3),
     )
     + UnaryOps
     (
@@ -9072,6 +9399,8 @@ impl_script_newtype! {
     ///floating point "error creep" which can occur when successive quaternion
     ///operations are applied.
     ///
+    ///SIMD vector types are used for storage on supported platforms.
+    ///
     ///This type is 16 byte aligned.
     glam::f32::Quat :
     Clone +
@@ -9100,7 +9429,8 @@ impl_script_newtype! {
         from_vec4(Wrapped(Vec4)) -> self,
 
         ///Create a quaternion for a normalized rotation `axis` and `angle` (in radians).
-        ///The axis must be normalized (unit-length).
+        ///
+        ///The axis must be a unit vector.
         ///
         ///# Panics
         ///
@@ -9136,7 +9466,7 @@ impl_script_newtype! {
         ///Gets the minimal rotation for transforming `from` to `to`.  The rotation is in the
         ///plane spanned by the two vectors.  Will rotate at most 180 degrees.
         ///
-        ///The input vectors must be normalized (unit-length).
+        ///The inputs must be unit vectors.
         ///
         ///`from_rotation_arc(from, to) * from ≈ to`.
         ///
@@ -9154,7 +9484,7 @@ impl_script_newtype! {
         ///The rotation is in the plane spanned by the two vectors.  Will rotate at most 90
         ///degrees.
         ///
-        ///The input vectors must be normalized (unit-length).
+        ///The inputs must be unit vectors.
         ///
         ///`to.dot(from_rotation_arc_colinear(from, to) * from).abs() ≈ 1`.
         ///
@@ -9166,7 +9496,7 @@ impl_script_newtype! {
         ///Gets the minimal rotation for transforming `from` to `to`.  The resulting rotation is
         ///around the z axis. Will rotate at most 180 degrees.
         ///
-        ///The input vectors must be normalized (unit-length).
+        ///The inputs must be unit vectors.
         ///
         ///`from_rotation_arc_2d(from, to) * from ≈ to`.
         ///
@@ -9316,9 +9646,9 @@ impl_script_newtype! {
         self Add self -> Wrapped(Quat),
         self Sub self -> Wrapped(Quat),
         self Div Raw(f32) -> Wrapped(Quat),
-        self Mul Raw(f32) -> Wrapped(Quat),
-        self Mul self -> Wrapped(Quat),
         self Mul Wrapped(Vec3) -> Wrapped(Vec3),
+        self Mul self -> Wrapped(Quat),
+        self Mul Raw(f32) -> Wrapped(Quat),
         self Mul Wrapped(Vec3A) -> Wrapped(Vec3A),
     )
     + UnaryOps
@@ -9363,7 +9693,8 @@ impl_script_newtype! {
         from_vec4(Wrapped(DVec4)) -> self,
 
         ///Create a quaternion for a normalized rotation `axis` and `angle` (in radians).
-        ///The axis must be normalized (unit-length).
+        ///
+        ///The axis must be a unit vector.
         ///
         ///# Panics
         ///
@@ -9396,7 +9727,7 @@ impl_script_newtype! {
         ///Gets the minimal rotation for transforming `from` to `to`.  The rotation is in the
         ///plane spanned by the two vectors.  Will rotate at most 180 degrees.
         ///
-        ///The input vectors must be normalized (unit-length).
+        ///The inputs must be unit vectors.
         ///
         ///`from_rotation_arc(from, to) * from ≈ to`.
         ///
@@ -9414,7 +9745,7 @@ impl_script_newtype! {
         ///The rotation is in the plane spanned by the two vectors.  Will rotate at most 90
         ///degrees.
         ///
-        ///The input vectors must be normalized (unit-length).
+        ///The inputs must be unit vectors.
         ///
         ///`to.dot(from_rotation_arc_colinear(from, to) * from).abs() ≈ 1`.
         ///
@@ -9426,7 +9757,7 @@ impl_script_newtype! {
         ///Gets the minimal rotation for transforming `from` to `to`.  The resulting rotation is
         ///around the z axis. Will rotate at most 180 degrees.
         ///
-        ///The input vectors must be normalized (unit-length).
+        ///The inputs must be unit vectors.
         ///
         ///`from_rotation_arc_2d(from, to) * from ≈ to`.
         ///
@@ -9786,7 +10117,7 @@ impl_script_newtype! {
         ///assert!(r.min.abs_diff_eq(Vec2::new(0., -1.), 1e-5));
         ///assert!(r.max.abs_diff_eq(Vec2::new(5., 3.), 1e-5));
         ///```
-        union(&self:Wrapped(Rect)) -> Wrapped(Rect),
+        union(&self:self) -> self,
 
         ///Build a new rectangle formed of the union of this rectangle and a point.
         ///
@@ -9802,7 +10133,7 @@ impl_script_newtype! {
         ///assert!(u.min.abs_diff_eq(Vec2::ZERO, 1e-5));
         ///assert!(u.max.abs_diff_eq(Vec2::new(5., 6.), 1e-5));
         ///```
-        union_point(&self:Wrapped(Vec2)) -> Wrapped(Rect),
+        union_point(&self:Wrapped(Vec2)) -> self,
 
         ///Build a new rectangle formed of the intersection of this rectangle and another rectangle.
         ///
@@ -9820,7 +10151,7 @@ impl_script_newtype! {
         ///assert!(r.min.abs_diff_eq(Vec2::new(1., 0.), 1e-5));
         ///assert!(r.max.abs_diff_eq(Vec2::new(3., 1.), 1e-5));
         ///```
-        intersect(&self:Wrapped(Rect)) -> Wrapped(Rect),
+        intersect(&self:self) -> self,
 
         ///Create a new rectangle with a constant inset.
         ///
@@ -9836,8 +10167,13 @@ impl_script_newtype! {
         ///let r2 = r.inset(3.); // w=11 h=7
         ///assert!(r2.min.abs_diff_eq(Vec2::splat(-3.), 1e-5));
         ///assert!(r2.max.abs_diff_eq(Vec2::new(8., 4.), 1e-5));
+        ///
+        ///let r = Rect::new(0., -1., 6., 7.); // w=6 h=8
+        ///let r2 = r.inset(-2.); // w=11 h=7
+        ///assert!(r2.min.abs_diff_eq(Vec2::new(2., 1.), 1e-5));
+        ///assert!(r2.max.abs_diff_eq(Vec2::new(4., 5.), 1e-5));
         ///```
-        inset(&self:Raw(f32)) -> Wrapped(Rect),
+        inset(&self:Raw(f32)) -> self,
 
     )
     + Fields
@@ -9868,6 +10204,10 @@ impl bevy_mod_scripting_lua::tealr::mlu::ExportInstances for BevyAPIGlobals {
         self,
         instances: &mut T,
     ) -> bevy_mod_scripting_lua::tealr::mlu::mlua::Result<()> {
+        instances.add_instance(
+            "Overflow",
+            bevy_mod_scripting_lua::tealr::mlu::UserDataProxy::<LuaOverflow>::new,
+        )?;
         instances.add_instance(
             "UiImage",
             bevy_mod_scripting_lua::tealr::mlu::UserDataProxy::<LuaUiImage>::new,
@@ -10099,10 +10439,10 @@ impl APIProvider for LuaBevyAPIProvider {
 			.process_type::<LuaInteraction>()
 			.process_type::<LuaJustifyContent>()
 			.process_type::<LuaOverflow>()
+			.process_type::<bevy_mod_scripting_lua::tealr::mlu::UserDataProxy<LuaOverflow>>()
 			.process_type::<LuaPositionType>()
 			.process_type::<LuaVal>()
 			.process_type::<LuaCalculatedClip>()
-			.process_type::<LuaCalculatedSize>()
 			.process_type::<LuaNode>()
 			.process_type::<LuaStyle>()
 			.process_type::<LuaUiImage>()
@@ -10300,7 +10640,6 @@ impl APIProvider for LuaBevyAPIProvider {
         app.register_foreign_lua_type::<PositionType>();
         app.register_foreign_lua_type::<Val>();
         app.register_foreign_lua_type::<CalculatedClip>();
-        app.register_foreign_lua_type::<CalculatedSize>();
         app.register_foreign_lua_type::<Node>();
         app.register_foreign_lua_type::<Style>();
         app.register_foreign_lua_type::<UiImage>();
diff --git a/bevy_script_api/src/lua/bevy/mod.rs b/bevy_script_api/src/lua/bevy/mod.rs
index e2f34aad29..32d29d7059 100644
--- a/bevy_script_api/src/lua/bevy/mod.rs
+++ b/bevy_script_api/src/lua/bevy/mod.rs
@@ -3,11 +3,10 @@ use crate::impl_tealr_type;
 
 use std::sync::Arc;
 
-use bevy::ecs::system::Command;
 use bevy::hierarchy::BuildWorldChildren;
 use bevy::prelude::AppTypeRegistry;
 
-use bevy::{hierarchy::DespawnRecursive, prelude::ReflectResource};
+use bevy::prelude::ReflectResource;
 use bevy_mod_scripting_core::prelude::*;
 use bevy_mod_scripting_lua::tealr;
 
@@ -18,6 +17,8 @@ use tealr::mlu::{
 
 pub use crate::generated::*;
 
+use super::util::LuaIndex;
+
 pub type LuaTypeRegistration = ScriptTypeRegistration;
 impl_tealr_type!(LuaTypeRegistration);
 
@@ -240,13 +241,13 @@ impl TealData for LuaWorld {
             .document("Inserts children entities to the given parent entity at the given index.");
         methods.add_method(
             "insert_children",
-            |_, world, (parent, index, children): (LuaEntity, usize, Vec<LuaEntity>)| {
+            |_, world, (parent, index, children): (LuaEntity, LuaIndex, Vec<LuaEntity>)| {
                 let children = children
                     .iter()
                     .map(|e| e.inner())
                     .collect::<Result<Vec<_>, _>>()?;
 
-                world.insert_children(parent.inner()?, index, &children);
+                world.insert_children(parent.inner()?, *index, &children);
                 Ok(())
             },
         );
@@ -254,8 +255,8 @@ impl TealData for LuaWorld {
         methods.document("Inserts child entity to the given parent entity at the given index.");
         methods.add_method(
             "insert_child",
-            |_, world, (parent, index, child): (LuaEntity, usize, LuaEntity)| {
-                world.insert_children(parent.inner()?, index, &[child.inner()?]);
+            |_, world, (parent, index, child): (LuaEntity, LuaIndex, LuaEntity)| {
+                world.insert_children(parent.inner()?, *index, &[child.inner()?]);
                 Ok(())
             },
         );
@@ -275,16 +276,6 @@ impl TealData for LuaWorld {
             Ok(())
         });
 
-        methods.document("Despawns the given entity and the entity's children recursively");
-        methods.add_method("insert_children", |_, world, entity: LuaEntity| {
-            let mut w = world.write();
-            DespawnRecursive {
-                entity: entity.inner()?,
-            }
-            .write(&mut w);
-            Ok(())
-        });
-
         methods.document("Spawns a new entity and returns its Entity ID");
         methods.add_method("spawn", |_, world, ()| {
             let mut w = world.write();
diff --git a/bevy_script_api/src/lua/mod.rs b/bevy_script_api/src/lua/mod.rs
index 6b3b826678..c3fc0fa84c 100644
--- a/bevy_script_api/src/lua/mod.rs
+++ b/bevy_script_api/src/lua/mod.rs
@@ -20,6 +20,7 @@ use tealr::TypeName;
 use crate::script_ref::{ReflectedValue, ScriptRef, ValueIndex};
 
 use self::bevy::LuaWorld;
+use self::util::to_host_idx;
 
 pub mod bevy;
 pub mod std;
@@ -65,7 +66,7 @@ impl ValueIndex<Value<'_>> for ScriptRef {
 
     fn index(&self, index: Value<'_>) -> Self::Output {
         match index {
-            Value::Integer(idx) => Ok(self.index(idx as usize)),
+            Value::Integer(idx) => Ok(self.index(to_host_idx(idx as usize))),
             Value::String(field) => {
                 let str_ = field.to_str()?.to_string();
                 // TODO: hopefully possible to use a &'_ str here
@@ -168,7 +169,7 @@ impl TealData for ReflectedValue {
         methods.document_type("If you know the reflected value converts to a LuaType (via LuaProxyable), use the `as` operator to convert to said type.");
 
         methods.add_meta_method(MetaMethod::ToString, |_, val, ()| {
-            val.ref_.get(|s| Ok(format!("{:#?}", &s)))?
+            val.ref_.get(|s| Ok(format!("{:?}", &s)))?
         });
 
         methods.add_meta_method_mut(MetaMethod::Index, |_, val, field: Value| {
diff --git a/bevy_script_api/src/lua/std.rs b/bevy_script_api/src/lua/std.rs
index a61921526e..c69e961b5c 100644
--- a/bevy_script_api/src/lua/std.rs
+++ b/bevy_script_api/src/lua/std.rs
@@ -3,6 +3,7 @@ use ::std::borrow::Cow;
 use bevy::reflect::FromReflect;
 use bevy::reflect::Reflect;
 
+use bevy::reflect::TypePath;
 use bevy_mod_scripting_lua::tealr;
 
 use tealr::mlu::mlua::MetaMethod;
@@ -23,6 +24,8 @@ use crate::{
     sub_reflect::ReflectPathElem,
 };
 
+use super::util::to_lua_idx;
+use super::util::LuaIndex;
 use super::ApplyLua;
 use super::FromLuaProxy;
 use super::LuaProxyable;
@@ -96,8 +99,8 @@ impl<'lua> ToLuaProxy<'lua> for String {
     }
 }
 
-impl<T: LuaProxyable + Reflect + FromReflect + for<'a> FromLuaProxy<'a> + Clone> LuaProxyable
-    for Option<T>
+impl<T: LuaProxyable + Reflect + FromReflect + TypePath + for<'a> FromLuaProxy<'a> + Clone>
+    LuaProxyable for Option<T>
 {
     fn ref_to_lua(self_: ScriptRef, lua: &Lua) -> mlua::Result<Value> {
         self_.get_typed(|s: &Option<T>| match s {
@@ -233,6 +236,7 @@ pub type LuaVec<T> = ScriptVec<T>;
 impl<
         T: TypeName
             + FromReflect
+            + TypePath
             + LuaProxyable
             + for<'a> FromLuaProxy<'a>
             + for<'a> ToLuaProxy<'a>
@@ -268,6 +272,7 @@ impl<T: TypeName> TypeName for LuaVec<T> {
 impl<
         T: TypeName
             + FromReflect
+            + TypePath
             + LuaProxyable
             + for<'a> FromLuaProxy<'a>
             + for<'a> ToLuaProxy<'a>
@@ -284,32 +289,42 @@ impl<
 }
 
 impl<
-        T: TypeName + FromReflect + LuaProxyable + for<'a> FromLuaProxy<'a> + for<'a> ToLuaProxy<'a>,
+        T: TypeName
+            + FromReflect
+            + TypePath
+            + LuaProxyable
+            + for<'a> FromLuaProxy<'a>
+            + for<'a> ToLuaProxy<'a>,
     > TealData for LuaVec<T>
 {
     fn add_methods<'lua, M: TealDataMethods<'lua, Self>>(methods: &mut M) {
         methods.document_type("A reference to the Vec<T> Rust type.");
         methods.document_type("All indexing begins at 1.");
 
-        methods.add_meta_method(MetaMethod::ToString, |_, s, ()| Ok(format!("{s:?}")));
+        methods.add_meta_method(MetaMethod::ToString, |_, s, ()| {
+            Ok(s.ref_.get(|s| format!("{:?}", s))?)
+        });
 
-        methods.add_meta_method(MetaMethod::Index, |_, s, index: usize| {
-            Ok(s.index(index - 1))
+        methods.add_meta_method(MetaMethod::Index, |_, s, index: LuaIndex| {
+            Ok(s.index(*index))
         });
 
         methods.add_meta_method_mut(
             MetaMethod::NewIndex,
-            |ctx, s, (index, value): (usize, Value)| s.index(index - 1).apply_lua(ctx, value),
+            |ctx, s, (index, value): (LuaIndex, Value)| s.index(*index).apply_lua(ctx, value),
         );
 
         methods.add_meta_method(MetaMethod::Pairs, |ctx, s, _: ()| {
             let len = s.len()?;
-            let mut curr_idx = 1;
+            let mut curr_idx = 0;
             let ref_: ScriptRef = s.clone().into();
             TypedFunction::from_rust_mut(
                 move |ctx, ()| {
                     let o = if curr_idx < len {
-                        (curr_idx.to_lua(ctx)?, ref_.index(curr_idx).to_lua(ctx)?)
+                        (
+                            to_lua_idx(curr_idx).to_lua(ctx)?,
+                            ref_.index(curr_idx).to_lua(ctx)?,
+                        )
                     } else {
                         (Value::Nil, Value::Nil)
                     };
@@ -322,6 +337,17 @@ impl<
 
         methods.add_meta_method(MetaMethod::Len, |_, s, ()| Ok(s.len()?));
 
+        methods.add_method("to_table", |ctx, s, ()| {
+            let table = ctx.create_table()?;
+            let len = s.len()?;
+
+            for i in 0..len {
+                table.raw_set(to_lua_idx(i), s.index(i).to_lua(ctx)?)?;
+            }
+
+            Ok(table)
+        });
+
         methods.add_method_mut("push", |ctx, s, v: Value| {
             let new_val = T::from_lua_proxy(v, ctx)?;
             s.push(new_val)?;
@@ -335,13 +361,13 @@ impl<
             Ok(())
         });
 
-        methods.add_method_mut("insert", |ctx, s, (idx, v): (usize, Value<'lua>)| {
-            s.insert(idx - 1, T::from_lua_proxy(v, ctx)?)?;
+        methods.add_method_mut("insert", |ctx, s, (idx, v): (LuaIndex, Value<'lua>)| {
+            s.insert(*idx, T::from_lua_proxy(v, ctx)?)?;
             Ok(())
         });
 
-        methods.add_method_mut("remove", |ctx, s, idx: usize| {
-            let removed = s.remove(idx)?;
+        methods.add_method_mut("remove", |ctx, s, idx: LuaIndex| {
+            let removed = s.remove(*idx)?;
             removed.to_lua_proxy(ctx)
         });
     }
@@ -350,6 +376,7 @@ impl<
 impl<
         T: TypeName
             + FromReflect
+            + TypePath
             + LuaProxyable
             + for<'a> FromLuaProxy<'a>
             + for<'a> ToLuaProxy<'a>
@@ -410,6 +437,7 @@ impl<
             + for<'a> ToLuaProxy<'a>
             + Clone
             + FromReflect
+            + TypePath
             + LuaProxyable
             + std::fmt::Debug,
     > FromLuaProxy<'lua> for Vec<T>
diff --git a/bevy_script_api/src/lua/util.rs b/bevy_script_api/src/lua/util.rs
index 05a2cbed09..9b1d4166b7 100644
--- a/bevy_script_api/src/lua/util.rs
+++ b/bevy_script_api/src/lua/util.rs
@@ -1,8 +1,61 @@
-use bevy_mod_scripting_lua::tealr;
-use std::marker::PhantomData;
+use bevy_mod_scripting_lua::{
+    prelude::{FromLua, Lua, LuaError, LuaValue, ToLua},
+    tealr,
+};
+use std::{
+    marker::PhantomData,
+    ops::{Deref, DerefMut},
+};
 
 use tealr::TypeName;
 
+/// Newtype abstraction of usize to represent a lua integer indexing things.
+/// Lua is 1 based, host is 0 based, and this type performs this conversion automatically via ToLua and FromLua traits.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct LuaIndex(usize);
+
+impl TypeName for LuaIndex {
+    fn get_type_parts() -> std::borrow::Cow<'static, [tealr::NamePart]> {
+        usize::get_type_parts()
+    }
+}
+
+impl Deref for LuaIndex {
+    type Target = usize;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for LuaIndex {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+impl ToLua<'_> for LuaIndex {
+    fn to_lua(self, lua: &Lua) -> Result<LuaValue, LuaError> {
+        to_lua_idx(self.0).to_lua(lua)
+    }
+}
+
+impl FromLua<'_> for LuaIndex {
+    fn from_lua(value: LuaValue, lua: &Lua) -> Result<LuaIndex, LuaError> {
+        Ok(LuaIndex(to_host_idx(usize::from_lua(value, lua)?)))
+    }
+}
+
+/// Converts lua index to host index (Lua is 1 based, host is 0 based)
+pub fn to_host_idx(lua_idx: usize) -> usize {
+    lua_idx - 1
+}
+
+/// Converts host index to lua index (Lua is 1 based, host is 0 based)
+pub fn to_lua_idx(host_idx: usize) -> usize {
+    host_idx + 1
+}
+
 /// forwards the TypeName implementation of T, useful for internal 'fake' global instances
 pub struct DummyTypeName<T> {
     _ph: PhantomData<T>,
@@ -136,12 +189,18 @@ macro_rules! impl_tealr_generic{
 
         }
 
-        impl ::bevy::reflect::Reflect for $name {
-            fn type_name(&self) -> &str {
-                panic!("This should never be called, I am a dummy implementation");
+        impl ::bevy::reflect::TypePath for $name {
+            fn short_type_path() -> &'static str{
+                panic!("This should never be called, I am a dummy implementation")
             }
 
-            fn get_type_info(&self) -> &'static bevy::reflect::TypeInfo {
+            fn type_path() -> &'static str{
+                panic!("This should never be called, I am a dummy implementation")
+            }
+        }
+
+        impl ::bevy::reflect::Reflect for $name {
+            fn type_name(&self) -> &str {
                 panic!("This should never be called, I am a dummy implementation");
             }
 
@@ -192,10 +251,14 @@ macro_rules! impl_tealr_generic{
             fn reflect_owned(self: Box<Self>) -> ::bevy::reflect::ReflectOwned {
                 panic!("This should never be called, I am a dummy implementation");
             }
+
+            fn get_represented_type_info(&self) -> std::option::Option<&'static bevy::reflect::TypeInfo> {
+                panic!("This should never be called, I am a dummy implementation");
+            }
         }
 
         impl ::bevy::reflect::FromReflect for $name {
-            fn from_reflect(_: &dyn ::bevy::reflect::Reflect) -> Option<Self> {
+            fn from_reflect(_: &(dyn bevy::prelude::Reflect + 'static)) -> std::option::Option<Self> {
                 panic!("This should never be called, I am a dummy implementation");
             }
         }
diff --git a/bevy_script_api/src/rhai/mod.rs b/bevy_script_api/src/rhai/mod.rs
index 28ecb7ab5e..b5391e343d 100644
--- a/bevy_script_api/src/rhai/mod.rs
+++ b/bevy_script_api/src/rhai/mod.rs
@@ -181,7 +181,13 @@ impl CustomType for ReflectedValue {
                 obj.ref_.index(index)?.apply_rhai(value)
             })
             .with_fn("to_debug", |self_: &mut ReflectedValue| {
-                format!("{self_:?}")
+                format!("{:?}", self_)
+            })
+            .with_fn("to_string", |self_: &mut ReflectedValue| {
+                self_
+                    .ref_
+                    .get(|s| format!("{:?}", &s))
+                    .map_err::<Box<EvalAltResult>, _>(|e| e.into())
             });
     }
 }
diff --git a/bevy_script_api/src/rhai/std.rs b/bevy_script_api/src/rhai/std.rs
index 4bf4ea7447..eb5a6309de 100644
--- a/bevy_script_api/src/rhai/std.rs
+++ b/bevy_script_api/src/rhai/std.rs
@@ -1,6 +1,10 @@
-use std::{any::type_name, iter::Map};
+use std::{
+    any::type_name,
+    fmt::{Debug, Display},
+    iter::Map,
+};
 
-use bevy::reflect::{FromReflect, Reflect};
+use bevy::reflect::{FromReflect, Reflect, TypePath};
 #[allow(deprecated)]
 use bevy_mod_scripting_rhai::rhai::{CustomType, Dynamic, Engine, EvalAltResult, Position};
 
@@ -109,7 +113,9 @@ impl_rhai_proxy!(f64 as FLOAT);
 impl_rhai_proxy!(bool as bool);
 impl_rhai_proxy!(String as Into);
 
-impl<T: RhaiProxyable + Reflect + FromReflect + Clone + FromRhaiProxy> RhaiProxyable for Option<T> {
+impl<T: RhaiProxyable + Reflect + FromReflect + TypePath + Clone + FromRhaiProxy> RhaiProxyable
+    for Option<T>
+{
     fn ref_to_rhai(self_: crate::ScriptRef) -> Result<Dynamic, Box<EvalAltResult>> {
         self_.get_typed(|s: &Option<T>| match s {
             Some(_) => T::ref_to_rhai(self_.sub_ref(ReflectPathElem::SubReflection {
@@ -234,17 +240,30 @@ impl<T: ToRhaiProxy> ToRhaiProxy for Option<T> {
 }
 
 /// Composite trait composing the various traits required for a type `T` to be used as part of a RhaiVec<T>
-pub trait RhaiVecElem: FromReflect + RhaiProxyable + FromRhaiProxy + Clone {}
-impl<T: FromReflect + RhaiProxyable + FromRhaiProxy + Clone> RhaiVecElem for T {}
+pub trait RhaiVecElem: FromReflect + TypePath + RhaiProxyable + FromRhaiProxy + Clone {}
+impl<T: FromReflect + TypePath + RhaiProxyable + FromRhaiProxy + Clone> RhaiVecElem for T {}
 
 /// A ScriptVec wrapper which implements a custom iterator ontop of ScriptVec's
 pub struct RhaiVec<T: RhaiVecElem>(pub ScriptVec<T>);
+
 impl<T: RhaiVecElem> Clone for RhaiVec<T> {
     fn clone(&self) -> Self {
         Self(self.0.clone())
     }
 }
 
+impl<T: RhaiVecElem> Debug for RhaiVec<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self.0)
+    }
+}
+
+impl<T: Display + RhaiVecElem> Display for RhaiVec<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 impl<T: RhaiVecElem> RhaiVec<T> {
     pub fn new_ref(self_: crate::ScriptRef) -> Self {
         Self(ScriptVec::<T>::new_ref(self_))
@@ -351,6 +370,12 @@ impl<T: RhaiVecElem> CustomType for RhaiVec<T> {
     fn build(mut builder: bevy_mod_scripting_rhai::rhai::TypeBuilder<Self>) {
         builder
             .with_name(type_name::<Vec<T>>())
+            .with_fn("to_debug", |vec: &mut RhaiVec<T>| format!("{:?}", vec))
+            .with_fn("to_string", |vec: &mut RhaiVec<T>| {
+                vec.ref_
+                    .get(|s| format!("{:?}", &s))
+                    .map_err::<Box<EvalAltResult>, _>(|e| e.into())
+            })
             .with_result_fn("is_empty", |vec: &mut RhaiVec<T>| {
                 vec.is_empty().map_err(Into::into)
             })
diff --git a/examples/lua/bevy_api.rs b/examples/lua/bevy_api.rs
index c347986cea..025e2e3dec 100644
--- a/examples/lua/bevy_api.rs
+++ b/examples/lua/bevy_api.rs
@@ -1,60 +1,19 @@
 use bevy::app::AppExit;
-use bevy::math::DQuat;
+
 use bevy::prelude::*;
 use bevy_mod_scripting::prelude::*;
-use bevy_mod_scripting_lua::tealr::mlu::mlua::UserData;
-use bevy_script_api::lua::{
-    bevy::LuaBevyAPIProvider, ReflectLuaProxyable, RegisterForeignLuaType, ValueLuaType,
-};
-
-/// Let's define a resource, we want it to be "assignable" via lua so we derive `ReflectLuaProxyable`
-/// This allows us to reach this value when it's a field under any other Reflectable type
-
-#[derive(Default, Clone, Resource, Reflect)]
-#[reflect(Resource, LuaProxyable)]
-pub struct MyResource {
-    pub thing: f64,
-}
 
-/// NOTE: this is a marker enabling an automatic implementation of LuaProxyable
-/// By default, because this type implements Clone as well,
-/// It will be passed BY VALUE
-/// meaning that calling these methods will result in changes to the cloned value on lua side only
-/// untill the resource is assigned back to the original component to make the changes on the original type.
-/// To have "pass by reference" semantics use a  [`bevy_mod_scripting::api::lua::LuaWrapper`] and implement LuaProxyable yourself (see wrappers.rs example)
-impl ValueLuaType for MyResource {}
-
-impl UserData for MyResource {
-    fn add_methods<'lua, M: mlua::UserDataMethods<'lua, Self>>(methods: &mut M) {
-        methods.add_method_mut("custom_resource_method", |_, s, v: f64| {
-            s.thing = v;
-
-            Ok("hello?")
-        });
-
-        methods.add_meta_method(mlua::MetaMethod::ToString, |_, s, ()| {
-            Ok(format!(
-                "I'm a resource with a custom metatable!: {}",
-                s.thing
-            ))
-        });
-    }
-}
+use bevy_script_api::lua::{bevy::LuaBevyAPIProvider, RegisterForeignLuaType};
 
 #[derive(Component, Default, Reflect)]
 #[reflect(Component)]
 pub struct MyComponent {
-    dquat: DQuat,
     quat: Quat,
     vec2: Vec2,
-    vec3: Vec3,
-    uvec2: UVec2,
     usize: usize,
     f32: f32,
     mat3: Mat3,
-    vec4: Vec4,
-    u8: u8,
-    option: Option<Vec3>,
+    option_vec3: Option<Vec3>,
     vec_of_option_bools: Vec<Option<bool>>,
     option_vec_of_bools: Option<Vec<bool>>,
 }
@@ -63,29 +22,22 @@ fn main() -> std::io::Result<()> {
     let mut app = App::new();
 
     app.add_plugins(DefaultPlugins)
-        .add_plugin(ScriptingPlugin)
+        .add_plugins(ScriptingPlugin)
         .register_type::<MyComponent>()
-        .register_type::<MyResource>()
         // note the implementation for Option is there, but we must register `LuaProxyable` for it
         .register_foreign_lua_type::<Option<Vec3>>()
         .register_foreign_lua_type::<Vec<Option<bool>>>()
         .register_foreign_lua_type::<Option<bool>>()
         .register_foreign_lua_type::<Option<Vec<bool>>>()
-        .init_resource::<MyResource>()
-        // this system set handles addition and removal of script contexts, we can safely use `CoreSet::PostUpdate`
-        .add_script_host_to_base_set::<LuaScriptHost<()>, _>(CoreSet::PostUpdate)
-        .add_script_handler_to_base_set::<LuaScriptHost<()>,_,0,0>(CoreSet::PostUpdate)
+        .add_script_host::<LuaScriptHost<()>>(PostUpdate)
         .add_api_provider::<LuaScriptHost<()>>(Box::new(LuaBevyAPIProvider))
-        .add_system(
+        .add_systems(Startup,
             |world: &mut World| {
 
                 let entity = world.spawn(())
                     .insert(MyComponent {
-                        vec2: Vec2::new(1.0, 2.0),
-                        vec3: Vec3::new(1.0, 2.0, 3.0),
-                        vec4: Vec4::new(1.0, 2.0, 3.0, 4.0),
-                        uvec2: UVec2::new(1, 2),
                         usize: 5,
+                        vec2: Vec2::new(1.0, 2.0),
                         f32: 6.7,
                         mat3: Mat3::from_cols(
                             Vec3::new(1.0, 2.0, 3.0),
@@ -93,9 +45,7 @@ fn main() -> std::io::Result<()> {
                             Vec3::new(7.0, 8.0, 9.0),
                         ),
                         quat: Quat::from_xyzw(1.0, 2.0, 3.0, 4.0),
-                        dquat: DQuat::from_xyzw(1.0, 2.0, 3.0, 4.0),
-                        u8: 240,
-                        option: None,
+                        option_vec3: None,
                         vec_of_option_bools: vec![Some(true), None, Some(false)],
                         option_vec_of_bools: Some(vec![true, true, true]),
                     }).id();
@@ -104,6 +54,14 @@ fn main() -> std::io::Result<()> {
                 world.resource_scope(|world, mut host: Mut<LuaScriptHost<()>>| {
                     host.run_one_shot(
                         r#"
+                        function table_to_string(t)
+                            local result = "["
+                            for k,v in pairs(t) do
+                                result = result .. string.format("%s:%s,",k,v)
+                            end
+                            return result .. "]"
+                        end
+
                         function once()
                             
                             -- the api provides us with 3 globals
@@ -112,107 +70,112 @@ fn main() -> std::io::Result<()> {
                             print(world)
 
                             -- we first retrieve ID's for our component and resource by their short name (long name/full path also work)
-                            
                             local my_component_type = world:get_type_by_name("MyComponent")
-                            local my_resource_type = world:get_type_by_name("MyResource")
 
                             -- then ask the world to give us a reference to `MyComponent` on the entity we just spawned
-
+                            -- resources work the same way, but we use `get_resource` instead of `get_component`
+                            -- the comp object is resolved to a `bevy_script_api::script_ref::ReflectValue` which implements UserData.
+                            -- we can use a custom proxy instead (by implementing LuaProxyable), but this is the simplest way to get started.
                             local comp = world:get_component(entity, my_component_type)
-                            -- and our resource
+                            print("Before script: ", comp)
 
-                            local res = world:get_resource(my_resource_type)
-                            -- we can now arbitrarily affect these 
-                            
-                            -- we can even call our custom methods!
-                            
-                            print(string.format(res:custom_resource_method(42)))
-                            
-                            -- we can set any of the fields
-                            -- if the field is `LuaProxyable` like our resource
-                            -- that trait's implementation controls this assignment
-                            comp.u8 = 2
-                            
-                            -- Option's get converted to nil | Value
-
-                            if comp.option == nil then
-                                print(string.format("option was %s", comp.option))
-                                comp.option = Vec3.new(2,1,3)
-                                print(string.format("option[1] is now %s", comp.option[1]))
-                                comp.option[1] = 5
-                                print(string.format("and now option[1] is %s", comp.option[1]))
-                            end
+                            print("============")
+
+                            -- the index metamethod on ReflectValue's uses bevy's reflection mechanism on top of some custom sub-reflection logic to
+                            -- allow reflecting inside Options, Vectors etc. 
+                            -- when we index into ReflectValue's we either get back a custom proxy or another ReflectValue
+
+                            -- the LuaBevyAPIProvider provides us custom proxies for many bevy types as well as std types.
+                            -- all of these implementations can be overridden via the bevy TypeRegistry
+                            comp.usize = 2
+                            print("comp.usize after assigning to 2: ", comp.usize)
                             
-                            -- Vec<T> references get converted to a special proxy `LuaVec<T>` which is 
-                            -- assignable via the Lua Tables
+                            -- Option's get converted to nil or the value inside
+                            print("comp.option_vec3 before: ", comp.option_vec3)
+                            comp.option_vec3 = Vec3.new(2,1,3)
+                            print("comp.option_vec3 after: ", comp.option_vec3)
+
+                            -- reflection via index is indexed starting at 1, unlike in Rust to match Lua's indexing
+                            print("comp.option_vec3[1] before: ", comp.option_vec3[1])
+                            comp.option_vec3[1] = 5
+                            print("comp.option_vec3[1] after: ", comp.option_vec3[1])
+
+                            print("============")
 
+                            -- Vec<T> references get converted to a custom proxy `LuaVec<T>` which is 
+                            -- also assignable via lua tables 
+
+                            print("comp.vec_of_option_bools before: ", table_to_string(comp.vec_of_option_bools))
                             comp.vec_of_option_bools = {true,false,true}
-                            
-                            -- everything on the bevy side which uses Lua constructs as "Owned" variants
-                            -- indexes from 1, other types map one to one with the bevy implementations and index from zero
+                            print("comp.vec_of_option_bools after assignment: ", table_to_string(comp.vec_of_option_bools))
 
+                            print("comp.vec_of_option_bools[1] before: ", comp.vec_of_option_bools[1])
                             comp.vec_of_option_bools[1] = false
-                            -- there are some additional methods available on LuaVec
+                            print("comp.vec_of_option_bools[1] after: ", comp.vec_of_option_bools[1])
 
+                            -- there are some additional methods available on LuaVec proxies imitating the Vec<T> api
+                            print("comp.vec_of_option_bools before insert: ", table_to_string(comp.vec_of_option_bools))
                             comp.vec_of_option_bools:insert(1,nil)
+                            print("comp.vec_of_option_bools after insert: ", table_to_string(comp.vec_of_option_bools))
+
+                            print("comp.vec_of_option_bools before push: ", table_to_string(comp.vec_of_option_bools))
                             comp.vec_of_option_bools:push(false)
-                            
-                            -- Note, that Option's are reflected as Value types in Bevy, we are using
-                            -- a custom magical SubReflection system allowing us to do this!
-
-                            comp.option_vec_of_bools = {false,true,false}
-                            comp.option_vec_of_bools[1] = true
-                            comp.option_vec_of_bools:insert(1,false)
-                            comp.option_vec_of_bools:push(true)
-                    
-                            print(#comp.vec_of_option_bools)
-                            print(comp.vec_of_option_bools:pop())
-                            print(comp.option_vec_of_bools:pop())
+                            print("comp.vec_of_option_bools after push: ", table_to_string(comp.vec_of_option_bools))
+
+                            print("comp.vec_of_option_bools len after push: ", #comp.vec_of_option_bools)
 
+                            print("comp.vec_of_option_bools before pop: ", table_to_string(comp.vec_of_option_bools))
+                            print(comp.vec_of_option_bools:pop())
+                            print("comp.vec_of_option_bools after pop: ", table_to_string(comp.vec_of_option_bools))
+                            
+                            print("the pairs inside comp.vec_of_option_bools: ")             
                             for k,v in pairs(comp.vec_of_option_bools) do
-                                print(string.format("%s:%s",k,v))
+                                print(string.format(" - %s:%s",k,v))
                             end
+                            
+                            comp.vec_of_option_bools:clear()
+                            print("comp.vec_of_option_bools after clear: ", table_to_string(comp.vec_of_option_bools))
 
-                            print(#comp.option_vec_of_bools)
+                            print("comp.vec_of_option_bools len after clear: ", #comp.vec_of_option_bools)
+                            print("============")
+
+                            print("comp.option_vec_of_bools before: ", table_to_string(comp.option_vec_of_bools))
+                            print(comp.option_vec_of_bools:pop())
+                            print("comp.option_vec_of_bools after pop: ", table_to_string(comp.option_vec_of_bools))
+  
 
+                            print("comp.option_vec_of_bools len after pop: ", #comp.option_vec_of_bools)
+
+                            print("the pairs inside comp.option_vec_of_bools: ")
                             for k,v in pairs(comp.option_vec_of_bools) do
-                                print(string.format("%s:%s",k,v))
+                                print(string.format(" - %s:%s",k,v))
                             end
-                    
-                            comp.vec_of_option_bools:clear()
 
-                            print(#comp.vec_of_option_bools)
+                            print("============")
 
-                            -- Every Bevy type implementing Reflect is available as a LuaProxyable wrapper
-                            -- available types are under `api::lua::bevy::*` and std types in `api::lua::std::*`
-                            -- not all functions are exposed but support for more complex functions will be rolled out
+                            local complex_vec_op = Vec3.new(0,1,0):any_orthonormal_vector() + comp.mat3.x_axis 
+                            print("(0,1,0).any_orthonormal_vector() + mat3.x_axis is: ", complex_vec_op) 
                             
+                            local new_mat3 = Mat3.from_cols(Vec3.new(1,0,0),Vec3.new(0,1,0),Vec3.new(0,0,-1))
+                            print("new_mat3 is:", new_mat3)
+
                             comp.vec2 = comp.vec2 + comp.vec2
-                            comp.uvec2 = comp.uvec2 + comp.uvec2
                             comp.usize = comp.vec2:min_element()
                             comp.f32 = comp.f32 + comp.f32 + comp.vec2:min_element()
                             comp.vec2 = Vec2.new(2,1)
-                            comp.vec3 = Vec3.new(0,1,0):any_orthonormal_vector() + comp.mat3.x_axis + comp.option
-                            comp.vec4 = Vec4.splat(3)
                             comp.quat = Quat.from_xyzw(3,2,1,4)
-                            comp.dquat = comp.dquat * 2
-                            local a = Mat3.from_cols(Vec3.new(1,0,0),Vec3.new(0,1,0),Vec3.new(0,0,-1))
-                            
-                            -- again an instance of sub reflection here, very cool!
-                            
-                            comp.mat3[0][0] = 42
                             comp.mat3.x_axis = Vec3.new(69,69,69)
+
+                            print("============")
+
+                            -- this is an example of something impossible to achieve with plain bevy reflection under the hood
+                            comp.mat3[1][1] = 42
+
+                            -- now let's retrieve these again to see if we actually changed their values permanently
+                            comp = world:get_component(entity,my_component_type)
                             
-                            -- now let's retrieve these again to see if we actually changed their values
-                            
-                            comp = world:get_component(Entity.from_raw(0),my_component_type)
-                            res = world:get_resource(my_resource_type)
-                            
-                            -- notet that our custom resource's value has not affected the original
-                            -- this is because it is a by-value proxy, see wrappers.rs for an alternative
                             print("After script:")
                             print(comp)
-                            print(res)
                         end
                         "#
                         .as_bytes(),
diff --git a/examples/lua/complex_game_loop.rs b/examples/lua/complex_game_loop.rs
index 13bd0fc8d9..6d46a9258a 100644
--- a/examples/lua/complex_game_loop.rs
+++ b/examples/lua/complex_game_loop.rs
@@ -1,10 +1,13 @@
+use bevy::core::FrameCount;
+use bevy::ecs::schedule::ScheduleLabel;
 use bevy::prelude::*;
 use bevy_mod_scripting::prelude::*;
 use rand::prelude::SliceRandom;
+use std::sync::atomic::AtomicU32;
 use std::sync::atomic::Ordering::Relaxed;
-use std::sync::{atomic::AtomicU32, Mutex};
 
 #[derive(Clone)]
+/// The type we will be using to send data to Lua
 pub struct MyLuaArg(usize);
 
 impl<'lua> ToLua<'lua> for MyLuaArg {
@@ -13,63 +16,37 @@ impl<'lua> ToLua<'lua> for MyLuaArg {
     }
 }
 
-#[derive(Default)]
-pub struct LuaAPIProvider;
-
-/// the custom Lua api, world is provided via a global pointer,
-/// and callbacks are defined only once at script creation
-impl APIProvider for LuaAPIProvider {
-    type APITarget = Mutex<Lua>;
-    type DocTarget = LuaDocFragment;
-    type ScriptContext = Mutex<Lua>;
-
-    fn attach_api(&mut self, ctx: &mut Self::APITarget) -> Result<(), ScriptError> {
-        // callbacks can receive any `ToLuaMulti` arguments, here '()' and
-        // return any `FromLuaMulti` arguments, here a `usize`
-        // check the Rlua documentation for more details
-
-        let ctx = ctx.get_mut().unwrap();
-
-        ctx.globals()
-            .set(
-                "print",
-                ctx.create_function(|_ctx, msg: String| {
-                    info!("{}", msg);
-                    Ok(())
-                })
-                .map_err(ScriptError::new_other)?,
-            )
-            .map_err(ScriptError::new_other)?;
-
-        Ok(())
-    }
-}
-
+/// Used to assign events unique ids
 static COUNTER: AtomicU32 = AtomicU32::new(0);
 
-/// utility for generating random events from a list
-fn fire_random_event(
-    w: &mut PriorityEventWriter<LuaEvent<mlua::Variadic<MyLuaArg>>>,
-    events: &[ScriptEventData],
-) {
+/// The event firing logic we will use at the each stage of the game loop
+/// Fires a random event from the pool of all events i.e. one of:
+/// - on_pre_physics, priority: 0
+/// - on_post_physics, priority: 11
+/// - on_pre_physics, priority: 21
+fn fire_random_event(w: &mut PriorityEventWriter<LuaEvent<mlua::Variadic<MyLuaArg>>>) {
     let mut rng = rand::thread_rng();
     let id = COUNTER.fetch_add(1, Relaxed);
     let arg = MyLuaArg(id as usize);
-    let (event, prio) = events
-        .choose(&mut rng)
-        .map(|v| {
-            let mut args = mlua::Variadic::new();
-            args.push(arg);
-            (
-                LuaEvent {
-                    hook_name: v.0.to_string(),
-                    args,
-                    recipients: Recipients::All,
-                },
-                v.1,
-            )
-        })
-        .unwrap();
+    let (event, prio) = [
+        ("on_pre_physics", 0),
+        ("on_post_physics", 11),
+        ("on_post_update", 21),
+    ]
+    .choose(&mut rng)
+    .map(|v| {
+        let mut args = mlua::Variadic::new();
+        args.push(arg);
+        (
+            LuaEvent {
+                hook_name: v.0.to_string(),
+                args,
+                recipients: Recipients::All,
+            },
+            v.1,
+        )
+    })
+    .unwrap();
 
     info!(
         "\t - event: {},\t prio: {},\t id: {}",
@@ -78,48 +55,27 @@ fn fire_random_event(
     w.send(event, prio);
 }
 
-fn do_some_shit_before_physics(mut w: PriorityEventWriter<LuaEvent<mlua::Variadic<MyLuaArg>>>) {
-    info!("PrePhysics, firing:");
-
-    for _ in 0..5 {
-        // fire random event, for any of the system sets
-        fire_random_event(&mut w, &ALL_EVENTS);
-    }
-}
-
+/// physics stage logic, represents a bunch of systems sending events of various types and priorities
 fn do_physics(mut w: PriorityEventWriter<LuaEvent<mlua::Variadic<MyLuaArg>>>) {
     info!("Physics, firing:");
 
     for _ in 0..5 {
-        // fire random event, for any of the system sets
-        fire_random_event(&mut w, &ALL_EVENTS);
+        fire_random_event(&mut w);
     }
 }
 
+/// update stage logic, fired each frame, represents a bunch of systems sending events of various types and priorities
+/// we fire just one since we want to keep the output clean
 fn do_update(mut w: PriorityEventWriter<LuaEvent<mlua::Variadic<MyLuaArg>>>) {
     info!("Update, firing:");
 
-    // fire random event, for any of the system sets
-    fire_random_event(&mut w, &ALL_EVENTS);
+    fire_random_event(&mut w);
 }
 
-#[derive(Clone, Copy)]
-pub struct ScriptEventData(&'static str, u32);
-
-static ON_PRE_PHYSICS_ONE: ScriptEventData = ScriptEventData("on_pre_physics_one", 0);
-static ON_PRE_PHYSICS_TWO: ScriptEventData = ScriptEventData("on_pre_physics_two", 1);
-static ON_POST_PHYSICS_ONE: ScriptEventData = ScriptEventData("on_post_physics_one", 11);
-static ON_POST_PHYSICS_TWO: ScriptEventData = ScriptEventData("on_post_physics_two", 12);
-static ON_POST_UPDATE_ONE: ScriptEventData = ScriptEventData("on_post_update_one", 21);
-static ON_POST_UPDATE_TWO: ScriptEventData = ScriptEventData("on_post_update_two", 22);
-static ALL_EVENTS: [ScriptEventData; 6] = [
-    ON_PRE_PHYSICS_ONE,
-    ON_PRE_PHYSICS_TWO,
-    ON_POST_PHYSICS_ONE,
-    ON_POST_PHYSICS_TWO,
-    ON_POST_UPDATE_ONE,
-    ON_POST_UPDATE_TWO,
-];
+/// We will run this system at the end of each update to make the output easier to read
+fn print_frame_count(frame: Res<FrameCount>) {
+    info!("================ Frame no {} End ================", frame.0);
+}
 
 fn load_our_script(server: Res<AssetServer>, mut commands: Commands) {
     let path = "scripts/complex_game_loop.lua";
@@ -130,13 +86,13 @@ fn load_our_script(server: Res<AssetServer>, mut commands: Commands) {
     });
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, SystemSet)]
+#[derive(ScheduleLabel, Debug, Clone, PartialEq, Eq, Hash, SystemSet)]
 enum ComplexGameLoopSet {
-    PrePhysics,
     Physics,
     PrePhysicsScripts,
     PostPhysicsScripts,
     PostUpdateScripts,
+    EndFrame,
 }
 
 fn main() -> std::io::Result<()> {
@@ -144,58 +100,71 @@ fn main() -> std::io::Result<()> {
 
     let mut app = App::new();
 
+    // first let's configure the set orders:
+    // we run the pre-physics scripts before physics (duh)
+    // we run the post-physics scripts after physics
+    // we run the post-update scripts after post-update
+    // pretty straightforward, note we use FixedUpdate for physics, which means it runs less often than Update
     app.add_plugins(DefaultPlugins)
         .insert_resource(FixedTime::new_from_secs(TIMESTEP_2_PER_SECOND))
-        .add_plugin(ScriptingPlugin)
-        .add_startup_system(load_our_script)
-        // --- main systems sets
-        // physics logic system set (twice a second)
-        .configure_set(ComplexGameLoopSet::Physics.before(CoreSet::Update))
-        .add_system(
-            do_physics
-                .in_set(ComplexGameLoopSet::Physics)
-                .in_schedule(CoreSchedule::FixedUpdate),
+        .add_plugins(ScriptingPlugin)
+        .add_systems(Startup, load_our_script)
+        .configure_set(
+            FixedUpdate,
+            ComplexGameLoopSet::PrePhysicsScripts.before(ComplexGameLoopSet::Physics),
         )
-        // pre physics logic system set (twice a second)
-        .configure_set(ComplexGameLoopSet::PrePhysics.before(ComplexGameLoopSet::Physics))
-        .add_system(
-            do_some_shit_before_physics
-                .in_set(ComplexGameLoopSet::PrePhysics)
-                .in_schedule(CoreSchedule::FixedUpdate),
+        .configure_set(
+            FixedUpdate,
+            ComplexGameLoopSet::PostPhysicsScripts.after(ComplexGameLoopSet::Physics),
         )
+        .configure_set(
+            PostUpdate,
+            ComplexGameLoopSet::EndFrame.after(ComplexGameLoopSet::PostUpdateScripts),
+        );
+
+    // Now let's configure our game's main logic/engine systems
+    app.add_systems(FixedUpdate, do_physics.in_set(ComplexGameLoopSet::Physics))
         // main update logic system set (every frame)
-        .add_system(do_update)
+        .add_systems(Update, do_update)
+        .add_systems(
+            PostUpdate,
+            print_frame_count.in_set(ComplexGameLoopSet::EndFrame),
+        );
+
+    // Finally let's configure the scripting systems.
+    // Think of the priority value of events as their "order"
+    // Events with priority "1" go before events of priority "2"
+    app
         // --- script handler system sets
-        // pre_physics,     priority: [0,10] inclusive
-        .configure_set(ComplexGameLoopSet::PrePhysicsScripts.after(ComplexGameLoopSet::PrePhysics))
-        .add_system(
-            script_event_handler::<LuaScriptHost<mlua::Variadic<MyLuaArg>>, 0, 10>
-                .in_set(ComplexGameLoopSet::PrePhysicsScripts)
-                .in_schedule(CoreSchedule::FixedUpdate),
+        // pre_physics,     event priority: [0,10] inclusive
+        // handlers always ignore the events of lower priority than their range
+        // meaning this one will only handle pre_physics events
+        .add_script_handler_to_set::<LuaScriptHost<mlua::Variadic<MyLuaArg>>, 0, 10>(
+            FixedUpdate,
+            ComplexGameLoopSet::PrePhysicsScripts,
         )
-        // post_physics,    priority: [11,20] inclusive
-        // since the previous system will consume all events in the [0,10] range
-        .configure_set(ComplexGameLoopSet::PostPhysicsScripts.after(ComplexGameLoopSet::Physics))
-        .add_system(
-            script_event_handler::<LuaScriptHost<mlua::Variadic<MyLuaArg>>, 11, 20>
-                .in_set(ComplexGameLoopSet::PostPhysicsScripts)
-                .in_schedule(CoreSchedule::FixedUpdate),
+        // post_physics,    event priority: [11,20] inclusive
+        // This handler one will only ever handle post_physics events,
+        // events of higher priority [0-11] are discarded completely
+        // (the logic being: if we are at a point in time where we are handling post_physics events, we don't care about pre_physics events)
+        .add_script_handler_to_set::<LuaScriptHost<mlua::Variadic<MyLuaArg>>, 11, 20>(
+            FixedUpdate,
+            ComplexGameLoopSet::PostPhysicsScripts,
         )
         // post_update,     priority: [21,30] inclusive
-        // note we do not use the CoreSet version since our scripts might want
-        // to modify transforms etc which some core systems synchronise in here
-        .configure_set(ComplexGameLoopSet::PostUpdateScripts.in_base_set(CoreSet::PostUpdate))
-        .add_script_handler_to_set::<LuaScriptHost<mlua::Variadic<MyLuaArg>>, _, 21, 30>(
+        // similar to before, only post_update events are handled
+        .add_script_handler_to_set::<LuaScriptHost<mlua::Variadic<MyLuaArg>>, 21, 30>(
+            PostUpdate,
             ComplexGameLoopSet::PostUpdateScripts,
         )
-        // this system set handles addition and removal of script contexts, we can safely use `CoreSet::PostUpdate`
-        .add_script_host_to_base_set::<LuaScriptHost<mlua::Variadic<MyLuaArg>>, _>(
-            CoreSet::PostUpdate,
-        )
-        .add_api_provider::<LuaScriptHost<mlua::Variadic<MyLuaArg>>>(Box::new(LuaAPIProvider));
-    // We have 3 core systems
+        // finally we add core script host systems to PostUpdate
+        // these handle the scripts themselves i.e. add/remove/modify them when necessary
+        .add_script_host_to_set::<LuaScriptHost<mlua::Variadic<MyLuaArg>>>(
+            PostUpdate,
+            ComplexGameLoopSet::PostUpdateScripts,
+        );
+    // We have 2 core systems
 
-    // PrePhysics (twice per second), fires 5 random events
     // Physics (twice per second),    fires 5 random events
     // Update (every frame),          fires 1 random event
 
@@ -209,12 +178,15 @@ fn main() -> std::io::Result<()> {
     // when a handler encounters an event of higher priority outside its range, that event is discarded
     // when a handler encounters an event of lower priority outside its range, it's left in the queue
     // therefore
-    // in our case, PrePhysics systems can generate events which can be handled by post_update,
+    // in our case, Physics systems can generate events which can be handled by post_update,
     // but Update cannot send events which are handled by anything other than post_update
 
     // note that regardless of the order in which the events were spawned
     // priority decides the order in which they are executed
     // in case of identical priority, order is the tie-breaker (earlier events launch first)
+
+    // interestingly, because the Main bevy scheduler runs FixedUpdate systems *before* any Update systems, in this case
+    // on_pre_physics events will *never* be handled! (they are discarded by the post_physics handler, and the update system never runs before physics)
     app.run();
 
     Ok(())
diff --git a/examples/lua/console_integration.rs b/examples/lua/console_integration.rs
index c51faeec6e..248ae85a65 100644
--- a/examples/lua/console_integration.rs
+++ b/examples/lua/console_integration.rs
@@ -1,9 +1,9 @@
-use bevy::{ecs::event::Events, prelude::*};
+use bevy::{asset::ChangeWatcher, ecs::event::Events, prelude::*};
 use bevy_console::{AddConsoleCommand, ConsoleCommand, ConsolePlugin, PrintConsoleLine};
 use bevy_mod_scripting::prelude::*;
 use clap::Parser;
 
-use std::sync::Mutex;
+use std::{sync::Mutex, time::Duration};
 
 #[derive(Default)]
 pub struct LuaAPIProvider;
@@ -119,11 +119,6 @@ pub fn run_script_cmd(
     }
 }
 
-/// optional, hot reloading
-fn watch_assets(server: Res<AssetServer>) {
-    server.asset_io().watch_for_changes().unwrap();
-}
-
 pub fn delete_script_cmd(
     mut log: ConsoleCommand<DeleteScriptCmd>,
     mut scripts: Query<(Entity, &mut ScriptCollection<LuaFile>)>,
@@ -163,21 +158,23 @@ pub struct DeleteScriptCmd {
 
 fn main() -> std::io::Result<()> {
     let mut app = App::new();
-    app.add_plugins(DefaultPlugins)
-        .add_plugin(ScriptingPlugin)
-        .add_plugin(ConsolePlugin)
-        .add_startup_system(watch_assets)
-        // register bevy_console commands
-        .add_console_command::<RunScriptCmd, _>(run_script_cmd)
-        .add_console_command::<DeleteScriptCmd, _>(delete_script_cmd)
-        // choose and register the script hosts you want to use
-        .add_script_host_to_base_set::<LuaScriptHost<()>, _>(CoreSet::PostUpdate)
-        .add_api_provider::<LuaScriptHost<()>>(Box::new(LuaAPIProvider))
-        .add_api_provider::<LuaScriptHost<()>>(Box::new(LuaBevyAPIProvider))
-        .add_script_handler_to_base_set::<LuaScriptHost<()>, _, 0, 0>(CoreSet::PostUpdate)
-        // add your systems
-        .add_system(trigger_on_update_lua)
-        .add_system(forward_script_err_to_console);
+    app.add_plugins(DefaultPlugins.set(AssetPlugin {
+        watch_for_changes: ChangeWatcher::with_delay(Duration::from_secs(0)),
+        ..Default::default()
+    }))
+    .add_plugins(ScriptingPlugin)
+    .add_plugins(ConsolePlugin)
+    // register bevy_console commands
+    .add_console_command::<RunScriptCmd, _>(run_script_cmd)
+    .add_console_command::<DeleteScriptCmd, _>(delete_script_cmd)
+    // choose and register the script hosts you want to use
+    .add_script_host::<LuaScriptHost<()>>(PostUpdate)
+    .add_api_provider::<LuaScriptHost<()>>(Box::new(LuaAPIProvider))
+    .add_api_provider::<LuaScriptHost<()>>(Box::new(LuaBevyAPIProvider))
+    .add_script_handler::<LuaScriptHost<()>, 0, 0>(PostUpdate)
+    // add your systems
+    .add_systems(Update, trigger_on_update_lua)
+    .add_systems(Update, forward_script_err_to_console);
 
     info!("press '~' to open the console. Type in `run_script \"console_integration.lua\"` to run example script!");
     app.run();
diff --git a/examples/lua/coroutines.rs b/examples/lua/coroutines.rs
index 14af196ab8..1d286c5ba6 100644
--- a/examples/lua/coroutines.rs
+++ b/examples/lua/coroutines.rs
@@ -1,18 +1,16 @@
-use bevy::prelude::*;
+use std::time::Duration;
+
+use bevy::{asset::ChangeWatcher, prelude::*};
 use bevy_mod_scripting::prelude::*;
 
 /// fire on_update
-fn do_update(mut w: PriorityEventWriter<LuaEvent<()>>, time: Res<Time>) {
+fn do_update(mut w: PriorityEventWriter<LuaEvent<()>>) {
     let event = LuaEvent {
         hook_name: "on_update".to_owned(),
         args: (),
         recipients: Recipients::All,
     };
-    info!(
-        "\t - event: {}, time: {:?}",
-        event.hook_name,
-        (time.startup() + time.elapsed())
-    );
+
     w.send(event, 0);
 }
 
@@ -29,15 +27,18 @@ fn load_our_scripts(server: Res<AssetServer>, mut commands: Commands) {
 fn main() -> std::io::Result<()> {
     let mut app = App::new();
 
-    app.add_plugins(DefaultPlugins)
-        .add_plugin(ScriptingPlugin)
-        .add_startup_system(load_our_scripts)
-        // randomly fire events for either all scripts,
-        // the script with id 0
-        // or the script with id 1
-        .add_system(do_update)
-        .add_script_handler_to_base_set::<LuaScriptHost<()>, _, 0, 0>(CoreSet::PostUpdate)
-        .add_script_host_to_base_set::<LuaScriptHost<()>, _>(CoreSet::PostUpdate);
+    app.add_plugins(DefaultPlugins.set(AssetPlugin {
+        watch_for_changes: ChangeWatcher::with_delay(Duration::from_secs(0)),
+        ..Default::default()
+    }))
+    .add_plugins(ScriptingPlugin)
+    .add_systems(Startup, load_our_scripts)
+    // randomly fire events for either all scripts,
+    // the script with id 0
+    // or the script with id 1
+    .add_systems(Update, do_update)
+    .add_script_handler::<LuaScriptHost<()>, 0, 0>(PostUpdate)
+    .add_script_host::<LuaScriptHost<()>>(PostUpdate);
     app.run();
 
     Ok(())
diff --git a/examples/lua/documentation_gen.rs b/examples/lua/documentation_gen.rs
index f858c514ce..bbf4d9dcc8 100644
--- a/examples/lua/documentation_gen.rs
+++ b/examples/lua/documentation_gen.rs
@@ -1,11 +1,11 @@
-use bevy::prelude::*;
+use bevy::{asset::ChangeWatcher, prelude::*};
 
 use bevy_mod_scripting::{
     api::{impl_tealr_type, lua::bevy::LuaBevyAPIProvider},
     prelude::*,
 };
 
-use std::sync::Mutex;
+use std::{sync::Mutex, time::Duration};
 
 #[derive(Clone)]
 pub struct MyLuaArg;
@@ -95,19 +95,22 @@ impl APIProvider for LuaAPIProvider {
 fn main() -> std::io::Result<()> {
     let mut app = App::new();
 
-    app.add_plugins(DefaultPlugins)
-        .add_plugin(ScriptingPlugin)
-        // add the providers and script host
-        .add_script_host_to_base_set::<LuaScriptHost<MyLuaArg>, _>(CoreSet::PostUpdate)
-        .add_api_provider::<LuaScriptHost<MyLuaArg>>(Box::new(LuaAPIProvider))
-        .add_api_provider::<LuaScriptHost<MyLuaArg>>(Box::new(LuaBevyAPIProvider))
-        // this needs to be placed after any `add_api_provider` and `add_script_host` calls
-        // it will generate `doc` and `types` folders under `assets/scripts` containing the documentation and teal declaration files
-        // respectively. See example asset folder to see how they look like. The `teal_file.tl` script in example assets shows the usage of one of those
-        // declaration files, use the teal vscode extension to explore the type hints!
-        // Note: This is a noop in optimized builds unless the `doc_always` feature is enabled!
-        .update_documentation::<LuaScriptHost<MyLuaArg>>()
-        .add_script_handler_to_base_set::<LuaScriptHost<MyLuaArg>, _, 0, 0>(CoreSet::PostUpdate);
+    app.add_plugins(DefaultPlugins.set(AssetPlugin {
+        watch_for_changes: ChangeWatcher::with_delay(Duration::from_secs(0)),
+        ..Default::default()
+    }))
+    .add_plugins(ScriptingPlugin)
+    // add the providers and script host
+    .add_script_host::<LuaScriptHost<MyLuaArg>>(PostUpdate)
+    .add_api_provider::<LuaScriptHost<MyLuaArg>>(Box::new(LuaAPIProvider))
+    .add_api_provider::<LuaScriptHost<MyLuaArg>>(Box::new(LuaBevyAPIProvider))
+    // this needs to be placed after any `add_api_provider` and `add_script_host` calls
+    // it will generate `doc` and `types` folders under `assets/scripts` containing the documentation and teal declaration files
+    // respectively. See example asset folder to see how they look like. The `teal_file.tl` script in example assets shows the usage of one of those
+    // declaration files, use the teal vscode extension to explore the type hints!
+    // Note: This is a noop in optimized builds unless the `doc_always` feature is enabled!
+    .update_documentation::<LuaScriptHost<MyLuaArg>>()
+    .add_script_handler::<LuaScriptHost<MyLuaArg>, 0, 0>(PostUpdate);
 
     // app.run(); no need, documentation gets generated before the app even starts
 
diff --git a/examples/lua/event_recipients.rs b/examples/lua/event_recipients.rs
index d8b2b62354..1c65e47a83 100644
--- a/examples/lua/event_recipients.rs
+++ b/examples/lua/event_recipients.rs
@@ -1,8 +1,10 @@
+use bevy::asset::ChangeWatcher;
 use bevy::prelude::*;
 use bevy_mod_scripting::prelude::*;
 use rand::prelude::SliceRandom;
 use std::sync::atomic::Ordering::Relaxed;
 use std::sync::{atomic::AtomicU32, Mutex};
+use std::time::Duration;
 
 #[derive(Clone)]
 pub struct MyLuaArg(usize);
@@ -118,16 +120,19 @@ fn load_our_scripts(server: Res<AssetServer>, mut commands: Commands) {
 fn main() -> std::io::Result<()> {
     let mut app = App::new();
 
-    app.add_plugins(DefaultPlugins)
-        .add_plugin(ScriptingPlugin)
-        .add_startup_system(load_our_scripts)
-        // randomly fire events for either all scripts,
-        // the script with id 0
-        // or the script with id 1
-        .add_system(do_update)
-        .add_script_handler_to_base_set::<LuaScriptHost<MyLuaArg>, _, 0, 0>(CoreSet::PostUpdate)
-        .add_script_host_to_base_set::<LuaScriptHost<MyLuaArg>, _>(CoreSet::PostUpdate)
-        .add_api_provider::<LuaScriptHost<MyLuaArg>>(Box::new(LuaAPIProvider));
+    app.add_plugins(DefaultPlugins.set(AssetPlugin {
+        watch_for_changes: ChangeWatcher::with_delay(Duration::from_secs(0)),
+        ..Default::default()
+    }))
+    .add_plugins(ScriptingPlugin)
+    .add_systems(Startup, load_our_scripts)
+    // randomly fire events for either all scripts,
+    // the script with id 0
+    // or the script with id 1
+    .add_systems(Update, do_update)
+    .add_script_handler::<LuaScriptHost<MyLuaArg>, 0, 0>(PostUpdate)
+    .add_script_host::<LuaScriptHost<MyLuaArg>>(PostUpdate)
+    .add_api_provider::<LuaScriptHost<MyLuaArg>>(Box::new(LuaAPIProvider));
     app.run();
 
     Ok(())
diff --git a/examples/lua/game_of_life.rs b/examples/lua/game_of_life.rs
index 3fc96d2259..5bee2236d2 100644
--- a/examples/lua/game_of_life.rs
+++ b/examples/lua/game_of_life.rs
@@ -1,6 +1,7 @@
-use std::{borrow::Cow, sync::Mutex};
+use std::{borrow::Cow, sync::Mutex, time::Duration};
 
 use bevy::{
+    asset::ChangeWatcher,
     diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
     prelude::*,
     reflect::Reflect,
@@ -209,53 +210,31 @@ pub fn send_init(mut events: PriorityEventWriter<LuaEvent<()>>) {
     )
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, SystemSet)]
-pub enum LifeSystemSets {
-    Scripts,
-}
-
 /// how often to step the simulation
 const UPDATE_FREQUENCY: f32 = 1.0 / 20.0;
 
 fn main() -> std::io::Result<()> {
     let mut app = App::new();
 
-    app.add_plugins(DefaultPlugins)
-        .insert_resource(FixedTime::new_from_secs(UPDATE_FREQUENCY))
-        .add_plugin(LogDiagnosticsPlugin::default())
-        .add_plugin(FrameTimeDiagnosticsPlugin::default())
-        .add_plugin(ScriptingPlugin)
-        .init_resource::<Settings>()
-        .add_startup_system(setup)
-        .add_startup_system(send_init)
-        .add_system(sync_window_size)
-        .add_startup_system(|asset_server: ResMut<AssetServer>| {
-            asset_server.asset_io().watch_for_changes().unwrap()
-        })
-        .add_system(
-            update_rendered_state
-                .after(sync_window_size)
-                .in_schedule(CoreSchedule::FixedUpdate),
-        )
-        .add_system(
-            send_on_update
-                .after(update_rendered_state)
-                .in_schedule(CoreSchedule::FixedUpdate),
-        )
-        .configure_set(
-            LifeSystemSets::Scripts
-                .after(CoreSet::UpdateFlush)
-                .before(CoreSet::PostUpdate),
-        )
-        .add_system(
-            script_event_handler::<LuaScriptHost<()>, 0, 1>
-                .in_set(LifeSystemSets::Scripts)
-                .in_schedule(CoreSchedule::FixedUpdate),
-        )
-        .add_script_host_to_base_set::<LuaScriptHost<()>, _>(CoreSet::PostUpdate)
-        .add_api_provider::<LuaScriptHost<()>>(Box::new(LuaBevyAPIProvider))
-        .add_api_provider::<LuaScriptHost<()>>(Box::new(LifeAPI))
-        .update_documentation::<LuaScriptHost<()>>();
+    app.add_plugins(DefaultPlugins.set(AssetPlugin {
+        watch_for_changes: ChangeWatcher::with_delay(Duration::from_secs(0)),
+        ..Default::default()
+    }))
+    .insert_resource(FixedTime::new_from_secs(UPDATE_FREQUENCY))
+    .add_plugins(LogDiagnosticsPlugin::default())
+    .add_plugins(FrameTimeDiagnosticsPlugin)
+    .add_plugins(ScriptingPlugin)
+    .init_resource::<Settings>()
+    .add_systems(Startup, setup)
+    .add_systems(Startup, send_init)
+    .add_systems(Update, sync_window_size)
+    .add_systems(FixedUpdate, update_rendered_state.after(sync_window_size))
+    .add_systems(FixedUpdate, send_on_update.after(update_rendered_state))
+    .add_systems(FixedUpdate, script_event_handler::<LuaScriptHost<()>, 0, 1>)
+    .add_script_host::<LuaScriptHost<()>>(PostUpdate)
+    .add_api_provider::<LuaScriptHost<()>>(Box::new(LuaBevyAPIProvider))
+    .add_api_provider::<LuaScriptHost<()>>(Box::new(LifeAPI))
+    .update_documentation::<LuaScriptHost<()>>();
 
     app.run();
 
diff --git a/examples/rhai/bevy_api.rs b/examples/rhai/bevy_api.rs
index 0b7cbd7078..b7ada4505e 100644
--- a/examples/rhai/bevy_api.rs
+++ b/examples/rhai/bevy_api.rs
@@ -1,36 +1,19 @@
 use bevy::app::AppExit;
-use bevy::math::DQuat;
+
 use bevy::prelude::*;
 use bevy_mod_scripting::{api::rhai::bevy::RhaiBevyAPIProvider, prelude::*};
 use bevy_mod_scripting_rhai::rhai::Engine;
 use bevy_script_api::rhai::{std::RegisterVecType, RegisterForeignRhaiType};
 
-/// Let's define a resource, we want it to be "assignable" via lua so we derive `ReflectLuaProxyable`
-/// This allows us to reach this value when it's a field under any other Reflectable type
-
-#[derive(Resource, Default, Clone, Reflect)]
-#[reflect(Resource)]
-pub struct MyResource {
-    pub thing: f64,
-}
-
 #[derive(Component, Default, Reflect)]
 #[reflect(Component)]
 pub struct MyComponent {
-    dquat: DQuat,
     quat: Quat,
     vec2: Vec2,
-    vec3: Vec3,
-    uvec2: UVec2,
     usize: usize,
     f32: f32,
     mat3: Mat3,
-    vec4: Vec4,
-    bool: bool,
-    string: String,
-    u8: u8,
-    bool_option: Option<bool>,
-    option: Option<Vec3>,
+    option_vec3: Option<Vec3>,
     vec_of_option_bools: Vec<Option<bool>>,
     option_vec_of_bools: Option<Vec<bool>>,
 }
@@ -58,27 +41,22 @@ fn main() -> std::io::Result<()> {
     let mut app = App::new();
 
     app.add_plugins(DefaultPlugins)
-        .add_plugin(ScriptingPlugin)
+        .add_plugins(ScriptingPlugin)
         .register_type::<MyComponent>()
-        .register_type::<MyResource>()
         .register_foreign_rhai_type::<Option<bool>>()
         .register_foreign_rhai_type::<Vec<Option<bool>>>()
         .register_foreign_rhai_type::<Option<Vec<bool>>>()
         // note the implementation for Option is there, but we must register `LuaProxyable` for it
-        .init_resource::<MyResource>()
         // this system set handles addition and removal of script contexts, we can safely use `CoreSet::PostUpdate`
-        .add_script_host_to_base_set::<RhaiScriptHost<()>, _>(CoreSet::PostUpdate)
+        .add_script_host::<RhaiScriptHost<()>>(PostUpdate)
         .add_api_provider::<RhaiScriptHost<()>>(Box::new(RhaiBevyAPIProvider))
         .add_api_provider::<RhaiScriptHost<()>>(Box::new(MyAPIProvider))
-        .add_system(|world: &mut World| {
+        .add_systems(Update, |world: &mut World| {
             let entity = world
                 .spawn(())
                 .insert(MyComponent {
-                    vec2: Vec2::new(1.0, 2.0),
-                    vec3: Vec3::new(1.0, 2.0, 3.0),
-                    vec4: Vec4::new(1.0, 2.0, 3.0, 4.0),
-                    uvec2: UVec2::new(1, 2),
                     usize: 5,
+                    vec2: Vec2::new(1.0, 2.0),
                     f32: 6.7,
                     mat3: Mat3::from_cols(
                         Vec3::new(1.0, 2.0, 3.0),
@@ -86,12 +64,7 @@ fn main() -> std::io::Result<()> {
                         Vec3::new(7.0, 8.0, 9.0),
                     ),
                     quat: Quat::from_xyzw(1.0, 2.0, 3.0, 4.0),
-                    dquat: DQuat::from_xyzw(1.0, 2.0, 3.0, 4.0),
-                    bool: true,
-                    string: "hello".to_owned(),
-                    u8: 240,
-                    bool_option: Some(true),
-                    option: None,
+                    option_vec3: Some(Vec3::new(1.0, 2.0, 3.0)),
                     vec_of_option_bools: vec![Some(true), None, Some(false)],
                     option_vec_of_bools: Some(vec![true, true, true]),
                 })
@@ -103,53 +76,90 @@ fn main() -> std::io::Result<()> {
                     r#"
                         fn once() {
                             print(world);
-                            print(world.get_children(entity));
+                            debug(world.get_children(entity));
 
+                            // we first retrieve ID's for our component and resource by their short name (long name/full path also work)
                             let my_component_type = world.get_type_by_name("MyComponent");
-                            let my_component = world.get_component(entity,my_component_type);
-
-                            debug(my_component_type);
-                            debug(my_component);
-                            print(my_component.u8);
-                            my_component.u8 = 255; 
-                            my_component.bool = false;
-                            my_component.string = "bye";
-                            my_component.bool_option = ();
-                            print(my_component.u8);
-                            print(my_component.bool);
-                            print(my_component.string);
-                            print(my_component.bool_option);
-                            my_component.bool_option = true;
-                            print(my_component.bool_option);
+
+                            // then ask the world to give us a reference to `MyComponent` on the entity we just spawned
+                            // resources work the same way, but we use `get_resource` instead of `get_component`
+                            // the comp object is resolved to a `bevy_script_api::script_ref::ReflectValue`.
+                            // we can use a custom proxy instead (by implementing RhaiProxyable), but this is the simplest way to get started.
+                            let comp = world.get_component(entity,my_component_type);
+
+                            print("Before script: " + comp);
+
+                            print("=============");
+
+                            comp.usize = 2;
+                            print("comp.usize: after assigning to 2: " + comp.usize);
+
+                            // not supported yet (no Bevy proxies yet)
+                            // print("comp.option_vec3 before: " + comp.option_vec3);
+                            // comp.option_vec3 = Vec3::new(2,1,3);
+                            // print("comp.option_vec3 after: " + comp.option_vec3);
                             
-                            print("----");
+                            // print("comp.option_vec3[0] before: " + comp.option_vec3[0]);
+                            // comp.option_vec3[1] = 5;
+                            // print("comp.option_vec3[0] after: " + comp.option_vec3[0]);
+
+                            print("=============");
 
-                            for e in my_component.vec_of_option_bools {
-                                print(`elem: ${e}`)
+                            print("comp.vec_of_option_bools before: " + comp.vec_of_option_bools);
+                            comp.vec_of_option_bools = [true,false,true];
+                            print("comp.vec_of_option_bools after: " + comp.vec_of_option_bools);
+
+                            print("comp.vec_of_option_bools[0] before: " + comp.vec_of_option_bools[0]);
+                            comp.vec_of_option_bools[0] = false;
+                            print("comp.vec_of_option_bools[0] after: " + comp.vec_of_option_bools[0]);
+
+                            print("comp.vec_of_option_bools before insert: " + comp.vec_of_option_bools);
+                            comp.vec_of_option_bools.insert(1,());
+                            print("comp.vec_of_option_bools after insert: " + comp.vec_of_option_bools);
+
+                            print("comp.vec_of_option_bools before push: " + comp.vec_of_option_bools);
+                            comp.vec_of_option_bools.push(false);
+                            print("comp.vec_of_option_bools after push: " + comp.vec_of_option_bools);
+
+                            print("comp.vec_of_option_bools len after push: " + comp.vec_of_option_bools.len());
+
+                            print("comp.vec_of_option_bools before pop: " + comp.vec_of_option_bools);
+                            print(comp.vec_of_option_bools.pop());
+                            print("comp.vec_of_option_bools after pop: " + comp.vec_of_option_bools);
+
+                            print("the elements inside comp.vec_of_option_bools: ");
+                            for e in comp.vec_of_option_bools {
+                                print(`elem: ${e}`);
                             }
-                            
-                            print("----");
 
-                            my_component.vec_of_option_bools = [true,false,true];
-                            my_component.vec_of_option_bools[0] = false;
-                            my_component.vec_of_option_bools.insert(1,());
-                            my_component.vec_of_option_bools.push(false);
+                            comp.vec_of_option_bools.clear();
+                            print("comp.vec_of_option_bools after clear: " + comp.vec_of_option_bools);
+                            print("comp.vec_of_option_bools len after clear: " + comp.vec_of_option_bools.len());
+
+                            print("=============");
+
+                            print("comp.option_vec_of_bools before: " + comp.option_vec_of_bools);
+                            print(comp.option_vec_of_bools.pop());
+                            print("comp.option_vec_of_bools after pop: " + comp.option_vec_of_bools);
+                            
+                            print("comp.option_vec_of_bools len after pop: " + comp.option_vec_of_bools.len());
 
-                            for e in my_component.vec_of_option_bools {
-                                print(`elem: ${e}`)
+                            print("the elements inside comp.option_vec_of_bools: ");
+                            for e in comp.option_vec_of_bools {
+                                print(`elem: ${e}`);
                             }
 
-                            let my_component_after = world.get_component(entity,my_component_type);
+                            print("=============");
+
+
+                            let comp_after = world.get_component(entity, my_component_type);
                             print("after script:");
-                            print(my_component_after.u8);
-                            print(my_component_after.bool);
-                            print(my_component_after.string);
-                            print(my_component_after.bool_option);
+                            print(comp_after);
 
                         }
                         "#
                     .as_bytes(),
-                    "script.lua",
+                    "script.rhai",
                     entity,
                     world,
                     RhaiEvent {
diff --git a/examples/rhai/console_integration.rs b/examples/rhai/console_integration.rs
index 162704fb6b..de657844a4 100644
--- a/examples/rhai/console_integration.rs
+++ b/examples/rhai/console_integration.rs
@@ -1,4 +1,6 @@
-use bevy::{ecs::event::Events, prelude::*};
+use std::time::Duration;
+
+use bevy::{asset::ChangeWatcher, ecs::event::Events, prelude::*};
 use bevy_console::{AddConsoleCommand, ConsoleCommand, ConsolePlugin, PrintConsoleLine};
 use bevy_mod_scripting::prelude::*;
 use bevy_script_api::common::bevy::ScriptWorld;
@@ -112,11 +114,6 @@ pub fn run_script_cmd(
     }
 }
 
-// optional, hot reloading
-fn watch_assets(server: Res<AssetServer>) {
-    server.asset_io().watch_for_changes().unwrap();
-}
-
 pub fn delete_script_cmd(
     mut log: ConsoleCommand<DeleteScriptCmd>,
     mut scripts: Query<(Entity, &mut ScriptCollection<RhaiFile>)>,
@@ -156,21 +153,23 @@ pub struct DeleteScriptCmd {
 
 fn main() -> std::io::Result<()> {
     let mut app = App::new();
-    app.add_plugins(DefaultPlugins)
-        .add_plugin(ScriptingPlugin)
-        .add_plugin(ConsolePlugin)
-        .add_startup_system(watch_assets)
-        // register bevy_console commands
-        .add_console_command::<RunScriptCmd, _>(run_script_cmd)
-        .add_console_command::<DeleteScriptCmd, _>(delete_script_cmd)
-        // choose and register the script hosts you want to use
-        .add_script_host_to_base_set::<RhaiScriptHost<()>, _>(CoreSet::PostUpdate)
-        .add_api_provider::<RhaiScriptHost<()>>(Box::new(RhaiAPI))
-        .add_api_provider::<RhaiScriptHost<()>>(Box::new(RhaiBevyAPIProvider))
-        .add_script_handler_to_base_set::<RhaiScriptHost<()>, _, 0, 0>(CoreSet::PostUpdate)
-        // add your systems
-        .add_system(trigger_on_update_rhai)
-        .add_system(forward_script_err_to_console);
+    app.add_plugins(DefaultPlugins.set(AssetPlugin {
+        watch_for_changes: ChangeWatcher::with_delay(Duration::from_secs(0)),
+        ..Default::default()
+    }))
+    .add_plugins(ScriptingPlugin)
+    .add_plugins(ConsolePlugin)
+    // register bevy_console commands
+    .add_console_command::<RunScriptCmd, _>(run_script_cmd)
+    .add_console_command::<DeleteScriptCmd, _>(delete_script_cmd)
+    // choose and register the script hosts you want to use
+    .add_script_host::<RhaiScriptHost<()>>(PostUpdate)
+    .add_api_provider::<RhaiScriptHost<()>>(Box::new(RhaiAPI))
+    .add_api_provider::<RhaiScriptHost<()>>(Box::new(RhaiBevyAPIProvider))
+    .add_script_handler::<RhaiScriptHost<()>, 0, 0>(PostUpdate)
+    // add your systems
+    .add_systems(Update, trigger_on_update_rhai)
+    .add_systems(Update, forward_script_err_to_console);
 
     info!("press '~' to open the console. Type in `run_script \"console_integration.rhai\"` to run example script!");
 
diff --git a/examples/rhai/game_of_life.rs b/examples/rhai/game_of_life.rs
index 7ddb3f852d..4f995f0b9b 100644
--- a/examples/rhai/game_of_life.rs
+++ b/examples/rhai/game_of_life.rs
@@ -1,4 +1,7 @@
+use std::time::Duration;
+
 use bevy::{
+    asset::ChangeWatcher,
     diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
     prelude::*,
     reflect::Reflect,
@@ -194,48 +197,33 @@ pub fn send_init(mut events: PriorityEventWriter<RhaiEvent<()>>) {
     )
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, SystemSet)]
-pub enum LifeSystemSets {
-    Scripts,
-}
-
 /// how often to step the simulation
 const UPDATE_FREQUENCY: f32 = 1.0 / 30.0;
 
 fn main() -> std::io::Result<()> {
     let mut app = App::new();
 
-    app.add_plugins(DefaultPlugins)
-        .insert_resource(FixedTime::new_from_secs(UPDATE_FREQUENCY))
-        .add_plugin(LogDiagnosticsPlugin::default())
-        .add_plugin(FrameTimeDiagnosticsPlugin::default())
-        .add_plugin(ScriptingPlugin)
-        .init_resource::<Settings>()
-        .add_startup_system(setup)
-        .add_startup_system(send_init)
-        .add_startup_system(|asset_server: ResMut<AssetServer>| {
-            asset_server.asset_io().watch_for_changes().unwrap()
-        })
-        .add_system(sync_window_size)
-        .add_systems(
-            (update_rendered_state, send_on_update)
-                .chain()
-                .in_schedule(CoreSchedule::FixedUpdate),
-        )
-        .configure_set(
-            LifeSystemSets::Scripts
-                .after(CoreSet::UpdateFlush)
-                .before(CoreSet::PostUpdate),
-        )
-        .add_system(
-            script_event_handler::<RhaiScriptHost<()>, 0, 1>
-                .in_set(LifeSystemSets::Scripts)
-                .in_schedule(CoreSchedule::FixedUpdate),
-        )
-        .add_script_host_to_base_set::<RhaiScriptHost<()>, _>(CoreSet::PostUpdate)
-        .add_api_provider::<RhaiScriptHost<()>>(Box::new(RhaiBevyAPIProvider))
-        .add_api_provider::<RhaiScriptHost<()>>(Box::new(LifeAPI))
-        .update_documentation::<RhaiScriptHost<()>>();
+    app.add_plugins(DefaultPlugins.set(AssetPlugin {
+        watch_for_changes: ChangeWatcher::with_delay(Duration::from_secs(0)),
+        ..Default::default()
+    }))
+    .insert_resource(FixedTime::new_from_secs(UPDATE_FREQUENCY))
+    .add_plugins(LogDiagnosticsPlugin::default())
+    .add_plugins(FrameTimeDiagnosticsPlugin)
+    .add_plugins(ScriptingPlugin)
+    .init_resource::<Settings>()
+    .add_systems(Startup, setup)
+    .add_systems(Startup, send_init)
+    .add_systems(Update, sync_window_size)
+    .add_systems(FixedUpdate, (update_rendered_state, send_on_update).chain())
+    .add_systems(
+        FixedUpdate,
+        script_event_handler::<RhaiScriptHost<()>, 0, 1>,
+    )
+    .add_script_host::<RhaiScriptHost<()>>(PostUpdate)
+    .add_api_provider::<RhaiScriptHost<()>>(Box::new(RhaiBevyAPIProvider))
+    .add_api_provider::<RhaiScriptHost<()>>(Box::new(LifeAPI))
+    .update_documentation::<RhaiScriptHost<()>>();
 
     app.run();
 
diff --git a/examples/wrappers.rs b/examples/wrappers.rs
index 6b086f2bf7..fe10026255 100644
--- a/examples/wrappers.rs
+++ b/examples/wrappers.rs
@@ -1,7 +1,7 @@
 use bevy::{app::AppExit, prelude::*};
 
 use bevy_mod_scripting::{
-    api::{impl_lua_newtype, impl_script_newtype, lua::bevy::LuaWorld, ScriptRef},
+    api::{impl_lua_newtype, impl_script_newtype},
     prelude::*,
 };
 
@@ -13,7 +13,7 @@ use bevy_mod_scripting::{
 // Even though we are implementing Clone we are still able to reference the original data in script thanks to the script wrapper we are about to implement
 // Debug is nice to have, we can forward that implementation to Lua's ToString via our macro
 #[derive(Resource, Reflect, Default, Clone, Debug)]
-#[reflect(Resource)]
+#[reflect(Resource, LuaProxyable)]
 pub struct MyThing {
     usize: usize,
     string: String,
@@ -25,9 +25,6 @@ impl MyThing {
     }
 }
 
-impl MyThing {
-    pub fn hello(&self) {}
-}
 // Step 2. Script representation
 // this macro does some magic and provides you with a `LuaMyThing` (and possibly more for other enabled languages) type with which you can create:
 // - owned values of your type via ::new()
@@ -36,7 +33,7 @@ impl MyThing {
 // Script references can also be made to subfields (even non reflectable ones) of types via sub reflection
 //
 // Note: this step is not fully necessary, if your value is reflectable, you'll be able to reach it via
-// The bevy API, however doing this means your provide static typing for your scripts in languages which support it,
+// The bevy API, however doing this means your type will have `pass-by-reference` semantics and if the language supports it, static typing.
 // To see what else this macro can do see `src/api/generated.rs`
 impl_script_newtype!(
     #[languages(lua)]
@@ -62,19 +59,8 @@ impl_script_newtype!(
         // below is a custom lua function
         // the fn here means this is a function and not a method (no self argument)
         // normally you'd make these available globally via mlua::create_proxy, but I digress.
-        fn "make_ref_to_my_resource" => |ctx,()| {
-            let globals = ctx.globals();
-            let lua_world : LuaWorld = globals.get("world")?;
-            let mut world = lua_world.write();
-
-            let reflect_resource_data = world.resource_scope(|world, type_registry: Mut<AppTypeRegistry>| {
-                let type_registry = type_registry.read();
-                let data = type_registry.get_type_data::<ReflectResource>(std::any::TypeId::of::<MyThing>()).expect("Type not registered properly");
-                data.clone()
-            });
-
-            // this is absolutely safe!
-            Ok(LuaMyThing::new_ref(ScriptRef::new_resource_ref(reflect_resource_data, lua_world.as_ref().clone())))
+        fn "my_raw_function" => |ctx,()| {
+            Ok("Hello from my_raw_function!".to_owned())
         };
     }
 
@@ -84,11 +70,12 @@ fn main() -> std::io::Result<()> {
     let mut app = App::new();
 
     app.add_plugins(DefaultPlugins)
-        .add_plugin(ScriptingPlugin)
-        .add_script_host_to_base_set::<LuaScriptHost<LuaMyThing>, _>(CoreSet::PostUpdate)
+        .add_plugins(ScriptingPlugin)
         .register_type::<MyThing>()
         .init_resource::<MyThing>()
-        .add_system(|world: &mut World| {
+        .add_script_host::<LuaScriptHost<LuaMyThing>>(PostUpdate)
+        .add_api_provider::<LuaScriptHost<LuaMyThing>>(Box::new(LuaBevyAPIProvider))
+        .add_systems(Update, |world: &mut World| {
             world.insert_resource(MyThing {
                 usize: 420,
                 string: "I live in the bevy world, you can't touch me!".to_owned(),
@@ -98,17 +85,22 @@ fn main() -> std::io::Result<()> {
             world.resource_scope(|world, mut host: Mut<LuaScriptHost<LuaMyThing>>| {
                 host.run_one_shot(
                     r#"
-                    function once(my_thing)
-                        local my_thing2 = my_thing.make_ref_to_my_resource()
-                        print(my_thing2)
-                        print(my_thing2.usize)
-                        print(my_thing2.string)
-                        print(my_thing2:do_something_cool())
-
-                        my_thing2.usize = my_thing.usize
-                        my_thing2.string = my_thing.string
-
-                        print(my_thing2:do_something_cool())
+                    function once(new_my_thing)
+                        local my_thing_type = world:get_type_by_name("MyThing");
+                        print(my_thing_type)
+                        local my_thing = world:get_resource(my_thing_type);
+
+                        print("my_thing: ", my_thing)
+                        print("my_thing.usize: ", my_thing.usize)
+                        print("my_thing.string: ", my_thing.string)
+                        print("my_thing:do_something_cool(): ", my_thing:do_something_cool())
+                        print("my_thing.my_raw_function(): ", my_thing.my_raw_function())
+                        print("changing my thing through the world reference")
+
+                        my_thing.usize = new_my_thing.usize
+                        my_thing.string = new_my_thing.string
+
+                        print("my_thing.do_something_cool(): ", my_thing:do_something_cool())
                     end
                 "#
                     .as_bytes(),
diff --git a/languages/bevy_mod_scripting_lua/Cargo.toml b/languages/bevy_mod_scripting_lua/Cargo.toml
index b33ac90fb2..f8be84efda 100644
--- a/languages/bevy_mod_scripting_lua/Cargo.toml
+++ b/languages/bevy_mod_scripting_lua/Cargo.toml
@@ -43,7 +43,7 @@ name="bevy_mod_scripting_lua"
 path="src/lib.rs"
 
 [dependencies]
-bevy= { version = "0.10.1", default-features = false}
+bevy= { version = "0.11", default-features = false}
 bevy_mod_scripting_core = {path="../../bevy_mod_scripting_core", version = "0.3.0" }
 tealr = { version = "=0.9.0-alpha4", features=["mlua_vendored","mlua_send"]}
 parking_lot = "0.12.1"
diff --git a/languages/bevy_mod_scripting_lua/src/assets.rs b/languages/bevy_mod_scripting_lua/src/assets.rs
index 9b6ac088f7..5ebfadb59d 100644
--- a/languages/bevy_mod_scripting_lua/src/assets.rs
+++ b/languages/bevy_mod_scripting_lua/src/assets.rs
@@ -1,12 +1,12 @@
 use bevy::{
     asset::{AssetLoader, Error, LoadedAsset},
-    reflect::TypeUuid,
+    reflect::{TypePath, TypeUuid},
 };
 use bevy_mod_scripting_core::asset::CodeAsset;
 
 use std::sync::Arc;
 
-#[derive(Debug, TypeUuid)]
+#[derive(Debug, TypeUuid, TypePath)]
 #[uuid = "39cadc56-aa9c-4543-8640-a018b74b5052"]
 /// A lua code file in bytes
 pub struct LuaFile {
diff --git a/languages/bevy_mod_scripting_lua/src/lib.rs b/languages/bevy_mod_scripting_lua/src/lib.rs
index 601b5ad88b..f75dd7fd80 100644
--- a/languages/bevy_mod_scripting_lua/src/lib.rs
+++ b/languages/bevy_mod_scripting_lua/src/lib.rs
@@ -2,10 +2,7 @@ use crate::{
     assets::{LuaFile, LuaLoader},
     docs::LuaDocFragment,
 };
-use bevy::{
-    ecs::schedule::{BaseSystemSet, FreeSystemSet},
-    prelude::*,
-};
+use bevy::{ecs::schedule::ScheduleLabel, prelude::*};
 use bevy_mod_scripting_core::{prelude::*, systems::*, world::WorldPointer};
 
 use std::fmt;
@@ -36,7 +33,7 @@ pub trait LuaArg: for<'lua> ToLuaMulti<'lua> + Clone + Sync + Send + 'static {}
 
 impl<T: for<'lua> ToLuaMulti<'lua> + Clone + Sync + Send + 'static> LuaArg for T {}
 
-#[derive(Clone)]
+#[derive(Clone, Event)]
 /// A Lua Hook. The result of creating this event will be
 /// a call to the lua script with the hook_name and the given arguments
 pub struct LuaEvent<A: LuaArg> {
@@ -81,28 +78,7 @@ impl<A: LuaArg> ScriptHost for LuaScriptHost<A> {
     type ScriptAsset = LuaFile;
     type DocTarget = LuaDocFragment;
 
-    fn register_with_app_in_set(app: &mut App, set: impl FreeSystemSet) {
-        app.add_priority_event::<Self::ScriptEvent>()
-            .add_asset::<LuaFile>()
-            .init_asset_loader::<LuaLoader>()
-            .init_resource::<CachedScriptState<Self>>()
-            .init_resource::<ScriptContexts<Self::ScriptContext>>()
-            .init_resource::<APIProviders<Self>>()
-            .register_type::<ScriptCollection<Self::ScriptAsset>>()
-            .register_type::<Script<Self::ScriptAsset>>()
-            .register_type::<Handle<LuaFile>>()
-            .add_systems(
-                (
-                    script_add_synchronizer::<Self>,
-                    script_remove_synchronizer::<Self>,
-                    script_hot_reload_handler::<Self>,
-                )
-                    .chain()
-                    .in_set(set),
-            );
-    }
-
-    fn register_with_app_in_base_set(app: &mut App, set: impl BaseSystemSet) {
+    fn register_with_app_in_set(app: &mut App, schedule: impl ScheduleLabel, set: impl SystemSet) {
         app.add_priority_event::<Self::ScriptEvent>()
             .add_asset::<LuaFile>()
             .init_asset_loader::<LuaLoader>()
@@ -115,13 +91,14 @@ impl<A: LuaArg> ScriptHost for LuaScriptHost<A> {
             // handle script insertions removal first
             // then update their contexts later on script asset changes
             .add_systems(
+                schedule,
                 (
                     script_add_synchronizer::<Self>,
                     script_remove_synchronizer::<Self>,
                     script_hot_reload_handler::<Self>,
                 )
                     .chain()
-                    .in_base_set(set),
+                    .in_set(set),
             );
     }
 
@@ -139,8 +116,9 @@ impl<A: LuaArg> ScriptHost for LuaScriptHost<A> {
         lua.load(script)
             .set_name(script_data.name)
             .and_then(|c| c.exec())
-            .map_err(|_e| ScriptError::FailedToLoad {
+            .map_err(|e| ScriptError::FailedToLoad {
                 script: script_data.name.to_owned(),
+                msg: e.to_string(),
             })?;
 
         let mut lua = Mutex::new(lua);
@@ -182,7 +160,6 @@ impl<A: LuaArg> ScriptHost for LuaScriptHost<A> {
             // guarantees when it comes to other scripts callbacks,
             // at least for now.
             let globals = ctx.globals();
-
             for event in events {
                 // check if this script should handle this event
                 if !event.recipients().is_recipient(&script_data) {
diff --git a/languages/bevy_mod_scripting_rhai/Cargo.toml b/languages/bevy_mod_scripting_rhai/Cargo.toml
index e8cc579e87..1ea37c2f36 100644
--- a/languages/bevy_mod_scripting_rhai/Cargo.toml
+++ b/languages/bevy_mod_scripting_rhai/Cargo.toml
@@ -22,6 +22,6 @@ name="bevy_mod_scripting_rhai"
 path="src/lib.rs"
 
 [dependencies]
-bevy= { version = "0.10.1", default-features = false}
-rhai = { version = "1.8.0", features = ["sync"] }
+bevy= { version = "0.11", default-features = false}
+rhai = { version = "1.15.1", features = ["sync"] }
 bevy_mod_scripting_core = {path="../../bevy_mod_scripting_core", version = "0.3.0" }
diff --git a/languages/bevy_mod_scripting_rhai/src/assets.rs b/languages/bevy_mod_scripting_rhai/src/assets.rs
index ef90336adc..6d803b4962 100644
--- a/languages/bevy_mod_scripting_rhai/src/assets.rs
+++ b/languages/bevy_mod_scripting_rhai/src/assets.rs
@@ -1,12 +1,12 @@
 use bevy::{
     asset::Error,
     asset::{AssetLoader, LoadedAsset},
-    reflect::TypeUuid,
+    reflect::{TypePath, TypeUuid},
 };
 use bevy_mod_scripting_core::prelude::*;
 use std::sync::Arc;
 
-#[derive(Debug, TypeUuid)]
+#[derive(Debug, TypeUuid, TypePath)]
 #[uuid = "e4f7d00d-5acd-45fb-a29c-5a44c5447f5c"]
 /// A rhai code file in bytes
 pub struct RhaiFile {
diff --git a/languages/bevy_mod_scripting_rhai/src/lib.rs b/languages/bevy_mod_scripting_rhai/src/lib.rs
index a6d15a1984..e539c32549 100644
--- a/languages/bevy_mod_scripting_rhai/src/lib.rs
+++ b/languages/bevy_mod_scripting_rhai/src/lib.rs
@@ -2,10 +2,7 @@ use crate::{
     assets::{RhaiFile, RhaiLoader},
     docs::RhaiDocFragment,
 };
-use bevy::{
-    ecs::schedule::{BaseSystemSet, FreeSystemSet},
-    prelude::*,
-};
+use bevy::{ecs::schedule::ScheduleLabel, prelude::*};
 use bevy_mod_scripting_core::{prelude::*, systems::*, world::WorldPointer};
 use rhai::*;
 use std::marker::PhantomData;
@@ -50,7 +47,7 @@ pub struct RhaiContext {
     pub scope: Scope<'static>,
 }
 
-#[derive(Clone)]
+#[derive(Clone, Event)]
 /// A Rhai Hook. The result of creating this event will be
 /// a call to the lua script with the hook_name and the given arguments
 pub struct RhaiEvent<A: FuncArgs + Clone + 'static> {
@@ -72,7 +69,11 @@ impl<A: FuncArgs + Send + Clone + Sync + 'static> ScriptHost for RhaiScriptHost<
     type APITarget = Engine;
     type DocTarget = RhaiDocFragment;
 
-    fn register_with_app_in_set(app: &mut bevy::prelude::App, set: impl FreeSystemSet) {
+    fn register_with_app_in_set(
+        app: &mut bevy::prelude::App,
+        schedule: impl ScheduleLabel,
+        set: impl SystemSet,
+    ) {
         app.add_priority_event::<Self::ScriptEvent>()
             .add_asset::<RhaiFile>()
             .init_asset_loader::<RhaiLoader>()
@@ -83,6 +84,7 @@ impl<A: FuncArgs + Send + Clone + Sync + 'static> ScriptHost for RhaiScriptHost<
             .register_type::<Script<Self::ScriptAsset>>()
             .register_type::<Handle<RhaiFile>>()
             .add_systems(
+                schedule,
                 (
                     script_add_synchronizer::<Self>,
                     script_remove_synchronizer::<Self>,
@@ -92,36 +94,8 @@ impl<A: FuncArgs + Send + Clone + Sync + 'static> ScriptHost for RhaiScriptHost<
                     .in_set(set),
             )
             // setup engine
-            .add_startup_system(
-                |mut providers: ResMut<APIProviders<Self>>, mut host: ResMut<Self>| {
-                    providers
-                        .attach_all(&mut host.engine)
-                        .expect("Error in adding api's for rhai");
-                },
-            );
-    }
-
-    fn register_with_app_in_base_set(app: &mut bevy::prelude::App, set: impl BaseSystemSet) {
-        app.add_priority_event::<Self::ScriptEvent>()
-            .add_asset::<RhaiFile>()
-            .init_asset_loader::<RhaiLoader>()
-            .init_resource::<CachedScriptState<Self>>()
-            .init_resource::<ScriptContexts<Self::ScriptContext>>()
-            .init_resource::<APIProviders<Self>>()
-            .register_type::<ScriptCollection<Self::ScriptAsset>>()
-            .register_type::<Script<Self::ScriptAsset>>()
-            .register_type::<Handle<RhaiFile>>()
             .add_systems(
-                (
-                    script_add_synchronizer::<Self>,
-                    script_remove_synchronizer::<Self>,
-                    script_hot_reload_handler::<Self>,
-                )
-                    .chain()
-                    .in_base_set(set),
-            )
-            // setup engine
-            .add_startup_system(
+                Startup,
                 |mut providers: ResMut<APIProviders<Self>>, mut host: ResMut<Self>| {
                     providers
                         .attach_all(&mut host.engine)
@@ -149,8 +123,9 @@ impl<A: FuncArgs + Send + Clone + Sync + 'static> ScriptHost for RhaiScriptHost<
         let mut ast = self
             .engine
             .compile(
-                std::str::from_utf8(script).map_err(|_| ScriptError::FailedToLoad {
+                std::str::from_utf8(script).map_err(|e| ScriptError::FailedToLoad {
                     script: script_data.name.to_owned(),
+                    msg: e.to_string(),
                 })?,
             )
             .map_err(|e| ScriptError::SyntaxError {
diff --git a/makefile b/makefile
index 64e484cfa9..3a4ccffdb8 100644
--- a/makefile
+++ b/makefile
@@ -58,22 +58,22 @@ generate_api:
 	rustfmt ./bevy_script_api/src/generated.rs
 
 make_json_files:
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_asset@0.10.1  --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_ecs@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_pbr@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_render@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_math@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_transform@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_sprite@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_ui@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_animation@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_core@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_core_pipeline@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_gltf@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_hierarchy@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_text@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_time@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_utils@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy_reflect@0.10.1 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p glam@0.23.0 --  -Zunstable-options --output-format json && \
-	rustup run nightly-2022-12-18 cargo rustdoc -p bevy@0.10.1 --  -Zunstable-options --output-format json 
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_asset@0.11.0  --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_ecs@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_pbr@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_render@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_math@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_transform@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_sprite@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_ui@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_animation@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_core@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_core_pipeline@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_gltf@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_hierarchy@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_text@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_time@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_utils@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy_reflect@0.11.0 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p glam@0.24.1 --  -Zunstable-options --output-format json && \
+	rustup run nightly-2023-07-16 cargo rustdoc -p bevy@0.11.0 --  -Zunstable-options --output-format json 
diff --git a/readme.md b/readme.md
index 98bd46d769..bafcf517fc 100644
--- a/readme.md
+++ b/readme.md
@@ -54,9 +54,9 @@ To install:
 - Add this crate to your Cargo.toml file dependencies
   - The crate is still in development so I recommended pinning to a git commit
 - Add ScriptingPlugin to your app
-- Add the ScriptHosts you plan on using (`add_script_host`)
+- Add the ScriptHosts you plan on using (`add_script_host`, `add_script_host_to_set`)
   - Make sure to attach it to a system set running AFTER any systems which may generate modify/create/remove script components
-- Add script handlers to capture events in the priority range you're expecting (`add_script_handler_to_set`,`add_script_handler_to_base_set`)
+- Add script handlers to capture events in the priority range you're expecting (`add_script_handler_to_set`,`add_script_handler`)
 - Add systems which generate ScriptEvents corresponding to your script host
 - Add systems which add ScriptCollection components to your entities and fill them with scripts
 
@@ -71,18 +71,18 @@ fn main() -> std::io::Result<()> {
         // pick and register only the hosts you want to use
         // use any system set AFTER any systems which add/remove/modify script components
         // in order for your script updates to propagate in a single frame
-        .add_script_host_to_base_set::<RhaiScriptHost<MyRhaiArgStruct>,_>(CoreSet::PostUpdate)
-        .add_script_host_to_base_set::<LuaScriptHost<MyLuaArgStruct>,_>(CoreSet::PostUpdate)
+        .add_script_host::<RhaiScriptHost<MyRhaiArgStruct>>(PostUpdate)
+        .add_script_host::<LuaScriptHost<MyLuaArgStruct>>(PostUpdate)
 
         // the handlers should be ran after any systems which produce script events.
         // The PostUpdate set is okay only if your API doesn't require the core Bevy systems' commands
         // to run beforehand.
         // Note, this setup assumes a single script handler system set with all events having identical
         // priority of zero (see examples for more complex scenarios)
-        .add_script_handler_to_base_set::<LuaScriptHost<MyLuaArg>, _, 0, 0>(
+        .add_script_handler::<LuaScriptHost<MyLuaArg>, 0, 0>(
             CoreSet::PostUpdate,
         )
-        .add_script_handler_to_base_set::<RhaiScriptHost<RhaiEventArgs>, _, 0, 0>(
+        .add_script_handler::<RhaiScriptHost<RhaiEventArgs>, 0, 0>(
             CoreSet::PostUpdate,
         )
 
@@ -252,8 +252,8 @@ Register the API providers like so:
 ```rust, ignore
     app.add_plugins(DefaultPlugins)
         .add_plugin(ScriptingPlugin)
-        .add_script_host_to_base_set::<LuaScriptHost<MyLuaArg>, _>(CoreSet::PostUpdate)
-        .add_script_host_to_base_set::<RhaiScriptHost<MyRhaiArg>, _>(CoreSet::PostUpdate)
+        .add_script_host::<LuaScriptHost<MyLuaArg>>(PostUpdate)
+        .add_script_host::<RhaiScriptHost<MyRhaiArg>>(PostUpdate)
         .add_api_provider::<LuaScriptHost<MyLuaArg>>(Box::new(LuaAPIProvider))
         .add_api_provider::<LuaScriptHost<MyRhaiArg>>(Box::new(RhaiAPIProvider))
         //...
@@ -275,14 +275,12 @@ fn main() -> std::io::Result<()> {
 
     app.add_plugins(DefaultPlugins)
         .add_plugin(ScriptingPlugin)
-        .add_script_host_to_base_set::<LuaScriptHost<()>, _>(CoreSet::PostUpdate)
+        .add_script_host::<LuaScriptHost<()>>(PostUpdate)
         // Note: This is a noop in optimized builds unless the `doc_always` feature is enabled!
         // this will pickup any API providers added *BEFOREHAND* like this one
         // .add_api_provider::<LuaScriptHost<()>>(Box::new(LuaAPIProvider))
         .update_documentation::<LuaScriptHost<()>>()
-        .add_script_handler_to_base_set::<LuaScriptHost<()>, _, 0, 0>(
-            CoreSet::PostUpdate,
-        );
+        .add_script_handler::<LuaScriptHost<()>, 0, 0>(PostUpdate);
 
     Ok(())
 }
diff --git a/src/documentation/main.rs b/src/documentation/main.rs
index 30ffdc4e49..04736f6849 100644
--- a/src/documentation/main.rs
+++ b/src/documentation/main.rs
@@ -6,8 +6,8 @@ fn main() {
     let args: Vec<String> = env::args().collect();
     let mut app = App::new();
     app.add_plugins(MinimalPlugins)
-        .add_plugin(ScriptingPlugin)
-        .add_plugin(AssetPlugin::default());
+        .add_plugins(ScriptingPlugin)
+        .add_plugins(AssetPlugin::default());
 
     static INVALID_ARGUMENT_WARNING: &str = "Expected one of: 'lua','rhai' as arguments";
 
@@ -16,7 +16,7 @@ fn main() {
     match lang.as_str() {
         "lua" => {
             #[cfg(all(feature = "lua", feature = "lua_script_api"))]
-            app.add_script_host_to_base_set::<LuaScriptHost<()>, _>(CoreSet::PostUpdate)
+            app.add_script_host::<LuaScriptHost<()>>(PostUpdate)
                 .add_api_provider::<LuaScriptHost<()>>(Box::new(LuaBevyAPIProvider))
                 .update_documentation::<LuaScriptHost<()>>();