diff --git a/CHANGELOG.md b/CHANGELOG.md
index da74fa7..c912e46 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,14 @@
+# 5.0.0
+- BREAKING CHANGE:
+	- Due to a soundness hole in the previous implementation of `stabby::result::Result`, its representation was overhauled. While it's still technically compatible binary-wise (meaning it still follows the original spec), the soundness hole could possibly lead to UB, so `stabby` will treat them as incompatible.
+- Add support for Rust 1.78:
+	- With 1.78, [Rust merged a breaking change](https://github.com/rust-lang/rust/issues/123281) which impacts `stabby`. This change prevents consts from refering to generics entirely, which was key to `stabby`'s implementation of vtables.
+	- More accurately, it prevents consts from refering to generics that aren't bound by `core::marker::Freeze`, but that trait hasn't been stabilized at the same time as the new error has.
+	- While the team was aware that this would be a breaking change, `crater` failed to report that `stabby` was impacted by the regression, as it tried compiling an obsolete version of `stabby` that could only build with pre-1.77 versions of Rust due to the `u128` ABI-break on x86. This led them to judge that the breaking change was acceptable.
+	- To compensate for this, `stabby` will (for non-nighly `>=1.78` versions of Rust) draw its vtable references from a heap-allocated, lazily populated, global set of vtables. This is in opposition to the `<1.78` and `nightly` behaviour where it'll keep on drawing these vtable references straight from the binary.
+		- From this release onwards, a new priority for `stabby` will be to improve the performance of this behaviour; or better yet find a new way to obtain the previous behaviour that compiles.
+	- While I can't hide that I am very annoyed at this development, I must also state that I understand the Rust Team's choice to ship this breaking change: they considered this potential window for a soundness hole a bug, and even though `crater` didn't report any use of this bug that was unsound, it also failed to report `stabby` as a legitimate user of it. I do wish they'd have waited for `Freeze`'s stabilization to make the breaking change however, as the sound pattern it would prevent, as well as the fact that it couldn't be replicated without `Freeze`, _was_ known.
+
 # 4.0.5
 - Fix for 1.72: `AllocPtr::prefix` is `const fn` from 1.73 onwards rather than 1.72 onwards (@yellowhatter).
 
diff --git a/README.md b/README.md
index 82c99cb..07585f5 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,19 @@
 [![Crates.io (latest)](https://img.shields.io/crates/v/stabby)](https://lib.rs/crates/stabby)
 [![docs.rs](https://img.shields.io/docsrs/stabby)](https://docs.rs/stabby/latest/stabby/)
 
+> [!WARNING]  
+> Due to a breaking change in Rust 1.78, `stabby`'s implementation of trait objects may raise performance issues:
+> - __Only non-nightly, >= 1.78 versions of Rust are affected__
+> - The v-tables backing trait objects are now inserted in a global lock-free set.
+> - This set is leaked: `valgrind` _will_ be angry at you.
+> - This set grows with the number of distinct `(type, trait-set)` pairs. Its current implementation is a vector:
+>   - Lookup is done through linear search (O(n)), which stays the fastest for <100 number of elements.
+>   - Insertion is done by cloning the vector (O(n)) and replacing it atomically, repeating the operation in case of collision.
+>   - Efforts to replace this implementation with immutable b-tree maps are ongoing (they will be scrapped if found to be much slower than the current implementation).
+>
+> This note will be updated as the situation evolves. In the meantime, if your project uses many `stabby`-defined trait objects,
+> I suggest using either `nightly` or a `< 1.78` version of the compiler.
+
 # A Stable ABI for Rust with compact sum-types
 `stabby` is your one-stop-shop to create stable binary interfaces for your shared libraries easily, without having your sum-types (enums) explode in size.
 
diff --git a/examples/dynlinkage/src/main.rs b/examples/dynlinkage/src/main.rs
index 4bf9cd1..f78bfcd 100644
--- a/examples/dynlinkage/src/main.rs
+++ b/examples/dynlinkage/src/main.rs
@@ -14,7 +14,7 @@
 
 #[stabby::import(name = "library")]
 extern "C" {
-    pub fn stable_fn(v: u8);
+    pub fn stable_fn(v: u8) -> stabby::option::Option<()>;
 }
 
 #[stabby::import(canaries = "", name = "library")]
diff --git a/examples/libloading/src/main.rs b/examples/libloading/src/main.rs
index cf13bbf..d130453 100644
--- a/examples/libloading/src/main.rs
+++ b/examples/libloading/src/main.rs
@@ -31,7 +31,9 @@ fn main() {
                     .map(|d| d.map(|f| f.unwrap().file_name()).collect::<Vec<_>>())
             )
         });
-        let stable_fn = lib.get_stabbied::<extern "C" fn(u8)>(b"stable_fn").unwrap();
+        let stable_fn = lib
+            .get_stabbied::<extern "C" fn(u8) -> stabby::option::Option<()>>(b"stable_fn")
+            .unwrap();
         let unstable_fn = lib
             .get_canaried::<extern "C" fn(&[u8])>(b"unstable_fn")
             .unwrap();
diff --git a/examples/library/src/lib.rs b/examples/library/src/lib.rs
index f8cf72f..da413c1 100644
--- a/examples/library/src/lib.rs
+++ b/examples/library/src/lib.rs
@@ -13,8 +13,9 @@
 //
 
 #[stabby::export]
-pub extern "C" fn stable_fn(v: u8) {
-    println!("{v}")
+pub extern "C" fn stable_fn(v: u8) -> stabby::option::Option<()> {
+    println!("{v}");
+    Default::default()
 }
 
 #[stabby::export(canaries)]
diff --git a/stabby-abi/Cargo.toml b/stabby-abi/Cargo.toml
index b5e880a..f008b59 100644
--- a/stabby-abi/Cargo.toml
+++ b/stabby-abi/Cargo.toml
@@ -14,7 +14,7 @@
 
 [package]
 name = "stabby-abi"
-version = "4.0.5"
+version = "5.0.0"
 edition = "2021"
 authors = { workspace = true }
 license = { workspace = true }
@@ -38,7 +38,7 @@ abi_stable-channels = ["abi_stable", "abi_stable/channels"]
 # unsafe_wakers = [] # unsafe_wakers is no longer a feature, but a compile option: you can enable them using `RUST_FLAGS='--cfg unsafe_wakers="true"'`
 
 [dependencies]
-stabby-macros = { path = "../stabby-macros/", version = "4.0.5" }
+stabby-macros = { path = "../stabby-macros/", version = "5.0.0" }
 abi_stable = { workspace = true, optional = true }
 libc = { workspace = true, optional = true }
 rustversion = { workspace = true }
diff --git a/stabby-abi/src/alloc/mod.rs b/stabby-abi/src/alloc/mod.rs
index e3f99b4..d4d414d 100644
--- a/stabby-abi/src/alloc/mod.rs
+++ b/stabby-abi/src/alloc/mod.rs
@@ -264,6 +264,13 @@ impl<T, Alloc> AllocPtr<T, Alloc> {
             marker: PhantomData,
         }
     }
+    /// Casts an allocated pointer.
+    pub const fn cast<U>(self) -> AllocPtr<U, Alloc> {
+        AllocPtr {
+            ptr: self.ptr.cast(),
+            marker: PhantomData,
+        }
+    }
     /// The offset between `self.ptr` and the prefix.
     pub const fn prefix_skip() -> usize {
         AllocPrefix::<Alloc>::skip_to::<T>()
diff --git a/stabby-abi/src/enums/err_non_empty.rs b/stabby-abi/src/enums/err_non_empty.rs
index 77738fb..037e7d9 100644
--- a/stabby-abi/src/enums/err_non_empty.rs
+++ b/stabby-abi/src/enums/err_non_empty.rs
@@ -26,7 +26,7 @@ pub struct Layout<
     ErrFv: IForbiddenValues,
     ErrUb: IBitMask,
     ErrSize: Unsigned,
-    ErrAlign: PowerOf2,
+    ErrAlign: Alignment,
     ErrOffset: Unsigned,
 >(
     core::marker::PhantomData<(
@@ -89,7 +89,7 @@ impl<
         ErrFv: IForbiddenValues,
         ErrUb: IBitMask,
         ErrSize: Unsigned,
-        ErrAlign: PowerOf2,
+        ErrAlign: Alignment,
         ErrOffset: Unsigned,
     > IDeterminantProviderInner
     for Layout<UnionSize, H, OkFv, OkUb, ErrFv, ErrUb, ErrSize, ErrAlign, ErrOffset>
@@ -108,7 +108,7 @@ impl<
         ErrFv: IForbiddenValues,
         ErrUb: IBitMask,
         ErrSize: Unsigned,
-        ErrAlign: PowerOf2,
+        ErrAlign: Alignment,
         ErrOffset: Unsigned,
     > IDeterminantProviderInner
     for Layout<UnionSize, T<Budget>, OkFv, OkUb, ErrFv, ErrUb, ErrSize, ErrAlign, ErrOffset>
@@ -145,7 +145,7 @@ impl<
         ErrFv: IForbiddenValues,
         ErrUb: IBitMask,
         ErrSize: Unsigned,
-        ErrAlign: PowerOf2,
+        ErrAlign: Alignment,
         ErrOffset: Unsigned,
         Offset: Unsigned,
         V: Unsigned,
@@ -179,7 +179,7 @@ impl<
         ErrFv: IForbiddenValues,
         ErrUb: IBitMask,
         ErrSize: Unsigned,
-        ErrAlign: PowerOf2,
+        ErrAlign: Alignment,
         ErrOffset: Unsigned,
         Offset: Unsigned,
         V: Unsigned,
@@ -211,7 +211,7 @@ impl<
         ErrFv: IForbiddenValues,
         ErrUb: IBitMask,
         ErrSize: Unsigned,
-        ErrAlign: PowerOf2,
+        ErrAlign: Alignment,
         ErrOffset: Unsigned,
         Offset: Unsigned,
         V: NonZero,
@@ -242,7 +242,7 @@ impl<
         ErrFv: IForbiddenValues,
         ErrUb: IBitMask,
         ErrSize: Unsigned,
-        ErrAlign: PowerOf2,
+        ErrAlign: Alignment,
         ErrOffset: Unsigned,
     > IDeterminantProviderInner
     for DeterminantProvider<
@@ -271,7 +271,7 @@ impl<
         ErrFv: IForbiddenValues,
         ErrUb: IBitMask,
         ErrSize: Unsigned,
-        ErrAlign: PowerOf2,
+        ErrAlign: Alignment,
         ErrOffset: Unsigned,
     > IDeterminantProviderInner
     for (
@@ -291,7 +291,7 @@ impl<
         ErrFv: IForbiddenValues,
         ErrUb: IBitMask,
         ErrSize: Unsigned,
-        ErrAlign: PowerOf2,
+        ErrAlign: Alignment,
         ErrOffset: Unsigned,
     > IDeterminantProviderInner
     for (
diff --git a/stabby-abi/src/fatptr.rs b/stabby-abi/src/fatptr.rs
index 3582355..ffbc680 100644
--- a/stabby-abi/src/fatptr.rs
+++ b/stabby-abi/src/fatptr.rs
@@ -140,7 +140,7 @@ impl<'a, Vt: Copy + 'a> DynRef<'a, Vt> {
     where
         Vt: PartialEq + IConstConstructor<'a, T>,
     {
-        (self.vtable == Vt::VTABLE).then(|| unsafe { self.ptr.as_ref() })
+        (self.vtable == Vt::vtable()).then(|| unsafe { self.ptr.as_ref() })
     }
     /// Downcasts the reference based on its reflection report.
     pub fn stable_downcast<T: crate::IStable, Path>(&self) -> Option<&T>
@@ -267,6 +267,12 @@ impl<'a, P: IPtrOwned + IPtr, Vt: HasDropVt + 'a> Dyn<'a, P, Vt> {
     /// This implies that this downcast will always yield `None` when attempting to downcast
     /// values constructed accross an FFI.
     ///
+    /// Note that the compiler may chose to have multiple copies of the vtable, notably in optimized builds.
+    /// This means that even within a same compile unit, this function may fail to downcast a value even if
+    /// the type should have matched.
+    ///
+    /// In general, you should prefer [`Self::stable_downcast_ref`]
+    ///
     /// # Safety
     /// This may have false positives if all of the following applies:
     /// - `self` was built from `&U`, within the same FFI-boundary,
@@ -280,20 +286,26 @@ impl<'a, P: IPtrOwned + IPtr, Vt: HasDropVt + 'a> Dyn<'a, P, Vt> {
     where
         Vt: PartialEq + Copy + IConstConstructor<'a, T>,
     {
-        (self.vtable == Vt::VTABLE).then(|| unsafe { self.ptr.as_ref() })
+        (self.vtable == Vt::vtable()).then(|| unsafe { self.ptr.as_ref() })
     }
     /// Downcasts the reference based on its reflection report.
     pub fn stable_downcast_ref<T: crate::IStable, Path>(&self) -> Option<&T>
     where
         Vt: TransitiveDeref<crate::vtable::StabbyVtableAny, Path> + IConstConstructor<'a, T>,
     {
-        (self.report() == T::REPORT).then(|| unsafe { self.ptr.as_ref() })
+        (self.id() == T::ID && self.report() == T::REPORT).then(|| unsafe { self.ptr.as_ref() })
     }
     /// Downcasts the mutable reference based on vtable equality.
     ///
     /// This implies that this downcast will always yield `None` when attempting to downcast
     /// values constructed accross an FFI.
     ///
+    /// Note that the compiler may chose to have multiple copies of the vtable, notably in optimized builds.
+    /// This means that even within a same compile unit, this function may fail to downcast a value even if
+    /// the type should have matched.
+    ///
+    /// In general, you should prefer [`Self::stable_downcast_mut`]
+    ///
     /// # Safety
     /// This may have false positives if all of the following applies:
     /// - `self` was built from `&U`, within the same FFI-boundary,
@@ -308,15 +320,15 @@ impl<'a, P: IPtrOwned + IPtr, Vt: HasDropVt + 'a> Dyn<'a, P, Vt> {
         Vt: PartialEq + Copy + IConstConstructor<'a, T>,
         P: IPtrMut,
     {
-        (self.vtable == Vt::VTABLE).then(|| unsafe { self.ptr.as_mut() })
+        (self.vtable == Vt::vtable()).then(|| unsafe { self.ptr.as_mut() })
     }
-    /// Downcasts the reference based on its reflection report.
+    /// Downcasts the mutable reference based on its reflection report.
     pub fn stable_downcast_mut<T: crate::IStable, Path>(&mut self) -> Option<&mut T>
     where
         Vt: TransitiveDeref<crate::vtable::StabbyVtableAny, Path> + IConstConstructor<'a, T>,
         P: IPtrMut,
     {
-        (self.report() == T::REPORT).then(|| unsafe { self.ptr.as_mut() })
+        (self.id() == T::ID && self.report() == T::REPORT).then(|| unsafe { self.ptr.as_mut() })
     }
 }
 
@@ -331,7 +343,7 @@ where
     fn from(value: P) -> Self {
         Self {
             ptr: core::mem::ManuallyDrop::new(value.anonimize()),
-            vtable: Vt::VTABLE,
+            vtable: Vt::vtable(),
             unsend: core::marker::PhantomData,
         }
     }
@@ -350,7 +362,7 @@ impl<'a, T, Vt: Copy + IConstConstructor<'a, T>> From<&'a T> for DynRef<'a, Vt>
         unsafe {
             DynRef {
                 ptr: core::mem::transmute(value),
-                vtable: Vt::VTABLE,
+                vtable: Vt::vtable(),
                 unsend: core::marker::PhantomData,
             }
         }
diff --git a/stabby-abi/src/istable.rs b/stabby-abi/src/istable.rs
index 2f8b203..b65ac9b 100644
--- a/stabby-abi/src/istable.rs
+++ b/stabby-abi/src/istable.rs
@@ -14,6 +14,8 @@
 
 use crate::report::TypeReport;
 
+use self::unsigned::{Alignment, IUnsignedBase};
+
 use super::typenum2::*;
 use super::unsigned::{IBitBase, NonZero};
 use super::{FieldPair, Struct, Union};
@@ -37,10 +39,10 @@ macro_rules! same_as {
 /// # Safety
 /// Mis-implementing this trait can lead to memory corruption in sum tyoes
 pub unsafe trait IStable: Sized {
-    /// The size of the annotated type.
+    /// The size of the annotated type in bytes.
     type Size: Unsigned;
-    /// The alignment of the annotated type.
-    type Align: PowerOf2;
+    /// The alignment of the annotated type in bytes.
+    type Align: Alignment;
     /// The values that the annotated type cannot occupy.
     type ForbiddenValues: IForbiddenValues;
     /// The padding bits in the annotated types
@@ -336,16 +338,13 @@ impl<O: Unsigned, T, R: IBitMask> IsEnd for Array<O, T, R> {
     type Output = B0;
 }
 
-unsafe impl<A: IStable, B: IStable> IStable for FieldPair<A, B>
-where
-    AlignedAfter<B, A::Size>: IStable,
-{
+unsafe impl<A: IStable, B: IStable> IStable for FieldPair<A, B> {
     type ForbiddenValues =
         Or<A::ForbiddenValues, <AlignedAfter<B, A::Size> as IStable>::ForbiddenValues>;
     type UnusedBits =
         <A::UnusedBits as IBitMask>::BitOr<<AlignedAfter<B, A::Size> as IStable>::UnusedBits>;
     type Size = <AlignedAfter<B, A::Size> as IStable>::Size;
-    type Align = <A::Align as PowerOf2>::Max<B::Align>;
+    type Align = <A::Align as Alignment>::Max<B::Align>;
     type HasExactlyOneNiche = <A::HasExactlyOneNiche as ISaturatingAdd>::SaturatingAdd<
         <AlignedAfter<B, A::Size> as IStable>::HasExactlyOneNiche,
     >;
@@ -483,7 +482,7 @@ unsafe impl<A: IStable, B: IStable> IStable for (Union<A, B>, B1) {
     type ForbiddenValues = End;
     type UnusedBits = End;
     type Size = <A::Size as Unsigned>::Max<B::Size>;
-    type Align = <A::Align as PowerOf2>::Max<B::Align>;
+    type Align = <A::Align as Alignment>::Max<B::Align>;
     type HasExactlyOneNiche = B0;
     type ContainsIndirections = <A::ContainsIndirections as Bit>::Or<B::ContainsIndirections>;
     primitive_report!("Union");
@@ -499,106 +498,25 @@ where
 pub struct AlignedAfter<T, Start: Unsigned>(core::marker::PhantomData<(T, Start)>);
 
 // AlignedAfter a ZST
-unsafe impl<T: IStable> IStable for AlignedAfter<T, U0> {
-    same_as!(T);
-}
-// Aligned after a non-ZST
-unsafe impl<T: IStable, B: Unsigned, Int: Bit> IStable for AlignedAfter<T, UInt<B, Int>>
-where
-    (Self, T::Align): IStable,
-{
-    same_as!((Self, T::Align));
-}
-
-unsafe impl<T: IStable, Start: Unsigned> IStable for (AlignedAfter<T, Start>, U1) {
-    type Align = U1;
-    type Size = tyeval!(Start + T::Size);
-    type UnusedBits = <T::UnusedBits as IBitMask>::Shift<Start>;
-    type ForbiddenValues = <T::ForbiddenValues as IForbiddenValues>::Shift<Start>;
-    type HasExactlyOneNiche = T::HasExactlyOneNiche;
-    type ContainsIndirections = T::ContainsIndirections;
-    primitive_report!("FP");
-}
-// non-ZST aligned after a non-ZST
-unsafe impl<T: IStable, Start: Unsigned, TAlignB1: Bit, TAlignB2: Bit, TAlignInt: Unsigned> IStable
-    for (
-        AlignedAfter<T, Start>,
-        UInt<UInt<TAlignInt, TAlignB1>, TAlignB2>,
-    )
-where
-    UInt<UInt<TAlignInt, TAlignB1>, TAlignB2>: PowerOf2,
-    (
-        Self,
-        tyeval!(Start % UInt<UInt<TAlignInt, TAlignB1>, TAlignB2>),
-    ): IStable,
-{
-    same_as!((
-        Self,
-        tyeval!(Start % UInt<UInt<TAlignInt, TAlignB1>, TAlignB2>)
-    ));
-}
-// non-ZST already aligned
-unsafe impl<T: IStable, Start: Unsigned, TAlignB: Unsigned, TAlignInt: Bit> IStable
-    for ((AlignedAfter<T, Start>, UInt<TAlignB, TAlignInt>), U0)
-{
+unsafe impl<T: IStable, Start: Unsigned> IStable for AlignedAfter<T, Start> {
     type Align = T::Align;
-    type Size = tyeval!(Start + T::Size);
-    type UnusedBits = <T::UnusedBits as IBitMask>::Shift<Start>;
-    type ForbiddenValues = <T::ForbiddenValues as IForbiddenValues>::Shift<Start>;
-    type HasExactlyOneNiche = T::HasExactlyOneNiche;
-    type ContainsIndirections = T::ContainsIndirections;
-    primitive_report!("FP");
-}
-// non-ZST needs alignment
-unsafe impl<T: IStable, Start: Unsigned, TAlignB: Unsigned, TAlignInt: Bit, B: Unsigned, Int: Bit>
-    IStable
-    for (
-        (AlignedAfter<T, Start>, UInt<TAlignB, TAlignInt>),
-        UInt<B, Int>,
-    )
-where
-// <tyeval!(T::Align - UInt<B, Int>) as Unsigned>::Padding: IStable,
-{
-    type Align = T::Align;
-    type Size = tyeval!((Start + (T::Align - UInt<B, Int>)) + T::Size);
-    type UnusedBits = <<<<tyeval!(T::Align - UInt<B, Int>) as Unsigned>::Padding as IStable>::UnusedBits as IBitMask>::Shift<Start> as IBitMask>::BitOr<
-        <T::UnusedBits as IBitMask>::Shift<tyeval!(Start + (T::Align - UInt<B, Int>))>>;
+    type Size = <T::Size as Unsigned>::Add<Start::NextMultipleOf<T::Align>>;
     type ForbiddenValues =
-        <T::ForbiddenValues as IForbiddenValues>::Shift<tyeval!(Start + (T::Align - UInt<B, Int>))>;
-    type HasExactlyOneNiche = Saturator;
+        <T::ForbiddenValues as IForbiddenValues>::Shift<Start::NextMultipleOf<T::Align>>;
+    type UnusedBits = <<<tyeval!(Start::NextMultipleOf<T::Align> - Start) as IUnsignedBase>::PaddingBitMask as IBitMask>::Shift<Start> as IBitMask>::BitOr<
+        <T::UnusedBits as IBitMask>::Shift<Start::NextMultipleOf<T::Align>>,
+    >;
+    type HasExactlyOneNiche = T::HasExactlyOneNiche;
     type ContainsIndirections = T::ContainsIndirections;
     primitive_report!("FP");
 }
 
-unsafe impl<T: IStable> IStable for Struct<T>
-where
-    (Self, T::Align): IStable,
-{
-    same_as!((Self, T::Align));
-}
-unsafe impl<T: IStable> IStable for (Struct<T>, U0) {
-    same_as!(T);
-}
-unsafe impl<T: IStable, B: Bit, Int: Unsigned> IStable for (Struct<T>, UInt<Int, B>)
-where
-    UInt<Int, B>: PowerOf2,
-    (Self, tyeval!(T::Size % UInt<Int, B>)): IStable,
-{
-    same_as!((Self, tyeval!(T::Size % UInt<Int, B>)));
-}
-unsafe impl<T: IStable, Align> IStable for ((Struct<T>, Align), U0) {
-    same_as!(T);
-}
-unsafe impl<T: IStable, Align, RemU: Unsigned, RemB: Bit> IStable
-    for ((Struct<T>, Align), UInt<RemU, RemB>)
-where
-// <tyeval!(T::Align - UInt<RemU, RemB>) as Unsigned>::Padding: IStable,
-{
-    type Size = tyeval!(T::Size + (T::Align - UInt<RemU, RemB>));
+unsafe impl<T: IStable> IStable for Struct<T> {
+    type Size = <T::Size as Unsigned>::NextMultipleOf<T::Align>;
     type Align = T::Align;
     type ForbiddenValues = T::ForbiddenValues;
     type UnusedBits = <T::UnusedBits as IBitMask>::BitOr<
-        <<<tyeval!(T::Align - UInt<RemU, RemB>) as Unsigned>::Padding as IStable>::UnusedBits as IBitMask>::Shift<T::Size>>;
+        <<tyeval!(<T::Size as Unsigned>::NextMultipleOf<T::Align> - T::Size) as IUnsignedBase>::PaddingBitMask as IBitMask>::Shift<T::Size>>;
     type HasExactlyOneNiche = Saturator;
     type ContainsIndirections = T::ContainsIndirections;
     primitive_report!("FP");
diff --git a/stabby-abi/src/lib.rs b/stabby-abi/src/lib.rs
index adae2da..054a6f7 100644
--- a/stabby-abi/src/lib.rs
+++ b/stabby-abi/src/lib.rs
@@ -32,6 +32,7 @@ pub mod alloc;
 pub mod num;
 
 pub use stabby_macros::{canary_suffixes, dynptr, export, import, stabby, vtable as vtmacro};
+use typenum2::unsigned::Alignment;
 
 use core::fmt::{Debug, Display};
 
@@ -256,7 +257,7 @@ unsafe impl<T, As: IStable> IStable for StableLike<T, As> {
 /// transitively containing the emulated type are indeed ABI-stable.
 pub struct NoNiches<
     Size: Unsigned,
-    Align: PowerOf2,
+    Align: Alignment,
     HasExactlyOneNiche: ISaturatingAdd = Saturator,
     ContainsIndirections: Bit = B0,
 >(
@@ -265,7 +266,7 @@ pub struct NoNiches<
 );
 unsafe impl<
         Size: Unsigned,
-        Align: PowerOf2,
+        Align: Alignment,
         HasExactlyOneNiche: ISaturatingAdd,
         ContainsIndirections: Bit,
     > IStable for NoNiches<Size, Align, HasExactlyOneNiche, ContainsIndirections>
diff --git a/stabby-abi/src/result.rs b/stabby-abi/src/result.rs
index bcaf186..932eac3 100644
--- a/stabby-abi/src/result.rs
+++ b/stabby-abi/src/result.rs
@@ -14,28 +14,75 @@
 
 //! Stable results!
 
+use stabby_macros::tyeval;
+
 pub use crate::enums::IDeterminant;
 use crate::enums::IDeterminantProvider;
-use crate::padding::Padded;
-use crate::Union;
-use crate::{self as stabby, unreachable_unchecked, Bit, IStable};
+use crate::istable::IBitMask;
+use crate::report::FieldReport;
+use crate::str::Str;
+use crate::unsigned::IUnsignedBase;
+use crate::{self as stabby, unreachable_unchecked, Bit, IStable, B0};
+use crate::{Alignment, Tuple, Unsigned};
 
+#[repr(transparent)]
 /// An ABI-stable, niche optimizing equivalent of [`core::result::Result`]
-#[stabby::stabby]
 pub struct Result<Ok, Err>
 where
     Ok: IDeterminantProvider<Err>,
     Err: IStable,
 {
-    niche_exporter: <Ok as IDeterminantProvider<Err>>::NicheExporter,
-    determinant: <Ok as IDeterminantProvider<Err>>::Determinant,
-    #[allow(clippy::type_complexity)]
-    union: core::mem::MaybeUninit<
-        Union<
-            Padded<<Ok as IDeterminantProvider<Err>>::OkShift, Ok>,
-            Padded<<Ok as IDeterminantProvider<Err>>::ErrShift, Err>,
-        >,
-    >,
+    storage: Storage<<Self as IStable>::Size, <Self as IStable>::Align>,
+}
+impl<Ok: Unpin, Err: Unpin> Unpin for Result<Ok, Err>
+where
+    Ok: IDeterminantProvider<Err>,
+    Err: IStable,
+{
+}
+type Determinant<Ok, Err> = <Ok as IDeterminantProvider<Err>>::Determinant;
+unsafe impl<Ok, Err> IStable for Result<Ok, Err>
+where
+    Ok: IDeterminantProvider<Err>,
+    Err: IStable,
+{
+    type Size = tyeval!(<<Determinant<Ok, Err> as IStable>::Size as Unsigned>::NextMultipleOf<Self::Align> + <Ok::Size as Unsigned>::Max<Err::Size>);
+    type Align = <Ok::Align as Alignment>::Max<Err::Align>;
+    type ContainsIndirections = <Ok::ContainsIndirections as Bit>::Or<Err::ContainsIndirections>;
+    type ForbiddenValues =
+        <<Ok as IDeterminantProvider<Err>>::NicheExporter as IStable>::ForbiddenValues;
+    type UnusedBits = <<Tuple<Determinant<Ok, Err>, <Self::Align as Alignment>::AsUint> as IStable>::UnusedBits as IBitMask>::BitOr<<<<Ok as IDeterminantProvider<Err>>::NicheExporter as IStable>::UnusedBits as IBitMask>::Shift<<<Determinant<Ok, Err> as IStable>::Size as Unsigned>::NextMultipleOf<Self::Align>>>;
+    type HasExactlyOneNiche = B0;
+    const REPORT: &'static crate::report::TypeReport = &crate::report::TypeReport {
+        name: Str::new("Result"),
+        module: Str::new("stabby_abi::result"),
+        tyty: crate::report::TyTy::Enum(Str::new("stabby")),
+        version: 1,
+        fields: crate::StableLike::new(Some(&FieldReport {
+            name: Str::new("Ok"),
+            ty: Ok::REPORT,
+            next_field: crate::StableLike::new(Some(&FieldReport {
+                name: Str::new("Err"),
+                ty: Err::REPORT,
+                next_field: crate::StableLike::new(None),
+            })),
+        })),
+    };
+    const ID: u64 = crate::report::gen_id(Self::REPORT);
+}
+
+#[stabby::stabby]
+struct Storage<Size: Unsigned, Align: Alignment + Alignment> {
+    inner: <Align::Divide<Size> as IUnsignedBase>::Array<Align::AsUint>,
+}
+
+impl<Size: Unsigned, Align: Alignment + Alignment> Storage<Size, Align> {
+    const fn as_ptr(&self) -> *const u8 {
+        self as *const Self as *const _
+    }
+    fn as_mut_ptr(&mut self) -> *mut u8 {
+        self as *mut Self as *mut _
+    }
 }
 
 impl<Ok: Clone, Err: Clone> Clone for Result<Ok, Err>
@@ -125,10 +172,11 @@ where
     Err: IStable,
 {
     fn drop(&mut self) {
-        if self.is_ok() {
-            unsafe { core::ptr::drop_in_place(&mut self.union.assume_init_mut().ok.value) }
-        } else {
-            unsafe { core::ptr::drop_in_place(&mut self.union.assume_init_mut().err.value) }
+        unsafe {
+            self.match_mut(
+                |mut ok| core::ptr::drop_in_place::<Ok>(&mut *ok),
+                |mut err| core::ptr::drop_in_place::<Err>(&mut *err),
+            )
         }
     }
 }
@@ -137,40 +185,67 @@ where
     Ok: IDeterminantProvider<Err>,
     Err: IStable,
 {
+    const DET_SIZE: usize = <<<Determinant<Ok, Err> as IStable>::Size as Unsigned>::NextMultipleOf<
+        <Self as IStable>::Align,
+    > as Unsigned>::USIZE;
+    const OK_OFFSET: usize =
+        <<Ok as IDeterminantProvider<Err>>::OkShift as Unsigned>::USIZE + Self::DET_SIZE;
+    const ERR_OFFSET: usize =
+        <<Ok as IDeterminantProvider<Err>>::ErrShift as Unsigned>::USIZE + Self::DET_SIZE;
+    const fn ok_ptr(
+        storage: *const Storage<<Self as IStable>::Size, <Self as IStable>::Align>,
+    ) -> *const Ok {
+        unsafe { storage.cast::<u8>().add(Self::OK_OFFSET).cast() }
+    }
+    const fn ok_ptr_mut(
+        storage: *mut Storage<<Self as IStable>::Size, <Self as IStable>::Align>,
+    ) -> *mut Ok {
+        unsafe { storage.cast::<u8>().add(Self::OK_OFFSET).cast() }
+    }
+    const fn err_ptr(
+        storage: *const Storage<<Self as IStable>::Size, <Self as IStable>::Align>,
+    ) -> *const Err {
+        unsafe { storage.cast::<u8>().add(Self::ERR_OFFSET).cast() }
+    }
+    const fn err_ptr_mut(
+        storage: *mut Storage<<Self as IStable>::Size, <Self as IStable>::Align>,
+    ) -> *mut Err {
+        unsafe { storage.cast::<u8>().add(Self::ERR_OFFSET).cast() }
+    }
+    const fn det_ptr(
+        storage: *const Storage<<Self as IStable>::Size, <Self as IStable>::Align>,
+    ) -> *const Determinant<Ok, Err> {
+        storage.cast()
+    }
+    const fn det_ptr_mut(
+        storage: *mut Storage<<Self as IStable>::Size, <Self as IStable>::Align>,
+    ) -> *mut Determinant<Ok, Err> {
+        storage.cast()
+    }
     /// Construct the `Ok` variant.
     #[allow(non_snake_case)]
     pub fn Ok(value: Ok) -> Self {
-        let mut union = core::mem::MaybeUninit::new(Union {
-            ok: core::mem::ManuallyDrop::new(Padded {
-                lpad: Default::default(),
-                value,
-            }),
-        });
-        let determinant = unsafe {
-            <Ok as IDeterminantProvider<Err>>::Determinant::ok(union.as_mut_ptr().cast())
-        };
-        Self {
-            niche_exporter: Default::default(),
-            determinant,
-            union,
+        let mut storage = core::mem::MaybeUninit::zeroed();
+        unsafe {
+            let storage_ptr = storage.as_mut_ptr();
+            Self::ok_ptr_mut(storage_ptr).write(value);
+            Self::det_ptr_mut(storage_ptr).write(Determinant::<Ok, Err>::ok(storage_ptr.cast()));
+            Self {
+                storage: storage.assume_init(),
+            }
         }
     }
     /// Construct the `Err` variant.
     #[allow(non_snake_case)]
     pub fn Err(value: Err) -> Self {
-        let mut union = core::mem::MaybeUninit::new(Union {
-            err: core::mem::ManuallyDrop::new(Padded {
-                lpad: Default::default(),
-                value,
-            }),
-        });
-        let determinant = unsafe {
-            <Ok as IDeterminantProvider<Err>>::Determinant::err(union.as_mut_ptr().cast())
-        };
-        Self {
-            niche_exporter: Default::default(),
-            determinant,
-            union,
+        let mut storage = core::mem::MaybeUninit::zeroed();
+        unsafe {
+            let storage_ptr = storage.as_mut_ptr();
+            Self::err_ptr_mut(storage_ptr).write(value);
+            Self::det_ptr_mut(storage_ptr).write(Determinant::<Ok, Err>::err(storage_ptr.cast()));
+            Self {
+                storage: storage.assume_init(),
+            }
         }
     }
     /// Converts to a standard [`Result`](core::result::Result) of immutable references to the variants.
@@ -262,12 +337,15 @@ where
         err: FnErr,
     ) -> U {
         let is_ok = self.is_ok();
-        let union = unsafe { self.union.assume_init_read() };
-        core::mem::forget(self);
+        let storage = &self.storage;
         if is_ok {
-            ok(core::mem::ManuallyDrop::into_inner(unsafe { union.ok }).value)
+            let t = unsafe { core::ptr::read(Self::ok_ptr(storage)) };
+            core::mem::forget(self);
+            ok(t)
         } else {
-            err(core::mem::ManuallyDrop::into_inner(unsafe { union.err }).value)
+            let t = unsafe { core::ptr::read(Self::err_ptr(storage)) };
+            core::mem::forget(self);
+            err(t)
         }
     }
     /// Equivalent to `match self`.
@@ -278,24 +356,20 @@ where
         err: FnErr,
     ) -> U {
         let is_ok = self.is_ok();
-        let union = unsafe { self.union.assume_init_read() };
-        core::mem::forget(self);
+        let storage = &self.storage;
         if is_ok {
-            ok(
-                ctx,
-                core::mem::ManuallyDrop::into_inner(unsafe { union.ok }).value,
-            )
+            let t = unsafe { core::ptr::read(Self::ok_ptr(storage)) };
+            core::mem::forget(self);
+            ok(ctx, t)
         } else {
-            err(
-                ctx,
-                core::mem::ManuallyDrop::into_inner(unsafe { union.err }).value,
-            )
+            let t = unsafe { core::ptr::read(Self::err_ptr(storage)) };
+            core::mem::forget(self);
+            err(ctx, t)
         }
     }
     /// Returns `true` if in the `Ok` variant.
     pub fn is_ok(&self) -> bool {
-        self.determinant
-            .is_det_ok(&self.union as *const _ as *const _)
+        unsafe { &*Self::det_ptr(&self.storage) }.is_det_ok(self.storage.as_ptr())
     }
     /// Returns `true` if in the `Err` variant.
     pub fn is_err(&self) -> bool {
@@ -373,11 +447,11 @@ where
     {
         self.unwrap_err_or_else(|e| panic!("Result::unwrap_err called on Ok variant: {e:?}"))
     }
-    unsafe fn ok_unchecked(&self) -> &Ok {
-        &self.union.assume_init_ref().ok.value
+    const unsafe fn ok_unchecked(&self) -> &Ok {
+        &*Self::ok_ptr(&self.storage)
     }
-    unsafe fn err_unchecked(&self) -> &Err {
-        &self.union.assume_init_ref().err.value
+    const unsafe fn err_unchecked(&self) -> &Err {
+        &*Self::err_ptr(&self.storage)
     }
     unsafe fn ok_mut_unchecked(&mut self) -> OkGuard<'_, Ok, Err> {
         OkGuard { inner: self }
@@ -405,7 +479,7 @@ where
 {
     type Target = Ok;
     fn deref(&self) -> &Self::Target {
-        unsafe { &self.inner.union.assume_init_ref().ok.value }
+        unsafe { self.inner.ok_unchecked() }
     }
 }
 impl<'a, Ok, Err> core::ops::DerefMut for OkGuard<'a, Ok, Err>
@@ -414,7 +488,7 @@ where
     Err: IStable,
 {
     fn deref_mut(&mut self) -> &mut Self::Target {
-        unsafe { &mut self.inner.union.assume_init_mut().ok.value }
+        unsafe { &mut *Result::<Ok, Err>::ok_ptr_mut(&mut self.inner.storage) }
     }
 }
 impl<'a, Ok, Err> Drop for OkGuard<'a, Ok, Err>
@@ -423,10 +497,8 @@ where
     Err: IStable,
 {
     fn drop(&mut self) {
-        if <<<Ok as IDeterminantProvider<Err>>::Determinant as IDeterminant>::IsNicheTrick as Bit>::BOOL {
-            unsafe {
-                <Ok as IDeterminantProvider<Err>>::Determinant::ok(self.inner.union.as_mut_ptr().cast())
-            };
+        if <<Determinant<Ok, Err> as IDeterminant>::IsNicheTrick as Bit>::BOOL {
+            unsafe { Determinant::<Ok, Err>::ok(self.inner.storage.as_mut_ptr()) };
         }
     }
 }
@@ -450,7 +522,7 @@ where
 {
     type Target = Err;
     fn deref(&self) -> &Self::Target {
-        unsafe { &self.inner.union.assume_init_ref().err.value }
+        unsafe { self.inner.err_unchecked() }
     }
 }
 impl<'a, Ok, Err> core::ops::DerefMut for ErrGuard<'a, Ok, Err>
@@ -459,7 +531,7 @@ where
     Err: IStable,
 {
     fn deref_mut(&mut self) -> &mut Self::Target {
-        unsafe { &mut self.inner.union.assume_init_mut().err.value }
+        unsafe { &mut *Result::<Ok, Err>::err_ptr_mut(&mut self.inner.storage) }
     }
 }
 impl<'a, Ok, Err> Drop for ErrGuard<'a, Ok, Err>
@@ -468,12 +540,8 @@ where
     Err: IStable,
 {
     fn drop(&mut self) {
-        if <<<Ok as IDeterminantProvider<Err>>::Determinant as IDeterminant>::IsNicheTrick as Bit>::BOOL {
-            unsafe {
-                <Ok as IDeterminantProvider<Err>>::Determinant::err(
-                    self.inner.union.as_mut_ptr().cast(),
-                )
-            };
+        if <<Determinant<Ok, Err> as IDeterminant>::IsNicheTrick as Bit>::BOOL {
+            unsafe { Determinant::<Ok, Err>::err(self.inner.storage.as_mut_ptr()) };
         }
     }
 }
diff --git a/stabby-abi/src/typenum2/unsigned.rs b/stabby-abi/src/typenum2/unsigned.rs
index f5051c8..1d44580 100644
--- a/stabby-abi/src/typenum2/unsigned.rs
+++ b/stabby-abi/src/typenum2/unsigned.rs
@@ -22,7 +22,7 @@ use typenames::*;
 
 use crate::{
     istable::{IBitMask, IForbiddenValues, ISaturatingAdd, ISingleForbiddenValue, Saturator},
-    Array, End, IStable,
+    Array, End, IStable, Tuple,
 };
 /// (unsigned)0
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
@@ -76,6 +76,10 @@ pub trait IBitBase {
     /// Support for [`IBit`]
     type _SaddTernary<A: ISaturatingAdd, B: ISaturatingAdd>: ISaturatingAdd;
     /// Support for [`IBit`]
+    type _StabTernary<A: IStable, B: IStable>: IStable;
+    /// Ternary for Aligments
+    type _ATernary<A: Alignment, B: Alignment>: Alignment;
+    /// Support for [`IBit`]
     type AsForbiddenValue: ISingleForbiddenValue;
 }
 /// false
@@ -95,6 +99,8 @@ impl IBitBase for B0 {
     type _FvTernary<A: IForbiddenValues, B: IForbiddenValues> = B;
     type _UbTernary<A: IBitMask, B: IBitMask> = B;
     type _SaddTernary<A: ISaturatingAdd, B: ISaturatingAdd> = B;
+    type _StabTernary<A: IStable, B: IStable> = B;
+    type _ATernary<A: Alignment, B: Alignment> = B;
     type AsForbiddenValue = Saturator;
 }
 /// true
@@ -114,6 +120,8 @@ impl IBitBase for B1 {
     type _FvTernary<A: IForbiddenValues, B: IForbiddenValues> = A;
     type _UbTernary<A: IBitMask, B: IBitMask> = A;
     type _SaddTernary<A: ISaturatingAdd, B: ISaturatingAdd> = A;
+    type _StabTernary<A: IStable, B: IStable> = A;
+    type _ATernary<A: Alignment, B: Alignment> = A;
     type AsForbiddenValue = End;
 }
 /// A boolean. [`B0`] and [`B1`] are the canonical members of this type-class
@@ -144,6 +152,8 @@ pub trait IBit: IBitBase {
     type UbTernary<A: IBitMask, B: IBitMask>: IBitMask;
     /// Self ? A : B, preserving bounds.
     type SaddTernary<A: ISaturatingAdd, B: ISaturatingAdd>: ISaturatingAdd;
+    /// Self ? A : B, preserving bounds.
+    type StabTernary<A: IStable, B: IStable>: IStable;
     /// !(Self & Other)
     type Nand<T: IBit>: IBit + Sized;
     /// Self ^ Other
@@ -173,6 +183,7 @@ impl<Bit: IBitBase> IBit for Bit {
     type FvTernary<A: IForbiddenValues, B: IForbiddenValues> = Self::_FvTernary<A, B>;
     type UbTernary<A: IBitMask, B: IBitMask> = Self::_UbTernary<A, B>;
     type SaddTernary<A: ISaturatingAdd, B: ISaturatingAdd> = Self::_SaddTernary<A, B>;
+    type StabTernary<A: IStable, B: IStable> = Self::_StabTernary<A, B>;
     type Nand<T: IBit> = <Self::_And<T> as IBitBase>::_Not;
     type Xor<T: IBit> = <Self::_And<T::_Not> as IBitBase>::_Or<T::_And<Self::_Not>>;
     type Equals<T: IBit> = <Self::Xor<T> as IBitBase>::_Not;
@@ -225,6 +236,12 @@ pub trait IUnsignedBase {
     type _NonZero: NonZero;
     /// Support for [`IUnsigned`]
     type _Mul<T: IUnsigned>: IUnsigned;
+    /// Generates the bitmask for a Self bytes long padding.
+    type PaddingBitMask: IBitMask;
+    /// Helper for [`IUnsignedBase::Array`]
+    type _AddToArray<LsbArray: IStable, ArrayStack: IStable>: IStable;
+    /// Generates a type that has the same layout as `[T; Self]`
+    type Array<T: IStable>: IStable;
 }
 /// A is smaller than B if `A::Cmp<B>` = Lesser.
 pub struct Lesser;
@@ -295,6 +312,10 @@ pub trait IPowerOf2: IUnsigned {
     type Min<T: IPowerOf2>: IPowerOf2;
     /// max(Self, T)
     type Max<T: IPowerOf2>: IPowerOf2;
+    /// T % Self
+    type Modulate<T: IUnsigned>: IUnsigned;
+    /// T / Self
+    type Divide<T: IUnsigned>: IUnsigned;
 }
 impl<U: IUnsignedBase> IUnsigned for U {
     const U128: u128 = Self::_U128;
@@ -319,7 +340,7 @@ impl<U: IUnsignedBase> IUnsigned for U {
     type Min<T: IUnsigned> = <Self::Greater<T> as IBit>::UTernary<T, Self>;
     type Max<T: IUnsigned> = <Self::Greater<T> as IBit>::UTernary<Self, T>;
     type Truncate<T: IUnsigned> = <Self::_Truncate<T> as IUnsignedBase>::_Simplified;
-    type Mod<T: IPowerOf2> = Self::Truncate<T::Log2>;
+    type Mod<T: IPowerOf2> = T::Modulate<Self>;
     type Padding = Self::_Padding;
     type NonZero = Self::_NonZero;
     type NextMultipleOf<T: IPowerOf2> =
@@ -350,6 +371,9 @@ impl IUnsignedBase for UTerm {
     type _TruncateAtRightmostOne = Saturator;
     type _NonZero = Saturator;
     type _Mul<T: IUnsigned> = UTerm;
+    type PaddingBitMask = End;
+    type _AddToArray<LsbArray: IStable, ArrayStack: IStable> = LsbArray;
+    type Array<T: IStable> = ();
 }
 impl IUnsignedBase for Saturator {
     #[cfg(not(doc))]
@@ -374,6 +398,9 @@ impl IUnsignedBase for Saturator {
     type _TruncateAtRightmostOne = Saturator;
     type _NonZero = Saturator;
     type _Mul<T: IUnsigned> = Saturator;
+    type PaddingBitMask = End;
+    type _AddToArray<LsbArray: IStable, ArrayStack: IStable> = ();
+    type Array<T: IStable> = ();
 }
 
 /// A non-zero unsigned number.
@@ -436,16 +463,65 @@ impl<Msb: IUnsigned, Bit: IBit> IUnsignedBase for UInt<Msb, Bit> {
     type _Mul<T: IUnsigned> = <Bit::UTernary<T, UTerm> as IUnsigned>::Add<
         <UInt<Msb::Mul<T>, B0> as IUnsignedBase>::_Simplified,
     >;
+    type PaddingBitMask = Array<
+        U0,
+        U255,
+        <<Self::_SatDecrement as IUnsignedBase>::PaddingBitMask as IBitMask>::Shift<U1>,
+    >;
+    type _AddToArray<LsbArray: IStable, ArrayStack: IStable> = Msb::_AddToArray<
+        Bit::StabTernary<
+            <<LsbArray::Size as IUnsignedBase>::_IsUTerm as IBit>::StabTernary<
+                ArrayStack,
+                Tuple<ArrayStack, LsbArray>,
+            >,
+            LsbArray,
+        >,
+        Tuple<ArrayStack, ArrayStack>,
+    >;
+    type Array<T: IStable> = Self::_AddToArray<(), T>;
 }
 impl<Msb: IUnsigned<_IsUTerm = B1>> IPowerOf2 for UInt<Msb, B1> {
     type Log2 = U0;
     type Min<T: IPowerOf2> = <Self::Greater<T> as IBit>::PTernary<T, Self>;
     type Max<T: IPowerOf2> = <Self::Greater<T> as IBit>::PTernary<Self, T>;
+    type Modulate<T: IUnsigned> = UTerm;
+    type Divide<T: IUnsigned> = T;
 }
 impl<Msb: IPowerOf2> IPowerOf2 for UInt<Msb, B0> {
     type Log2 = <Msb::Log2 as IUnsignedBase>::Increment;
     type Min<T: IPowerOf2> = <Self::Greater<T> as IBit>::PTernary<T, Self>;
     type Max<T: IPowerOf2> = <Self::Greater<T> as IBit>::PTernary<Self, T>;
+    type Modulate<T: IUnsigned> =
+        <UInt<Msb::Modulate<T::Msb>, T::Bit> as IUnsignedBase>::_Simplified;
+    type Divide<T: IUnsigned> = Msb::Divide<T::Msb>;
+}
+
+/// An alignment that `stabby` can build an array arround.
+pub trait Alignment: IPowerOf2 {
+    /// max(Self, T)
+    type Max<T: Alignment>: Alignment;
+    /// A type with size and aligment equal to Self
+    type AsUint: Copy + Default + IStable;
+}
+impl Alignment for U1 {
+    type Max<T: Alignment> = <Self::Greater<T> as IBitBase>::_ATernary<Self, T>;
+    type AsUint = u8;
+}
+impl Alignment for U2 {
+    type Max<T: Alignment> = <Self::Greater<T> as IBitBase>::_ATernary<Self, T>;
+    type AsUint = u16;
+}
+impl Alignment for U4 {
+    type Max<T: Alignment> = <Self::Greater<T> as IBitBase>::_ATernary<Self, T>;
+    type AsUint = u32;
+}
+impl Alignment for U8 {
+    type Max<T: Alignment> = <Self::Greater<T> as IBitBase>::_ATernary<Self, T>;
+    type AsUint = u64;
+}
+impl Alignment for U16 {
+    type Max<T: Alignment> = <Self::Greater<T> as IBitBase>::_ATernary<Self, T>;
+    type AsUint = u128;
 }
 
 #[test]
@@ -574,6 +650,7 @@ fn ops() {
     let _: U2 = <<U10 as IUnsigned>::BitAnd<U6>>::default();
     let _: B1 = <<U2 as IUnsigned>::Equal<<U10 as IUnsigned>::BitAnd<U6>>>::default();
     let _: B0 = <<U3 as IUnsigned>::Equal<<U10 as IUnsigned>::BitAnd<U6>>>::default();
+    let _: U11 = <<U16 as IPowerOf2>::Modulate<U11>>::default();
     let _: U11 = <<U11 as IUnsigned>::Mod<U16>>::default();
     let _: U10 = <<U10 as IUnsigned>::Mod<U16>>::default();
     let _: U3 = <<U11 as IUnsigned>::Mod<U8>>::default();
@@ -585,6 +662,11 @@ fn ops() {
     let _: U0 = <<U10 as IUnsigned>::Mod<U1>>::default();
     let _: U255 = UxFF::default();
     let _: Ub111100 = <<Ub11111100 as IUnsigned>::BitAnd<Ub111111>>::default();
+    let _: U0 = <<U0 as IUnsigned>::NextMultipleOf<U8>>::default();
+    let _: U16 = <<U10 as IUnsigned>::NextMultipleOf<U8>>::default();
+    let _: U16 = <<U16 as IUnsigned>::NextMultipleOf<U8>>::default();
+    let _: U32 = <<U26 as IUnsigned>::NextMultipleOf<U8>>::default();
+    let _: U32 = <<U26 as IUnsigned>::NextMultipleOf<U32>>::default();
     assert_eq!(U0::_U128, 0);
     assert_eq!(U1::_U128, 1);
     assert_eq!(U2::_U128, 2);
@@ -592,4 +674,7 @@ fn ops() {
     assert_eq!(U4::_U128, 4);
     assert_eq!(U5::_U128, 5);
     assert_eq!(U10::_U128, 10);
+    unsafe { core::mem::transmute::<_, <U22 as IUnsignedBase>::Array<u8>>([0u8; 22]) };
+    unsafe { core::mem::transmute::<_, <U122 as IUnsignedBase>::Array<u16>>([0u16; 122]) };
+    unsafe { core::mem::transmute::<[u8; 0], <U0 as IUnsignedBase>::Array<u8>>([]) };
 }
diff --git a/stabby-abi/src/vtable.rs b/stabby-abi/src/vtable.rs
index 64010b5..cebf5ba 100644
--- a/stabby-abi/src/vtable.rs
+++ b/stabby-abi/src/vtable.rs
@@ -12,21 +12,138 @@
 //   Pierre Avital, <pierre.avital@me.com>
 //
 
-use crate as stabby;
+use crate::{self as stabby};
+use core::{
+    hash::{Hash, Hasher},
+    marker::PhantomData,
+    ptr::NonNull,
+};
 
 #[rustversion::nightly]
 /// Implementation detail for stabby's version of dyn traits.
 /// Any type that implements a trait `ITrait` must implement `IConstConstructor<VtITrait>` for `stabby::dyn!(Ptr<ITrait>)::from(value)` to work.
 pub trait IConstConstructor<'a, Source>: 'a + Copy + core::marker::Freeze {
     /// The vtable.
-    const VTABLE: &'a Self;
+    const VTABLE: Self;
+    /// A reference to the vtable
+    const VTABLE_REF: &'a Self = &Self::VTABLE;
+    /// Returns the reference to the vtable
+    fn vtable() -> &'a Self {
+        Self::VTABLE_REF
+    }
 }
-#[rustversion::not(nightly)]
+
+#[rustversion::before(1.78.0)]
 /// Implementation detail for stabby's version of dyn traits.
 /// Any type that implements a trait `ITrait` must implement `IConstConstructor<VtITrait>` for `stabby::dyn!(Ptr<ITrait>)::from(value)` to work.
 pub trait IConstConstructor<'a, Source>: 'a + Copy {
     /// The vtable.
-    const VTABLE: &'a Self;
+    const VTABLE: Self;
+    /// A reference to the vtable
+    const VTABLE_REF: &'a Self = &Self::VTABLE;
+    /// Returns the reference to the vtable
+    fn vtable() -> &'a Self {
+        Self::VTABLE_REF
+    }
+}
+
+#[cfg(feature = "libc")]
+#[rustversion::all(since(1.78.0), not(nightly))]
+/// Implementation detail for stabby's version of dyn traits.
+/// Any type that implements a trait `ITrait` must implement `IConstConstructor<VtITrait>` for `stabby::dyn!(Ptr<ITrait>)::from(value)` to work.
+pub trait IConstConstructor<'a, Source>: 'a + Copy + core::hash::Hash + core::fmt::Debug {
+    /// The vtable.
+    const VTABLE: Self;
+    /// Returns the reference to the vtable
+    fn vtable() -> &'a Self {
+        static VTABLES: core::sync::atomic::AtomicPtr<
+            crate::alloc::vec::Vec<(
+                u64,
+                crate::alloc::AllocPtr<*const (), crate::alloc::DefaultAllocator>,
+            )>,
+        > = core::sync::atomic::AtomicPtr::new(core::ptr::null_mut());
+        use crate::alloc::{boxed::Box, vec::Vec, AllocPtr, DefaultAllocator};
+        let vtable = Self::VTABLE;
+        #[allow(deprecated)]
+        let hash = {
+            let mut hasher = core::hash::SipHasher::new();
+            vtable.hash(&mut hasher);
+            hasher.finish()
+        };
+        fn insert_vtable(hash: u64, vtable: &[*const ()]) -> AllocPtr<*const (), DefaultAllocator> {
+            let mut search_start = 0;
+            let mut allocated_vt = None;
+            let mut vtables = VTABLES.load(core::sync::atomic::Ordering::SeqCst);
+            loop {
+                let vts = match unsafe { vtables.as_ref() } {
+                    None => [].as_slice(),
+                    Some(vts) => match vts[search_start..]
+                        .iter()
+                        .find_map(|e| (e.0 == hash).then_some(e.1))
+                    {
+                        Some(vt) => return vt,
+                        None => vts,
+                    },
+                };
+                let vt = allocated_vt.unwrap_or_else(|| {
+                    let mut ptr =
+                        AllocPtr::alloc_array(&mut DefaultAllocator::new(), vtable.len()).unwrap();
+                    unsafe {
+                        core::ptr::copy_nonoverlapping(vtable.as_ptr(), ptr.as_mut(), vtable.len())
+                    };
+                    ptr
+                });
+                allocated_vt = Some(vt);
+                let updated = VTABLES.load(core::sync::atomic::Ordering::SeqCst);
+                if !core::ptr::eq(vtables, updated) {
+                    vtables = updated;
+                    continue;
+                }
+                let mut vec = Vec::with_capacity(vts.len() + 1);
+                vec.copy_extend(vts);
+                vec.push((hash, vt));
+                let mut vec = Box::into_raw(Box::new(vec));
+                match VTABLES.compare_exchange(
+                    updated,
+                    unsafe { vec.as_mut() },
+                    core::sync::atomic::Ordering::SeqCst,
+                    core::sync::atomic::Ordering::SeqCst,
+                ) {
+                    Ok(updated) => {
+                        if let Some(updated) = NonNull::new(updated) {
+                            unsafe {
+                                Box::from_raw(AllocPtr {
+                                    ptr: updated,
+                                    marker: PhantomData::<DefaultAllocator>,
+                                })
+                            };
+                        }
+                        return vt;
+                    }
+                    Err(new_vtables) => {
+                        search_start = vts.len();
+                        vtables = new_vtables;
+                        unsafe { Box::from_raw(vec) };
+                    }
+                }
+            }
+        }
+        unsafe {
+            let vtable = core::slice::from_raw_parts(
+                (&vtable as *const Self).cast(),
+                core::mem::size_of::<Self>() / core::mem::size_of::<*const ()>(),
+            );
+            let vt = insert_vtable(hash, vtable).cast().as_ref();
+            debug_assert_eq!(
+                core::slice::from_raw_parts(
+                    (vt as *const Self).cast::<*const ()>(),
+                    core::mem::size_of::<Self>() / core::mem::size_of::<*const ()>(),
+                ),
+                vtable
+            );
+            vt
+        }
+    }
 }
 
 /// Implementation detail for stabby's version of dyn traits.
@@ -42,7 +159,7 @@ pub struct T<T>(T);
 /// You should _always_ use `stabby::vtable!(Trait1 + Trait2 + ...)` to generate this type,
 /// as this macro will ensure that traits are ordered consistently in the vtable.
 #[stabby::stabby]
-#[derive(Clone, Copy, PartialEq, Eq)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 pub struct VTable<Head, Tail = VtDrop> {
     /// The rest of the vtable.
     ///
@@ -63,13 +180,13 @@ where
     Head: IConstConstructor<'a, T>,
     Tail: IConstConstructor<'a, T>,
 {
-    const VTABLE: &'a VTable<Head, Tail> = &VTable {
-        head: *Head::VTABLE,
-        tail: *Tail::VTABLE,
+    const VTABLE: VTable<Head, Tail> = VTable {
+        head: Head::VTABLE,
+        tail: Tail::VTABLE,
     };
 }
 impl<'a, T> IConstConstructor<'a, T> for () {
-    const VTABLE: &'a () = &();
+    const VTABLE: () = ();
 }
 impl<Head, Tail> TransitiveDeref<Head, H> for VTable<Head, Tail> {
     fn tderef(&self) -> &Head {
@@ -122,11 +239,21 @@ impl<Head, Tail: HasSyncVt> HasSyncVt for VTable<Head, Tail> {}
 // DROP
 /// The vtable to drop a value in place
 #[stabby::stabby]
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Eq)]
 pub struct VtDrop {
     /// The [`Drop::drop`] function, shimmed with the C calling convention.
     pub drop: crate::StableLike<unsafe extern "C" fn(&mut ()), core::num::NonZeroUsize>,
 }
+impl core::fmt::Debug for VtDrop {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "VtDrop({:p})", unsafe { self.drop.as_ref_unchecked() })
+    }
+}
+impl Hash for VtDrop {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        self.drop.hash(state)
+    }
+}
 impl PartialEq for VtDrop {
     fn eq(&self, other: &Self) -> bool {
         core::ptr::eq(
@@ -136,7 +263,7 @@ impl PartialEq for VtDrop {
     }
 }
 impl<'a, T> IConstConstructor<'a, T> for VtDrop {
-    const VTABLE: &'a VtDrop = &VtDrop {
+    const VTABLE: VtDrop = VtDrop {
         drop: unsafe {
             core::mem::transmute({
                 unsafe extern "C" fn drop<T>(this: &mut T) {
@@ -150,7 +277,7 @@ impl<'a, T> IConstConstructor<'a, T> for VtDrop {
 
 /// A marker for vtables for types that are `Send`
 #[stabby::stabby]
-#[derive(Clone, Copy, PartialEq, Eq)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 pub struct VtSend<T>(pub T);
 impl CompoundVt for dyn Send {
     type Vt<T> = VtSend<T>;
@@ -166,18 +293,18 @@ impl<Head, Tail> From<crate::vtable::VtSend<VTable<Head, Tail>>> for VTable<Head
     }
 }
 impl<'a, T: Send, Vt: IConstConstructor<'a, T>> IConstConstructor<'a, T> for VtSend<Vt> {
-    const VTABLE: &'a VtSend<Vt> = &VtSend(*Vt::VTABLE);
+    const VTABLE: VtSend<Vt> = VtSend(Vt::VTABLE);
 }
 
 /// A marker for vtables for types that are `Sync`
 #[stabby::stabby]
-#[derive(Clone, Copy, PartialEq, Eq)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
 pub struct VtSync<T>(pub T);
 impl CompoundVt for dyn Sync {
     type Vt<T> = VtSync<T>;
 }
 impl<'a, T: Sync, Vt: IConstConstructor<'a, T>> IConstConstructor<'a, T> for VtSync<Vt> {
-    const VTABLE: &'a VtSync<Vt> = &VtSync(*Vt::VTABLE);
+    const VTABLE: VtSync<Vt> = VtSync(Vt::VTABLE);
 }
 impl<Tail: TransitiveDeref<Vt, N>, Vt, N> TransitiveDeref<Vt, N> for VtSync<Tail> {
     fn tderef(&self) -> &Vt {
@@ -207,9 +334,14 @@ impl<Head, Tail> From<crate::vtable::VtSync<VTable<Head, Tail>>> for VTable<Head
 pub trait Any {
     /// The report of the type.
     extern "C" fn report(&self) -> &'static crate::report::TypeReport;
+    /// The id of the type.
+    extern "C" fn id(&self) -> u64;
 }
 impl<T: crate::IStable> Any for T {
     extern "C" fn report(&self) -> &'static crate::report::TypeReport {
         Self::REPORT
     }
+    extern "C" fn id(&self) -> u64 {
+        Self::ID
+    }
 }
diff --git a/stabby-macros/Cargo.toml b/stabby-macros/Cargo.toml
index 2da4657..fe0f2e6 100644
--- a/stabby-macros/Cargo.toml
+++ b/stabby-macros/Cargo.toml
@@ -14,7 +14,7 @@
 
 [package]
 name = "stabby-macros"
-version = "4.0.5"
+version = "5.0.0"
 edition = "2021"
 authors = { workspace = true }
 license = { workspace = true }
diff --git a/stabby-macros/src/traits.rs b/stabby-macros/src/traits.rs
index 55bb2c6..fd937fe 100644
--- a/stabby-macros/src/traits.rs
+++ b/stabby-macros/src/traits.rs
@@ -654,6 +654,8 @@ impl<'a> DynTraitDescription<'a> {
                 )*
             }
         };
+        let vtid_str = vtid.to_string();
+        let all_fn_ids_str = all_fn_ids.iter().map(|id| id.to_string());
         vtable_decl = crate::stabby(proc_macro::TokenStream::new(), vtable_decl.into()).into();
         quote! {
             #[doc = #vt_doc]
@@ -669,6 +671,18 @@ impl<'a> DynTraitDescription<'a> {
                     #(core::ptr::eq((*unsafe{self.#all_fn_ids.as_ref_unchecked()}) as *const (), (*unsafe{other.#all_fn_ids.as_ref_unchecked()}) as *const _) &&)* true
                 }
             }
+            impl< #vt_generics > core::hash::Hash for #vtid < #nbvt_generics > where #(#vt_bounds)*{
+                fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+                    #(self.#all_fn_ids.hash(state);)*
+                }
+            }
+            impl< #vt_generics > core::fmt::Debug for #vtid < #nbvt_generics > where #(#vt_bounds)*{
+                fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+                    let mut s = f.debug_struct(#vtid_str);
+                    #(s.field(#all_fn_ids_str, &core::format_args!("{:p}", unsafe{self.#all_fn_ids.as_ref_unchecked()}));)*
+                    s.finish()
+                }
+            }
 
             impl<
                 'stabby_vt_lt, #(#trait_lts,)*
@@ -683,7 +697,7 @@ impl<'a> DynTraitDescription<'a> {
                 #(#unbound_trait_types: 'stabby_vt_lt,)*
                 #(#dyntrait_types: 'stabby_vt_lt,)* {
                 #[doc = #vt_doc]
-                const VTABLE: &'stabby_vt_lt #vt_signature = & #vtid {
+                const VTABLE: #vt_signature =  #vtid {
                     #(#all_fn_ids: unsafe {core::mem::transmute(#self_as_trait::#all_fn_ids as #fn_ptrs)},)*
                 };
             }
diff --git a/stabby/Cargo.toml b/stabby/Cargo.toml
index ed9a402..ddb3fac 100644
--- a/stabby/Cargo.toml
+++ b/stabby/Cargo.toml
@@ -14,7 +14,7 @@
 
 [package]
 name = "stabby"
-version = "4.0.5"
+version = "5.0.0"
 edition = "2021"
 authors = { workspace = true }
 license = { workspace = true }
@@ -30,7 +30,7 @@ libloading = ["dep:libloading", "std"]
 libc = ["stabby-abi/libc"]
 
 [dependencies]
-stabby-abi = { path = "../stabby-abi/", version = "4.0.5" }
+stabby-abi = { path = "../stabby-abi/", version = "5.0.0" }
 
 lazy_static = { workspace = true }
 libloading = { workspace = true, optional = true }
diff --git a/stabby/tests/traits.rs b/stabby/tests/traits.rs
index cf3b1b1..326d727 100644
--- a/stabby/tests/traits.rs
+++ b/stabby/tests/traits.rs
@@ -129,24 +129,26 @@ impl<'b> AsyncRead for stabby::slice::Slice<'b, u8> {
 
 #[test]
 fn dyn_traits() {
+    let boxed = Box::new(6u8);
+    let dyned = <stabby::dynptr!(
+        Box<dyn MyTrait2 + stabby::Any + MyTrait3<Box<()>, A = u8, B = u8> + Send>
+    )>::from(boxed);
+    let dyned: stabby::dynptr!(Box<dyn MyTrait2 + stabby::Any + Send>) = dyned.into_super();
+    assert_eq!(dyned.stable_downcast_ref::<u8, _>(), Some(&6));
+    assert!(dyned.stable_downcast_ref::<u16, _>().is_none());
+
     let boxed = Box::new(6u8);
     let mut dyned = <stabby::dynptr!(
         Box<dyn Send + MyTrait2 + MyTrait3<Box<()>, A = u8, B = u8> + Sync + MyTrait<Output = u8>>
     )>::from(boxed);
-    assert_eq!(unsafe { dyned.downcast_ref::<u8>() }, Some(&6));
     assert_eq!(dyned.do_stuff(&0), &6);
     assert_eq!(dyned.gen_stuff(), 6);
     assert_eq!(dyned.gen_stuff3(Box::new(())), 6);
-    assert!(unsafe { dyned.downcast_ref::<u16>() }.is_none());
+    // assert_eq!(unsafe { dyned.downcast_ref::<u8>() }, Some(&6));
+    // assert!(unsafe { dyned.downcast_ref::<u16>() }.is_none());
+
     fn trait_assertions<T: Send + Sync + stabby::abi::IStable>(_t: T) {}
     trait_assertions(dyned);
-    let boxed = Box::new(6u8);
-    let dyned = <stabby::dynptr!(
-        Box<dyn MyTrait2 + stabby::Any + MyTrait3<Box<()>, A = u8, B = u8> + Send>
-    )>::from(boxed);
-    let dyned: stabby::dynptr!(Box<dyn MyTrait2 + stabby::Any + Send>) = dyned.into_super();
-    assert_eq!(dyned.stable_downcast_ref::<u8, _>(), Some(&6));
-    assert!(dyned.stable_downcast_ref::<u16, _>().is_none());
 }
 
 #[test]
@@ -155,9 +157,9 @@ fn arc_traits() {
     let boxed = Arc::new(6u8);
     let dyned =
         <stabby::dynptr!(Arc<dyn Send + MyTrait2 + Sync + MyTrait<Output = u8>>)>::from(boxed);
-    assert_eq!(unsafe { dyned.downcast_ref::<u8>() }, Some(&6));
     assert_eq!(dyned.do_stuff(&0), &6);
-    assert!(unsafe { dyned.downcast_ref::<u16>() }.is_none());
+    // assert_eq!(unsafe { dyned.downcast_ref::<u8>() }, Some(&6));
+    // assert!(unsafe { dyned.downcast_ref::<u16>() }.is_none());
     fn trait_assertions<T: Send + Sync + stabby::abi::IStable>(_t: T) {}
     trait_assertions(dyned);
     let boxed = Arc::new(6u8);