diff --git a/.gitattributes b/.gitattributes
index 25300b4ef..dd9d1a0c8 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -5,6 +5,9 @@ Makefile text eol=lf
 *.sh text eol=lf
 vendor/box2d/lib/box2d_windows_amd64_avx2.lib filter=lfs diff=lfs merge=lfs -text
 vendor/box2d/lib/box2d_windows_amd64_sse2.lib filter=lfs diff=lfs merge=lfs -text
+vendor/box3d/lib/linux-amd64/libbox3d.a filter=lfs diff=lfs merge=lfs -text
+vendor/box3d/lib/darwin/libbox3d.a filter=lfs diff=lfs merge=lfs -text
+vendor/box3d/lib/box3d.lib filter=lfs diff=lfs merge=lfs -text
 vendor/miniaudio/lib/miniaudio.lib filter=lfs diff=lfs merge=lfs -text
 vendor/sdl3/SDL3.dll filter=lfs diff=lfs merge=lfs -text
 vendor/sdl3/SDL3.lib filter=lfs diff=lfs merge=lfs -text
@@ -31,5 +34,3 @@ vendor/raylib/windows/raylibdll.lib filter=lfs diff=lfs merge=lfs -text
 vendor/raylib/windows/raygui.dll filter=lfs diff=lfs merge=lfs -text
 vendor/raylib/windows/raygui.lib filter=lfs diff=lfs merge=lfs -text
 vendor/raylib/windows/rayguidll.lib filter=lfs diff=lfs merge=lfs -text
-vendor/box3d/lib/linux-amd64/libbox3d.a filter=lfs diff=lfs merge=lfs -text
-vendor/box3d/lib/darwin/libbox3d.a filter=lfs diff=lfs merge=lfs -text
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 17a00c36a..b3ae67161 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -36,9 +36,9 @@ jobs:
           ./odin check examples/all -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -target:netbsd_arm64
           ./odin check examples/all/sdl3 -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -target:netbsd_amd64 -no-entry-point
           ./odin check examples/all/sdl3 -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -target:netbsd_arm64 -no-entry-point
-          ./odin test tests/core/normal.odin -file -all-packages -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -define:ODIN_TEST_FANCY=false -define:ODIN_TEST_FAIL_ON_BAD_MEMORY=true
-          ./odin test tests/core/speed.odin -file -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -o:speed -define:ODIN_TEST_FANCY=false -define:ODIN_TEST_FAIL_ON_BAD_MEMORY=true
-          ./odin test tests/vendor -all-packages -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -define:ODIN_TEST_FANCY=false -define:ODIN_TEST_FAIL_ON_BAD_MEMORY=true
+          ./odin test tests/core/normal.odin -file -all-packages -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -define:ODIN_TEST_FANCY=false -define:ODIN_TEST_FAIL_ON_BAD_MEMORY=true -microarch:native
+          ./odin test tests/core/speed.odin -file -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -o:speed -define:ODIN_TEST_FANCY=false -define:ODIN_TEST_FAIL_ON_BAD_MEMORY=true -microarch:native
+          ./odin test tests/vendor -all-packages -vet -vet-tabs -strict-style -vet-style -warnings-as-errors -disallow-do -define:ODIN_TEST_FANCY=false -define:ODIN_TEST_FAIL_ON_BAD_MEMORY=true -microarch:native
           (cd tests/issues; ./run.sh)
           ./odin check tests/benchmark -vet -strict-style -no-entry-point
 
diff --git a/base/intrinsics/intrinsics.odin b/base/intrinsics/intrinsics.odin
index e639aadbd..d91bc2e79 100644
--- a/base/intrinsics/intrinsics.odin
+++ b/base/intrinsics/intrinsics.odin
@@ -379,6 +379,7 @@ simd_pairwise_sub :: proc(a, b: #simd[LANES]T) -> #simd[LANES]T where LANES % 2
 simd_interleave   :: proc(a, ..#simd[LANES/N]T)       -> #simd[LANES]T where N >= 1 ---
 simd_deinterleave :: proc(a: #simd[LANES]T, $N: uint) -> (..#simd[LANES/N]T) where N >= 1, LANES % N == 0 --- // returns N multiple vectors
 
+soa_copy_from_slice :: proc(ptr: ^$A/#soa[dynamic]$E, offset: int, args: []$E) ---
 
 // Checks if the current target supports the given target features.
 //
diff --git a/base/runtime/core_builtin.odin b/base/runtime/core_builtin.odin
index e65cf56f0..4913b53d9 100644
--- a/base/runtime/core_builtin.odin
+++ b/base/runtime/core_builtin.odin
@@ -128,7 +128,7 @@ copy :: proc{copy_slice, copy_from_string, copy_from_string16}
 // Note: If you want the elements to remain in their order, use `ordered_remove`.
 // Note: If the index is out of bounds, this procedure will panic.
 @builtin
-unordered_remove_dynamic_array :: proc(array: ^$D/[dynamic]$T, #any_int index: int, loc := #caller_location) #no_bounds_check {
+unordered_remove_dynamic_array :: proc(#no_alias array: ^$D/[dynamic]$T, #any_int index: int, loc := #caller_location) #no_bounds_check {
 	bounds_check_error_loc(loc, index, len(array))
 	n := len(array)-1
 	if index != n {
@@ -142,7 +142,7 @@ unordered_remove_dynamic_array :: proc(array: ^$D/[dynamic]$T, #any_int index: i
 // Note: If the elements do not have to remain in their order, prefer `unordered_remove`.
 // Note: If the index is out of bounds, this procedure will panic.
 @builtin
-ordered_remove_dynamic_array :: proc(array: ^$D/[dynamic]$T, #any_int index: int, loc := #caller_location) #no_bounds_check {
+ordered_remove_dynamic_array :: proc(#no_alias array: ^$D/[dynamic]$T, #any_int index: int, loc := #caller_location) #no_bounds_check {
 	bounds_check_error_loc(loc, index, len(array))
 	if index+1 < len(array) {
 		copy(array[index:], array[index+1:])
@@ -155,7 +155,7 @@ ordered_remove_dynamic_array :: proc(array: ^$D/[dynamic]$T, #any_int index: int
 // Note: This is an O(N) operation.
 // Note: If the range is out of bounds, this procedure will panic.
 @builtin
-remove_range_dynamic_array :: proc(array: ^$D/[dynamic]$T, #any_int lo, hi: int, loc := #caller_location) #no_bounds_check {
+remove_range_dynamic_array :: proc(#no_alias array: ^$D/[dynamic]$T, #any_int lo, hi: int, loc := #caller_location) #no_bounds_check {
 	slice_expr_error_lo_hi_loc(loc, lo, hi, len(array))
 	n := max(hi-lo, 0)
 	if n > 0 {
@@ -236,13 +236,13 @@ remove_range :: proc{
 //
 // Note: If the dynamic array has no elements (`len(array) == 0`), this procedure will panic.
 @builtin
-pop_dynamic_array :: proc(array: ^$T/[dynamic]$E, loc := #caller_location) -> (res: E) #no_bounds_check {
+pop_dynamic_array :: proc(#no_alias array: ^$T/[dynamic]$E, loc := #caller_location) -> (res: E) #no_bounds_check {
 	assert(len(array) > 0, loc=loc)
 	_pop_dynamic_array_type_erased(&res, (^Raw_Dynamic_Array)(array), size_of(E))
 	return res
 }
 
-_pop_dynamic_array_type_erased :: proc(res: rawptr, array: ^Raw_Dynamic_Array, elem_size: int) {
+_pop_dynamic_array_type_erased :: proc(res: rawptr, #no_alias array: ^Raw_Dynamic_Array, elem_size: int) {
 	end := rawptr(uintptr(array.data) + uintptr(elem_size*(array.len-1)))
 	intrinsics.mem_copy_non_overlapping(res, end, elem_size)
 	array.len -= 1
@@ -276,7 +276,7 @@ pop :: proc{
 // `pop_safe_dynamic_array` trys to remove and return the end value of dynamic array `array` and reduces the length of `array` by 1.
 // If the operation is not possible, it will return false.
 @builtin
-pop_safe_dynamic_array :: proc "contextless" (array: ^$T/[dynamic]$E) -> (res: E, ok: bool) #no_bounds_check {
+pop_safe_dynamic_array :: proc "contextless" (#no_alias array: ^$T/[dynamic]$E) -> (res: E, ok: bool) #no_bounds_check {
 	if len(array) == 0 {
 		return
 	}
@@ -310,7 +310,7 @@ pop_safe :: proc{
 //
 // Note: If the dynamic array as no elements (`len(array) == 0`), this procedure will panic.
 @builtin
-pop_front_dynamic_array :: proc(array: ^$T/[dynamic]$E, loc := #caller_location) -> (res: E) #no_bounds_check {
+pop_front_dynamic_array :: proc(#no_alias array: ^$T/[dynamic]$E, loc := #caller_location) -> (res: E) #no_bounds_check {
 	assert(len(array) > 0, loc=loc)
 	res = array[0]
 	if len(array) > 1 {
@@ -348,7 +348,7 @@ pop_front :: proc{
 // `pop_front_safe_dynamic_array` trys to return and remove the first value of dynamic array `array` and reduces the length of `array` by 1.
 // If the operation is not possible, it will return false.
 @builtin
-pop_front_safe_dynamic_array :: proc "contextless" (array: ^$T/[dynamic]$E) -> (res: E, ok: bool) #no_bounds_check {
+pop_front_safe_dynamic_array :: proc "contextless" (#no_alias array: ^$T/[dynamic]$E) -> (res: E, ok: bool) #no_bounds_check {
 	if len(array) == 0 {
 		return
 	}
@@ -590,7 +590,7 @@ make_dynamic_array_len_cap :: proc($T: typeid/[dynamic]$E, #any_int len: int, #a
 }
 
 @(require_results)
-_make_dynamic_array_len_cap :: proc(array: ^Raw_Dynamic_Array, size_of_elem, align_of_elem: int, #any_int len: int, #any_int cap: int, allocator := context.allocator, loc := #caller_location) -> (err: Allocator_Error) {
+_make_dynamic_array_len_cap :: proc(#no_alias array: ^Raw_Dynamic_Array, size_of_elem, align_of_elem: int, #any_int len: int, #any_int cap: int, allocator := context.allocator, loc := #caller_location) -> (err: Allocator_Error) {
 	make_dynamic_array_error_loc(loc, len, cap)
 	array.allocator = allocator // initialize allocator before just in case it fails to allocate any memory
 	data := mem_alloc_bytes(size_of_elem*cap, align_of_elem, allocator, loc) or_return
@@ -716,7 +716,7 @@ when MAP_ENABLED {
 	}
 }
 
-_append_elem :: #force_no_inline proc(array: ^Raw_Dynamic_Array, size_of_elem, align_of_elem: int, arg_ptr: rawptr, should_zero: bool, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
+_append_elem :: #force_no_inline proc(#no_alias array: ^Raw_Dynamic_Array, size_of_elem, align_of_elem: int, arg_ptr: rawptr, should_zero: bool, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
 	if array == nil {
 		return
 	}
@@ -739,7 +739,7 @@ _append_elem :: #force_no_inline proc(array: ^Raw_Dynamic_Array, size_of_elem, a
 	return
 }
 
-_append_elem_ptr :: #force_no_inline proc(array: ^Raw_Dynamic_Array, arg: rawptr, should_zero: bool, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
+_append_elem_ptr :: #force_no_inline proc(#no_alias array: ^Raw_Dynamic_Array, arg: rawptr, should_zero: bool, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
 	if array == nil {
 		return
 	}
@@ -764,7 +764,7 @@ _append_elem_ptr :: #force_no_inline proc(array: ^Raw_Dynamic_Array, arg: rawptr
 
 // `append_elem` appends an element to the end of a dynamic array.
 @builtin
-append_elem :: proc(array: ^$T/[dynamic]$E, #no_broadcast arg: E, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
+append_elem :: proc(#no_alias array: ^$T/[dynamic]$E, #no_broadcast arg: E, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
 	when size_of(E) == 0 {
 		if array == nil {
 			return
@@ -806,7 +806,7 @@ append_elem :: proc(array: ^$T/[dynamic]$E, #no_broadcast arg: E, loc := #caller
 //
 // Note: Prefer using the procedure group `non_zero_append
 @builtin
-non_zero_append_elem :: proc(array: ^$T/[dynamic]$E, #no_broadcast arg: E, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
+non_zero_append_elem :: proc(#no_alias array: ^$T/[dynamic]$E, #no_broadcast arg: E, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
 	when size_of(E) == 0 {
 		(^Raw_Dynamic_Array)(array).len += 1
 		return 1, nil
@@ -841,7 +841,7 @@ non_zero_append_elem :: proc(array: ^$T/[dynamic]$E, #no_broadcast arg: E, loc :
 	}
 }
 
-_append_elems :: #force_no_inline proc(array: ^Raw_Dynamic_Array, size_of_elem, align_of_elem: int, should_zero: bool, loc := #caller_location, args: rawptr, arg_len: int) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
+_append_elems :: #force_no_inline proc(#no_alias array: ^Raw_Dynamic_Array, size_of_elem, align_of_elem: int, should_zero: bool, loc := #caller_location, args: rawptr, arg_len: int) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
 	if array == nil {
 		return 0, nil
 	}
@@ -872,7 +872,7 @@ _append_elems :: #force_no_inline proc(array: ^Raw_Dynamic_Array, size_of_elem,
 //
 // Note: Prefer using the procedure group `append`.
 @builtin
-append_elems :: proc(array: ^$T/[dynamic]$E, #no_broadcast args: ..E, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
+append_elems :: proc(#no_alias array: ^$T/[dynamic]$E, #no_broadcast args: ..E, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
 	when size_of(E) == 0 {
 		a := (^Raw_Dynamic_Array)(array)
 		a.len += len(args)
@@ -886,7 +886,7 @@ append_elems :: proc(array: ^$T/[dynamic]$E, #no_broadcast args: ..E, loc := #ca
 //
 // Note: Prefer using the procedure group `non_zero_append
 @builtin
-non_zero_append_elems :: proc(array: ^$T/[dynamic]$E, #no_broadcast args: ..E, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
+non_zero_append_elems :: proc(#no_alias array: ^$T/[dynamic]$E, #no_broadcast args: ..E, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
 	when size_of(E) == 0 {
 		a := (^Raw_Dynamic_Array)(array)
 		a.len += len(args)
@@ -897,7 +897,7 @@ non_zero_append_elems :: proc(array: ^$T/[dynamic]$E, #no_broadcast args: ..E, l
 }
 
 // The append_string built-in procedure appends a string to the end of a [dynamic]u8 like type
-_append_elem_string :: proc(array: ^$T/[dynamic]$E/u8, arg: $A/string, should_zero: bool, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
+_append_elem_string :: proc(#no_alias array: ^$T/[dynamic]$E/u8, arg: $A/string, should_zero: bool, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
 	return _append_elems((^Raw_Dynamic_Array)(array), 1, 1, should_zero, loc, raw_data(arg), len(arg))
 }
 
@@ -905,14 +905,14 @@ _append_elem_string :: proc(array: ^$T/[dynamic]$E/u8, arg: $A/string, should_ze
 //
 // Note: Prefer using the procedure group `append`.
 @builtin
-append_elem_string :: proc(array: ^$T/[dynamic]$E/u8, arg: $A/string, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
+append_elem_string :: proc(#no_alias array: ^$T/[dynamic]$E/u8, arg: $A/string, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
 	return _append_elem_string(array, arg, true, loc)
 }
 // `non_zero_append_elem_string` appends a string to the end of a dynamic array of bytes, without zeroing any reserved memory
 //
 // Note: Prefer using the procedure group `non_zero_append`.
 @builtin
-non_zero_append_elem_string :: proc(array: ^$T/[dynamic]$E/u8, arg: $A/string, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
+non_zero_append_elem_string :: proc(#no_alias array: ^$T/[dynamic]$E/u8, arg: $A/string, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
 	return _append_elem_string(array, arg, false, loc)
 }
 
@@ -930,7 +930,7 @@ non_zero_append_elem_fixed_capacity_string :: proc "contextless" (array: ^$T/[dy
 //
 // Note: Prefer using the procedure group `append`.
 @builtin
-append_string :: proc(array: ^$T/[dynamic]$E/u8, args: ..string, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
+append_string :: proc(#no_alias array: ^$T/[dynamic]$E/u8, args: ..string, loc := #caller_location) -> (num_appended: int, err: Allocator_Error) #optional_allocator_error {
 	n_arg: int
 	for arg in args {
 		n_arg, err = append(array, ..transmute([]E)(arg), loc=loc)
@@ -1026,7 +1026,7 @@ non_zero_append :: proc{
 // `append_nothing` appends an empty value to a dynamic array. It returns `1, nil` if successful, and `0, err` when it was not possible,
 // whatever `err` happens to be.
 @builtin
-append_nothing_dynamic_array :: proc(array: ^$T/[dynamic]$E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
+append_nothing_dynamic_array :: proc(#no_alias array: ^$T/[dynamic]$E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
 	if array == nil {
 		return 0, nil
 	}
@@ -1059,7 +1059,7 @@ append_nothing :: proc{
 
 // `inject_at_elem` injects an element in a dynamic array at a specified index and moves the previous elements after that index "across"
 @builtin
-inject_at_elem :: proc(array: ^$T/[dynamic]$E, #any_int index: int, #no_broadcast arg: E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
+inject_at_elem :: proc(#no_alias array: ^$T/[dynamic]$E, #any_int index: int, #no_broadcast arg: E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
 	when !ODIN_NO_BOUNDS_CHECK {
 		ensure(index >= 0, "Index must be positive.", loc)
 	}
@@ -1081,7 +1081,7 @@ inject_at_elem :: proc(array: ^$T/[dynamic]$E, #any_int index: int, #no_broadcas
 
 // `inject_at_elems` injects multiple elements in a dynamic array at a specified index and moves the previous elements after that index "across"
 @builtin
-inject_at_elems :: proc(array: ^$T/[dynamic]$E, #any_int index: int, #no_broadcast args: ..E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
+inject_at_elems :: proc(#no_alias array: ^$T/[dynamic]$E, #any_int index: int, #no_broadcast args: ..E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
 	when !ODIN_NO_BOUNDS_CHECK {
 		ensure(index >= 0, "Index must be positive.", loc)
 	}
@@ -1108,7 +1108,7 @@ inject_at_elems :: proc(array: ^$T/[dynamic]$E, #any_int index: int, #no_broadca
 
 // `inject_at_elem_string` injects a string into a dynamic array at a specified index and moves the previous elements after that index "across"
 @builtin
-inject_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, #any_int index: int, arg: string, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
+inject_at_elem_string :: proc(#no_alias array: ^$T/[dynamic]$E/u8, #any_int index: int, arg: string, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
 	when !ODIN_NO_BOUNDS_CHECK {
 		ensure(index >= 0, "Index must be positive.", loc)
 	}
@@ -1219,7 +1219,7 @@ inject_at :: proc{
 // `assign_at_elem` assigns a value at a given index. If the requested index is past the end of the current
 // size of the dynamic array, it will attempt to `resize` the a new length of `index+1` and then assign as `index`.
 @builtin
-assign_at_elem :: proc(array: ^$T/[dynamic]$E, #any_int index: int, arg: E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
+assign_at_elem :: proc(#no_alias array: ^$T/[dynamic]$E, #any_int index: int, arg: E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
 	if index < len(array) {
 		array[index] = arg
 		ok = true
@@ -1235,7 +1235,7 @@ assign_at_elem :: proc(array: ^$T/[dynamic]$E, #any_int index: int, arg: E, loc
 // `assign_at_elems` assigns a values at a given index. If the requested index is past the end of the current
 // size of the dynamic array, it will attempt to `resize` the a new length of `index+len(args)` and then assign as `index`.
 @builtin
-assign_at_elems :: proc(array: ^$T/[dynamic]$E, #any_int index: int, #no_broadcast args: ..E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
+assign_at_elems :: proc(#no_alias array: ^$T/[dynamic]$E, #any_int index: int, #no_broadcast args: ..E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
 	new_size := index + len(args)
 	if len(args) == 0 {
 		ok = true
@@ -1253,7 +1253,7 @@ assign_at_elems :: proc(array: ^$T/[dynamic]$E, #any_int index: int, #no_broadca
 // `assign_at_elem_string` assigns a string at a given index. If the requested index is past the end of the current
 // size of the dynamic array, it will attempt to `resize` the a new length of `index+len(arg)` and then assign as `index`.
 @builtin
-assign_at_elem_string :: proc(array: ^$T/[dynamic]$E/u8, #any_int index: int, arg: string, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
+assign_at_elem_string :: proc(#no_alias array: ^$T/[dynamic]$E/u8, #any_int index: int, arg: string, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
 	new_size := index + len(arg)
 	if len(arg) == 0 {
 		ok = true
@@ -1341,7 +1341,7 @@ assign_at :: proc{
 //
 // Note: Prefer the procedure group `clear`.
 @builtin
-clear_dynamic_array :: proc "contextless" (array: ^$T/[dynamic]$E) {
+clear_dynamic_array :: proc "contextless" (#no_alias array: ^$T/[dynamic]$E) {
 	if array != nil {
 		(^Raw_Dynamic_Array)(array).len = 0
 	}
@@ -1362,7 +1362,7 @@ clear_fixed_capacity_dynamic_array :: proc "contextless" (array: ^$T/[dynamic; $
 // When a memory resize allocation is required, the memory will be asked to be zeroed (i.e. it calls `mem_resize`).
 //
 // Note: Prefer the procedure group `reserve`.
-_reserve_dynamic_array :: #force_no_inline proc(a: ^Raw_Dynamic_Array, size_of_elem, align_of_elem: int, capacity: int, should_zero: bool, loc := #caller_location) -> Allocator_Error {
+_reserve_dynamic_array :: #force_no_inline proc(#no_alias a: ^Raw_Dynamic_Array, size_of_elem, align_of_elem: int, capacity: int, should_zero: bool, loc := #caller_location) -> Allocator_Error {
 	if a == nil {
 		return nil
 	}
@@ -1395,7 +1395,7 @@ _reserve_dynamic_array :: #force_no_inline proc(a: ^Raw_Dynamic_Array, size_of_e
 	return nil
 }
 
-_reserve_dynamic_array_unsafe :: #force_no_inline proc(a: ^Raw_Dynamic_Array, size_of_elem, align_of_elem: int, capacity: int, should_zero: bool, loc := #caller_location) -> Allocator_Error {
+_reserve_dynamic_array_unsafe :: #force_no_inline proc(#no_alias a: ^Raw_Dynamic_Array, size_of_elem, align_of_elem: int, capacity: int, should_zero: bool, loc := #caller_location) -> Allocator_Error {
 	if capacity <= a.cap {
 		return nil
 	}
@@ -1430,7 +1430,7 @@ _reserve_dynamic_array_unsafe :: #force_no_inline proc(a: ^Raw_Dynamic_Array, si
 //
 // Note: Prefer the procedure group `reserve`.
 @builtin
-reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, #any_int capacity: int, loc := #caller_location) -> Allocator_Error {
+reserve_dynamic_array :: proc(#no_alias array: ^$T/[dynamic]$E, #any_int capacity: int, loc := #caller_location) -> Allocator_Error {
 	return _reserve_dynamic_array((^Raw_Dynamic_Array)(array), size_of(E), align_of(E), capacity, true, loc)
 }
 
@@ -1440,12 +1440,12 @@ reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, #any_int capacity: int, lo
 //
 // Note: Prefer the procedure group `non_zero_reserve`.
 @builtin
-non_zero_reserve_dynamic_array :: proc(array: ^$T/[dynamic]$E, #any_int capacity: int, loc := #caller_location) -> Allocator_Error {
+non_zero_reserve_dynamic_array :: proc(#no_alias array: ^$T/[dynamic]$E, #any_int capacity: int, loc := #caller_location) -> Allocator_Error {
 	return _reserve_dynamic_array((^Raw_Dynamic_Array)(array), size_of(E), align_of(E), capacity, false, loc)
 }
 
 
-_resize_dynamic_array :: #force_no_inline proc(a: ^Raw_Dynamic_Array, size_of_elem, align_of_elem: int, length: int, should_zero: bool, loc := #caller_location) -> Allocator_Error {
+_resize_dynamic_array :: #force_no_inline proc(#no_alias a: ^Raw_Dynamic_Array, size_of_elem, align_of_elem: int, length: int, should_zero: bool, loc := #caller_location) -> Allocator_Error {
 	if a == nil {
 		return nil
 	}
@@ -1491,7 +1491,7 @@ _resize_dynamic_array :: #force_no_inline proc(a: ^Raw_Dynamic_Array, size_of_el
 //
 // Note: Prefer the procedure group `resize`
 @builtin
-resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, #any_int length: int, loc := #caller_location) -> Allocator_Error {
+resize_dynamic_array :: proc(#no_alias array: ^$T/[dynamic]$E, #any_int length: int, loc := #caller_location) -> Allocator_Error {
 	return _resize_dynamic_array((^Raw_Dynamic_Array)(array), size_of(E), align_of(E), length, true, loc=loc)
 }
 
@@ -1501,7 +1501,7 @@ resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, #any_int length: int, loc :
 //
 // Note: Prefer the procedure group `non_zero_resize`
 @builtin
-non_zero_resize_dynamic_array :: proc(array: ^$T/[dynamic]$E, #any_int length: int, loc := #caller_location) -> Allocator_Error {
+non_zero_resize_dynamic_array :: proc(#no_alias array: ^$T/[dynamic]$E, #any_int length: int, loc := #caller_location) -> Allocator_Error {
 	return _resize_dynamic_array((^Raw_Dynamic_Array)(array), size_of(E), align_of(E), length, false, loc=loc)
 }
 
@@ -1552,11 +1552,11 @@ non_zero_resize_fixed_capacity_dynamic_array :: proc "contextless" (array: ^$T/[
 //
 // Note: Prefer the procedure group `shrink`
 @builtin
-shrink_dynamic_array :: proc(array: ^$T/[dynamic]$E, #any_int new_cap := -1, loc := #caller_location) -> (did_shrink: bool, err: Allocator_Error) {
+shrink_dynamic_array :: proc(#no_alias array: ^$T/[dynamic]$E, #any_int new_cap := -1, loc := #caller_location) -> (did_shrink: bool, err: Allocator_Error) {
 	return _shrink_dynamic_array((^Raw_Dynamic_Array)(array), size_of(E), align_of(E), new_cap, loc)
 }
 
-_shrink_dynamic_array :: proc(a: ^Raw_Dynamic_Array, size_of_elem, align_of_elem: int, new_cap := -1, loc := #caller_location) -> (did_shrink: bool, err: Allocator_Error) {
+_shrink_dynamic_array :: proc(#no_alias a: ^Raw_Dynamic_Array, size_of_elem, align_of_elem: int, new_cap := -1, loc := #caller_location) -> (did_shrink: bool, err: Allocator_Error) {
 	if a == nil {
 		return
 	}
diff --git a/base/runtime/core_builtin_soa.odin b/base/runtime/core_builtin_soa.odin
index f4cdec08f..61b93efd7 100644
--- a/base/runtime/core_builtin_soa.odin
+++ b/base/runtime/core_builtin_soa.odin
@@ -50,13 +50,18 @@ Raw_SOA_Footer_Dynamic_Array :: struct {
 	allocator: Allocator,
 }
 
+// Note: When casting array to access footer/fields
+// uintptr(array) lowers to LLVM ptrtoint and captures pointer provenance,
+// whcih defeats #no_alias on the array in any code following (including in callers).
+// Multipointer indexing lowers to GEP and doesn't capture, so prefer that throughout.
+
 @(builtin, require_results)
 raw_soa_footer_slice :: proc(array: ^$T/#soa[]$E) -> (footer: ^Raw_SOA_Footer_Slice) {
 	if array == nil {
 		return nil
 	}
-	field_count := uintptr(len(E) when intrinsics.type_is_array(E) else intrinsics.type_struct_field_count(E))
-	footer = (^Raw_SOA_Footer_Slice)(uintptr(array) + field_count*size_of(rawptr))
+	field_count := len(E) when intrinsics.type_is_array(E) else intrinsics.type_struct_field_count(E)
+	footer = (^Raw_SOA_Footer_Slice)(&([^]byte)(array)[field_count*size_of(rawptr)])
 	return
 }
 @(builtin, require_results)
@@ -64,8 +69,8 @@ raw_soa_footer_dynamic_array :: proc(array: ^$T/#soa[dynamic]$E) -> (footer: ^Ra
 	if array == nil {
 		return nil
 	}
-	field_count := uintptr(len(E) when intrinsics.type_is_array(E) else intrinsics.type_struct_field_count(E))
-	footer = (^Raw_SOA_Footer_Dynamic_Array)(uintptr(array) + field_count*size_of(rawptr))
+	field_count := len(E) when intrinsics.type_is_array(E) else intrinsics.type_struct_field_count(E)
+	footer = (^Raw_SOA_Footer_Dynamic_Array)(&([^]byte)(array)[field_count*size_of(rawptr)])
 	return
 }
 raw_soa_footer :: proc{
@@ -118,15 +123,13 @@ make_soa_aligned :: proc($T: typeid/#soa[]$E, #any_int length, alignment: int, a
 	}
 	new_data := raw_data(new_bytes)
 
-	data := uintptr(&array)
 	offset := 0
 	for i in 0..<field_count {
 		type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
 
 		offset = align_forward_int(offset, max_align)
 
-		(^uintptr)(data)^ = uintptr(new_data) + uintptr(offset)
-		data += size_of(rawptr)
+		([^]rawptr)(&array)[i] = rawptr(uintptr(new_data) + uintptr(offset))
 		offset += type.size * length
 	}
 	footer.len = length
@@ -174,7 +177,7 @@ make_soa :: proc{
 
 
 @builtin
-resize_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int length: int, loc := #caller_location) -> Allocator_Error {
+resize_soa :: proc(#no_alias array: ^$T/#soa[dynamic]$E, #any_int length: int, loc := #caller_location) -> Allocator_Error {
 	if array == nil {
 		return nil
 	}
@@ -215,7 +218,7 @@ resize_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int length: int, loc := #cal
 }
 
 @builtin
-non_zero_resize_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int length: int, loc := #caller_location) -> Allocator_Error {
+non_zero_resize_soa :: proc(#no_alias array: ^$T/#soa[dynamic]$E, #any_int length: int, loc := #caller_location) -> Allocator_Error {
 	if array == nil {
 		return nil
 	}
@@ -225,6 +228,15 @@ non_zero_resize_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int length: int, lo
 	return nil
 }
 
+// `reserve_soa` will try to reserve memory of a passed SOA dynamic array to the requested element count (setting the `cap`).
+//
+// For maximizing performance it is recommended to avoid power-of-2 capacities
+// when manually reserving memory for SOA arrays, more so for sizes above 512.
+// For element types with several fields, prefer padding such capacities by at
+// least the number of fields that fit in a CPU cache line.
+// Modern cache lines are typically 64 (Intel/AMD/Arm64) or 128 bytes (Apple Silicon),
+// so pad requested capacity with e.g. `128 / size_of(field)` (for the smallest field when field sizes differ),
+// that is, prefer capacity of 4128 instead of 4096 for 4-byte fields.
 @builtin
 reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int capacity: int, loc := #caller_location) -> Allocator_Error {
 	return _reserve_soa(array, capacity, true, loc)
@@ -235,7 +247,33 @@ non_zero_reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int capacity: int,
 	return _reserve_soa(array, capacity, false, loc)
 }
 
-_reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, zero_memory: bool, loc := #caller_location) -> Allocator_Error {
+
+// Note: capacity and performance
+// Each field is stored in contiguous memory with stride between fields capacity * size_of(field) (+ alignment).
+// When the stride is a multiple of 4KB, e.g. a power-of-2 capacity >= 1024 with 4-byte fields,
+// every same-size field's cache line for a given index maps to the same L1 set, and
+// per-element operations degrade (e.g. append_soa, inject_at_soa).
+// It is worst past 8 same-size fields where the burst exceeds the common
+// L1 8-way associativity and the fields collide (measured up to ~7-8x degradation
+// on a type with 18 same-size fields; fields of different sizes advance through
+// the sets at different rates, so they don't collide persistently).
+// Common SoA iterative flows may also be affected, when the loop touches multiple fields
+// and other hot data aliases the same L1 set.
+// So, for types with several fields, prefer padding such capacities by at
+// least the number of fields that fit in a CPU cache line.
+// Modern cache lines are typically 64 (Intel/AMD/Arm64) or 128 bytes (Apple Silicon),
+// so pad with e.g. 128 / size_of(field) (for the smallest field when field sizes differ),
+// so prefer 4128 instead of 4096 for 4-byte fields. Setting cap to e.g. 4097 is NOT enough
+// (it shifts field memory by only 4 bytes (same cache line) and fields keep colliding).
+// Note: 4KB stride in the discussion above is the x86 L1 set period (32–48KB/8–12-way);
+// Apple Silicon (128KB/8-way) has a 16KB period, so cap 4096 × 4 = 16KB stride
+// is still pathological there and the recommended 128-byte pad fixes it.
+// Note: struct size also plays a role, but the user facing padding recommendation
+// on reserve_soa() will handle up to 256 fields (of 4 bytes) decently on 8-way caches.
+// Note: Ideally, this should be handled internally by allowing allocated capacity to exceed requested capacity.
+// This would break current runtime tests though, they explicitly test requested cap.
+// Note: Capacities produced by append growth all the way from empty (2*cap + 8) are not affected.
+_reserve_soa :: #force_no_inline proc(array: ^$T/#soa[dynamic]$E, capacity: int, zero_memory: bool, loc := #caller_location) -> Allocator_Error {
 	if array == nil {
 		return nil
 	}
@@ -322,7 +360,7 @@ _reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, zero_memory: boo
 
 			mem_copy(new_data_elem, old_data_elem, old_size_elem)
 
-			(^rawptr)(uintptr(array) + i*size_of(rawptr))^ = new_data_elem
+			([^]rawptr)(array)[i] = new_data_elem
 
 			if zero_memory {
 				mem_zero(rawptr(uintptr(new_data_elem) + uintptr(old_size_elem)), new_size_elem - old_size_elem)
@@ -361,7 +399,7 @@ _reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, zero_memory: boo
 
 		mem_copy(new_data_elem, old_data_elem, type.size * old_cap)
 
-		(^rawptr)(uintptr(array) + i*size_of(rawptr))^ = new_data_elem
+		([^]rawptr)(array)[i] = new_data_elem
 
 		old_offset += type.size * old_cap
 		new_offset += type.size * capacity
@@ -388,7 +426,7 @@ non_zero_append_soa_elem :: proc(array: ^$T/#soa[dynamic]$E, #no_broadcast arg:
 	return _append_soa_elem(array, false, arg, loc)
 }
 
-_append_soa_elem :: proc(array: ^$T/#soa[dynamic]$E, zero_memory: bool, #no_broadcast arg: E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
+_append_soa_elem :: proc(#no_alias array: ^$T/#soa[dynamic]$E, zero_memory: bool, #no_broadcast arg: E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
 	if array == nil {
 		return 0, nil
 	}
@@ -399,35 +437,13 @@ _append_soa_elem :: proc(array: ^$T/#soa[dynamic]$E, zero_memory: bool, #no_broa
 		err = _reserve_soa(array, cap, zero_memory, loc) // do not 'or_return' here as it could be a partial success
 	}
 
-	footer := raw_soa_footer(array)
-
 	if size_of(E) > 0 && cap(array)-len(array) > 0 {
-		ti := type_info_of(T)
-		ti = type_info_base(ti)
-		si := &ti.variant.(Type_Info_Struct)
-		field_count := uintptr(len(E) when intrinsics.type_is_array(E) else intrinsics.type_struct_field_count(E))
-
-		data := (^rawptr)(array)^
-
-		soa_offset := 0
-		item_offset := 0
-
-		arg_copy := arg
-		arg_ptr := &arg_copy
-
-		max_align :: align_of(E)
-		for i in 0..<field_count {
-			type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
-
-			soa_offset  = align_forward_int(soa_offset, max_align)
-			item_offset = align_forward_int(item_offset, type.align)
-
-			dst := rawptr(uintptr(data) + uintptr(soa_offset) + uintptr(type.size * footer.len))
-			src := rawptr(uintptr(arg_ptr) + uintptr(item_offset))
-			mem_copy(dst, src, type.size)
-
-			soa_offset  += type.size * cap(array)
-			item_offset += type.size
+		footer := raw_soa_footer(array)
+		// Field stores are generated by the compiler's #soa
+		// element store lowering, specialized for E.
+		// Note that #no_bounds_check is not optional, we write at index == len.
+		#no_bounds_check {
+			array[footer.len] = arg
 		}
 		footer.len += 1
 		return 1, err
@@ -446,7 +462,7 @@ non_zero_append_soa_elems :: proc(array: ^$T/#soa[dynamic]$E, #no_broadcast args
 }
 
 
-_append_soa_elems :: proc(array: ^$T/#soa[dynamic]$E, zero_memory: bool, #no_broadcast args: []E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
+_append_soa_elems :: proc(#no_alias array: ^$T/#soa[dynamic]$E, zero_memory: bool, #no_broadcast args: []E, loc := #caller_location) -> (n: int, err: Allocator_Error) #optional_allocator_error {
 	if array == nil {
 		return
 	}
@@ -464,42 +480,26 @@ _append_soa_elems :: proc(array: ^$T/#soa[dynamic]$E, zero_memory: bool, #no_bro
 
 	footer := raw_soa_footer(array)
 	if size_of(E) > 0 && arg_len > 0 {
-		ti := type_info_of(typeid_of(T))
-		ti = type_info_base(ti)
-		si := &ti.variant.(Type_Info_Struct)
-		field_count := uintptr(len(E) when intrinsics.type_is_array(E) else intrinsics.type_struct_field_count(E))
-
-		data := (^rawptr)(array)^
-
-		soa_offset := 0
-		item_offset := 0
-
-		args_ptr := &args[0]
-
-		max_align :: align_of(E)
-		for i in 0..<field_count {
-			type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
-
-			soa_offset  = align_forward_int(soa_offset, max_align)
-			item_offset = align_forward_int(item_offset, type.align)
-
-			dst := uintptr(data) + uintptr(soa_offset) + uintptr(type.size * footer.len)
-			src := uintptr(args_ptr) + uintptr(item_offset)
-			for j in 0..<arg_len {
-				d := rawptr(dst + uintptr(j*type.size))
-				s := rawptr(src + uintptr(j*size_of(E)))
-				mem_copy(d, s, type.size)
+		offset := footer.len
+		FIELD_COUNT :: len(E) when intrinsics.type_is_array(E) else intrinsics.type_struct_field_count(E)
+		// Advance len before the copy, soa_copy_from_slice needs the final len to be set
+		footer.len += arg_len
+		when FIELD_COUNT == 0 {
+			// do nothing
+		} else when FIELD_COUNT <= 16 && ODIN_OPTIMIZATION_MODE <= .Size {
+			// Use the compiler's #soa element store lowering, more compact at these field counts.
+			#no_bounds_check for j in 0..<arg_len {
+				array[offset + j] = args[j]
 			}
-
-			soa_offset  += type.size * cap(array)
-			item_offset += type.size
+		} else {
+			intrinsics.soa_copy_from_slice(array, offset, args[:arg_len])
 		}
+	} else {
+		footer.len += arg_len
 	}
-	footer.len += arg_len
 	return arg_len, err
 }
 
-
 // The append_soa built-in procedure appends elements to the end of an #soa dynamic array
 @builtin
 append_soa :: proc{
@@ -523,43 +523,44 @@ append_nothing_soa :: proc(array: ^$T/#soa[dynamic]$E, loc := #caller_location)
 
 // `inject_at_elem_soa` injects an element in a dynamic SOA array at a specified index and moves the previous elements after that index "across"
 @builtin
-inject_at_elem_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int index: int, #no_broadcast arg: E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
+inject_at_elem_soa :: proc(#no_alias array: ^$T/#soa[dynamic]$E, #any_int index: int, #no_broadcast arg: E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
 	when !ODIN_NO_BOUNDS_CHECK {
 		ensure(index >= 0, "Index must be positive.", loc)
 	}
 	if array == nil {
 		return
 	}
-	n := max(len(array), index)
+	old_len := len(array)
+	n := max(old_len, index)
 	m :: 1
 	new_len := n + m
 
-	resize_soa(array, new_len, loc) or_return
+	// The tail shift and the stored element cover every new slot,
+	// except a gap of [old_len, index) when injecting past the end, which is
+	// zeroed explicitly below.
+	non_zero_resize_soa(array, new_len, loc) or_return
 
 	when size_of(E) != 0 {
 		ti := type_info_base(type_info_of(typeid_of(T)))
 		si := &ti.variant.(Type_Info_Struct)
 
-		field_count := len(E) when intrinsics.type_is_array(E) else intrinsics.type_struct_field_count(E)
+		FIELD_COUNT :: len(E) when intrinsics.type_is_array(E) else intrinsics.type_struct_field_count(E)
 
-		item_offset := 0
-
-		arg_copy := arg
-		arg_ptr := &arg_copy
-
-		for i in 0..<field_count {
-			data := (^uintptr)(uintptr(array) + uintptr(si.offsets[i]))^
+		for i in 0..<FIELD_COUNT {
+			data := uintptr(([^]rawptr)(array)[i])
 			type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
-			item_offset = align_forward_int(item_offset, type.align)
+
+			if index > old_len { // zero the gap left by injecting past the end
+				mem_zero(rawptr(data + uintptr(old_len * type.size)), (index - old_len) * type.size)
+			}
 
 			src := data + uintptr(index * type.size)
 			dst := data + uintptr((index + m) * type.size)
 			mem_copy(rawptr(dst), rawptr(src), (n - index) * type.size)
-
-			mem_copy(rawptr(src), rawptr(uintptr(arg_ptr) + uintptr(item_offset)), type.size)
-
-			item_offset += type.size
 		}
+
+		// store the new element via the compiler's #soa element store lowering
+		array[index] = arg
 	}
 
 	ok = true
@@ -568,7 +569,7 @@ inject_at_elem_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int index: int, #no_
 
 // `inject_at_elems_soa` injects multiple elements in a dynamic SOA array at a specified index and moves the previous elements after that index "across"
 @builtin
-inject_at_elems_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int index: int, #no_broadcast args: ..E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
+inject_at_elems_soa :: proc(#no_alias array: ^$T/#soa[dynamic]$E, #any_int index: int, #no_broadcast args: ..E, loc := #caller_location) -> (ok: bool, err: Allocator_Error) #no_bounds_check #optional_allocator_error {
 	when !ODIN_NO_BOUNDS_CHECK {
 		ensure(index >= 0, "Index must be positive.", loc)
 	}
@@ -580,11 +581,15 @@ inject_at_elems_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int index: int, #no
 		return
 	}
 
-	n := max(len(array), index)
+	old_len := len(array)
+	n := max(old_len, index)
 	m := len(args)
 	new_len := n + m
 
-	resize_soa(array, new_len, loc) or_return
+	// The tail shift and the stored elements cover every new slot,
+	// except a gap of [old_len, index) when injecting past the end, which is
+	// zeroed explicitly below.
+	non_zero_resize_soa(array, new_len, loc) or_return
 
 	when size_of(E) != 0 {
 		ti := type_info_base(type_info_of(typeid_of(T)))
@@ -592,14 +597,28 @@ inject_at_elems_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int index: int, #no
 
 		field_count := len(E) when intrinsics.type_is_array(E) else intrinsics.type_struct_field_count(E)
 
-		item_offset := 0
-
 		args_ptr := &args[0]
 
+		when !intrinsics.type_is_array(E) {
+			// E's field offsets come from E's own RTTI (si describes the SOA
+			// struct, whose fields are multipointers); basing on default struct
+			// layout here would misplace the fields of #packed elements.
+			se := &type_info_base(si.soa_base_type).variant.(Type_Info_Struct)
+		}
+
 		for i in 0..<field_count {
-			data := (^uintptr)(uintptr(array) + uintptr(si.offsets[i]))^
+			data := uintptr(([^]rawptr)(array)[i])
 			type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
-			item_offset = align_forward_int(item_offset, type.align)
+			when intrinsics.type_is_array(E) {
+				// array lanes are uniform, so offsets are just i * stride
+				item_offset := uintptr(i * type.size)
+			} else {
+				item_offset := se.offsets[i]
+			}
+
+			if index > old_len { // zero the gap left by injecting past the end
+				mem_zero(rawptr(data + uintptr(old_len * type.size)), (index - old_len) * type.size)
+			}
 
 			src := data + uintptr(index * type.size)
 			dst := data + uintptr((index + m) * type.size)
@@ -607,11 +626,9 @@ inject_at_elems_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int index: int, #no
 
 			for j in 0..<len(args) {
 				d := rawptr(src + uintptr(j*type.size))
-				s := rawptr(uintptr(args_ptr) + uintptr(item_offset) + uintptr(j*size_of(E)))
+				s := rawptr(uintptr(args_ptr) + item_offset + uintptr(j*size_of(E)))
 				mem_copy(d, s, type.size)
 			}
-
-			item_offset += type.size
 		}
 	}
 
@@ -694,24 +711,11 @@ into_dynamic_soa :: proc(array: $T/#soa[]$E) -> #soa[dynamic]E {
 // Note: If you the elements to remain in their order, use `ordered_remove_soa`.
 // Note: If the index is out of bounds, this procedure will panic.
 @builtin
-unordered_remove_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int index: int, loc := #caller_location) #no_bounds_check {
+unordered_remove_soa :: proc(#no_alias array: ^$T/#soa[dynamic]$E, #any_int index: int, loc := #caller_location) #no_bounds_check {
 	bounds_check_error_loc(loc, index, len(array))
 	if index+1 < len(array) {
-		ti := type_info_of(typeid_of(T))
-		ti = type_info_base(ti)
-		si := &ti.variant.(Type_Info_Struct)
-
-		field_count := uintptr(len(E) when intrinsics.type_is_array(E) else intrinsics.type_struct_field_count(E))
-
-		data := uintptr(array)
-		for i in 0..<field_count {
-			type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
-
-			offset := rawptr((^uintptr)(data)^ + uintptr(index*type.size))
-			final := rawptr((^uintptr)(data)^ + uintptr((len(array)-1)*type.size))
-			mem_copy(offset, final, type.size)
-			data += size_of(rawptr)
-		}
+		// Use the compiler's #soa element load and store lowering.
+		array[index] = array[len(array)-1]
 	}
 	raw_soa_footer_dynamic_array(array).len -= 1
 }
@@ -722,23 +726,21 @@ unordered_remove_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int index: int, lo
 // Note: If you the elements do not have to remain in their order, prefer `unordered_remove_soa`.
 // Note: If the index is out of bounds, this procedure will panic.
 @builtin
-ordered_remove_soa :: proc(array: ^$T/#soa[dynamic]$E, #any_int index: int, loc := #caller_location) #no_bounds_check {
+ordered_remove_soa :: proc(#no_alias array: ^$T/#soa[dynamic]$E, #any_int index: int, loc := #caller_location) #no_bounds_check {
 	bounds_check_error_loc(loc, index, len(array))
 	if index+1 < len(array) {
 		ti := type_info_of(typeid_of(T))
 		ti = type_info_base(ti)
 		si := &ti.variant.(Type_Info_Struct)
 
+		l1 := len(array)-1
 		field_count := uintptr(len(E) when intrinsics.type_is_array(E) else intrinsics.type_struct_field_count(E))
-
-		data := uintptr(array)
 		for i in 0..<field_count {
 			type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
 
-			offset := (^uintptr)(data)^ + uintptr(index*type.size)
-			length := type.size*(len(array) - index - 1)
+			offset := uintptr(([^]rawptr)(array)[i]) + uintptr(index*type.size)
+			length := type.size*(l1 - index)
 			mem_copy(rawptr(offset), rawptr(offset + uintptr(type.size)), length)
-			data += size_of(rawptr)
 		}
 	}
 	raw_soa_footer_dynamic_array(array).len -= 1
diff --git a/base/runtime/dynamic_map_internal.odin b/base/runtime/dynamic_map_internal.odin
index 06509c1e8..c15bc9cc0 100644
--- a/base/runtime/dynamic_map_internal.odin
+++ b/base/runtime/dynamic_map_internal.odin
@@ -524,15 +524,6 @@ map_grow_dynamic :: proc "odin" (#no_alias m: ^Raw_Map, #no_alias info: ^Map_Inf
 
 @(require_results)
 map_reserve_dynamic :: #force_no_inline proc "odin" (#no_alias m: ^Raw_Map, #no_alias info: ^Map_Info, new_capacity: uintptr, loc := #caller_location) -> Allocator_Error {
-	@(require_results)
-	ceil_log2 :: #force_inline proc "contextless" (x: uintptr) -> uintptr {
-		z := intrinsics.count_leading_zeros(x)
-		if z > 0 && x & (x-1) != 0 {
-			z -= 1
-		}
-		return size_of(uintptr)*8 - 1 - z
-	}
-
 	if m.allocator.procedure == nil {
 		m.allocator = context.allocator
 	}
@@ -545,7 +536,7 @@ map_reserve_dynamic :: #force_no_inline proc "odin" (#no_alias m: ^Raw_Map, #no_
 	}
 
 	// ceiling nearest power of two
-	log2_new_capacity := ceil_log2(new_capacity)
+	log2_new_capacity := __ceil_log2(new_capacity)
 
 	log2_min_cap := max(MAP_MIN_LOG2_CAPACITY, log2_new_capacity)
 
@@ -592,21 +583,31 @@ map_shrink_dynamic :: #force_no_inline proc "odin" (#no_alias m: ^Raw_Map, #no_a
 		m.allocator = context.allocator
 	}
 
-	log2_capacity := map_log2_cap(m^)
 	// Don't shrink below the minimum.
-	if log2_capacity <= MAP_MIN_LOG2_CAPACITY {
+	log2_capacity_current := map_log2_cap(m^)
+	if log2_capacity_current <= MAP_MIN_LOG2_CAPACITY {
 		return false, nil
 	}
+
 	// Cannot shrink the capacity if the number of items in the map would exceed
 	// one minus the current log2 capacity's resize threshold. That is the shrunk
 	// map needs to be within the max load factor.
-	if uintptr(m.len) >= map_load_factor(log2_capacity - 1) {
+	load_factor_new_max := map_load_factor(log2_capacity_current - 1)
+	if m.len >= load_factor_new_max {
 		return false, nil
 	}
 
-	shrunk := map_alloc_dynamic(info, log2_capacity - 1, m.allocator) or_return
+	log2_capacity_new := max(__ceil_log2(m.len), MAP_MIN_LOG2_CAPACITY)
+	load_factor_new := map_load_factor(log2_capacity_new)
 
-	capacity := uintptr(1) << log2_capacity
+	// The new log2 capacity's load factor needs to contain the current map as well.
+	if m.len > load_factor_new {
+		log2_capacity_new += 1
+	}
+
+	shrunk := map_alloc_dynamic(info, log2_capacity_new, m.allocator) or_return
+
+	capacity := uintptr(1) << log2_capacity_new
 
 	ks, vs, hs, _, _ := map_kvh_data_dynamic(m^, info)
 
@@ -914,7 +915,6 @@ __dynamic_map_entry :: proc "odin" (#no_alias m: ^Raw_Map, #no_alias info: ^Map_
 	return
 }
 
-
 // IMPORTANT: USED WITHIN THE COMPILER
 @(private)
 __dynamic_map_reserve :: proc "odin" (#no_alias m: ^Raw_Map, #no_alias info: ^Map_Info, new_capacity: uint, loc := #caller_location) -> Allocator_Error {
@@ -924,7 +924,20 @@ __dynamic_map_reserve :: proc "odin" (#no_alias m: ^Raw_Map, #no_alias info: ^Ma
 	return map_reserve_dynamic(m, info, uintptr(new_capacity), loc)
 }
 
+@(require_results, private)
+__ceil_log2 :: #force_inline proc "contextless" (x: uintptr) -> uintptr {
+	// NOTE(barney): log2(0) is undefined, but 0 is a reasonable return value.
+	// Alternatively, 8 could be considered as well.
+	if x == 0 {
+		return 0
+	}
 
+	z := intrinsics.count_leading_zeros(x)
+	if z > 0 && x & (x-1) != 0 {
+		z -= 1
+	}
+	return size_of(uintptr)*8 - 1 - z
+}
 
 // NOTE: the default hashing algorithm derives from fnv64a, with some minor modifications to work for `map` type:
 //
diff --git a/base/runtime/random_generator_chacha8_simd128.odin b/base/runtime/random_generator_chacha8_simd128.odin
index d63d92620..b0725b2e6 100644
--- a/base/runtime/random_generator_chacha8_simd128.odin
+++ b/base/runtime/random_generator_chacha8_simd128.odin
@@ -69,7 +69,7 @@ chacha8rand_refill_simd128 :: proc(r: ^Default_Random_State) {
 		s8_ := intrinsics.byte_swap(k[4])
 		s9_ := intrinsics.byte_swap(k[5])
 		s10_ := intrinsics.byte_swap(k[6])
-		s11_ := intrinicss.byte_swap(k[7])
+		s11_ := intrinsics.byte_swap(k[7])
 	}
 
 	// 4-lane ChaCha8.
diff --git a/core/compress/gzip/doc.odin b/core/compress/gzip/doc.odin
index e4b1929dd..e8185482c 100644
--- a/core/compress/gzip/doc.odin
+++ b/core/compress/gzip/doc.odin
@@ -53,7 +53,7 @@ Example:
 			if file == "-" {
 				// Read from stdin
 				ctx := &compress.Context_Stream_Input{
-					input = os.stdin.stream,
+					input = os.to_stream(os.stdin),
 				}
 				err = gzip.load(ctx, &buf)
 			} else {
diff --git a/core/crypto/_fiat/field_scalarp256r1/field.odin b/core/crypto/_fiat/field_scalarp256r1/field.odin
index 802f3382e..a2016992f 100644
--- a/core/crypto/_fiat/field_scalarp256r1/field.odin
+++ b/core/crypto/_fiat/field_scalarp256r1/field.odin
@@ -38,7 +38,7 @@ fe_from_bytes :: proc "contextless" (
 	out1: ^Montgomery_Domain_Field_Element,
 	arg1: []byte,
 ) -> bool {
-	ensure_contextless(len(out1) <= 64, "p256r1: invalid scalar input buffer")
+	ensure_contextless(len(arg1) <= 64, "p256r1: invalid scalar input buffer")
 
 	is_canonical := false
 	s_len := len(arg1)
diff --git a/core/crypto/_fiat/field_scalarp384r1/field.odin b/core/crypto/_fiat/field_scalarp384r1/field.odin
index d465bae44..8c110b6ad 100644
--- a/core/crypto/_fiat/field_scalarp384r1/field.odin
+++ b/core/crypto/_fiat/field_scalarp384r1/field.odin
@@ -31,7 +31,7 @@ fe_from_bytes :: proc "contextless" (
 	out1: ^Montgomery_Domain_Field_Element,
 	arg1: []byte,
 ) -> bool {
-	ensure_contextless(len(out1) <= 64, "p384r1: invalid scalar input buffer")
+	ensure_contextless(len(arg1) <= 64, "p384r1: invalid scalar input buffer")
 
 	is_canonical := false
 	s_len := len(arg1)
diff --git a/core/crypto/argon2id/argon2id.odin b/core/crypto/argon2id/argon2id.odin
index e2f5e487b..bad83238e 100644
--- a/core/crypto/argon2id/argon2id.odin
+++ b/core/crypto/argon2id/argon2id.odin
@@ -28,8 +28,8 @@ MIN_TAG_SIZE :: 4
 MAX_TAG_SIZE :: (1 << 32) - 1
 
 // RECOMMENDED_TAG_SIZE is the recommended tag size in bytes.
-RECOMMENTED_TAG_SIZE :: 32 // 256-bits
-// RECOMMENDNED_SALT_SIZE is the recommended salt size in bytes.
+RECOMMENDED_TAG_SIZE :: 32 // 256-bits
+// RECOMMENDED_SALT_SIZE is the recommended salt size in bytes.
 RECOMMENDED_SALT_SIZE :: 16 // 128-bits
 
 @(private)
diff --git a/core/debug/trace/allocator.odin b/core/debug/trace/allocator.odin
index 642561bac..febbcc4e1 100644
--- a/core/debug/trace/allocator.odin
+++ b/core/debug/trace/allocator.odin
@@ -97,6 +97,8 @@ tracking_allocator_init :: proc(
 tracking_allocator_destroy :: proc(t: ^Tracking_Allocator) {
 	delete(t.allocation_map)
 	delete(t.bad_free_array)
+	t.allocation_map = {}
+	t.bad_free_array = {}
 }
 
 @(no_sanitize_address)
diff --git a/core/flags/doc.odin b/core/flags/doc.odin
index e17cff21b..4aca753f7 100644
--- a/core/flags/doc.odin
+++ b/core/flags/doc.odin
@@ -52,8 +52,8 @@ Under the `args` tag, there are the following subtags:
 - `hidden`: hide this flag from the usage documentation.
 - `required`: cause verification to fail if this argument is not set.
 - `manifold=N`: take several arguments at once, UNIX-style only.
-- `file`: for `os.Handle` types, file open mode.
-- `perms`: for `os.Handle` types, file open permissions.
+- `file`: for `^os.File` types, file open mode.
+- `perms`: for `^os.File` types, file open permissions.
 - `indistinct`: allow the setting of distinct types by their base type.
 
 `required` may be given a range specifier in the following formats:
@@ -71,7 +71,7 @@ arguments it consumes at once. If this number is not specified, it will take as
 many arguments as can be converted to the underlying element type.
 
 
-`file` determines the file open mode for an `os.Handle`.
+`file` determines the file open mode for an `^os.File`.
 It accepts a string of flags that can be mixed together:
 - r: read
 - w: write
@@ -80,7 +80,7 @@ It accepts a string of flags that can be mixed together:
 - t: truncate, erase the file on open
 
 
-`perms` determines the file open permissions for an `os.Handle`.
+`perms` determines the file open permissions for an `^os.File`.
 
 The permissions are represented by three numbers in octal format. The first
 number is the owner, the second is the group, and the third is other. Read is
@@ -119,7 +119,7 @@ Supported Flag Data Types:
 - all bit_sets
 - `string` and `cstring`
 - `rune`
-- `os.Handle`
+- `^os.File`
 - `time.Time`
 - `datetime.DateTime`
 - `net.Host_Or_Endpoint`,
diff --git a/core/mem/tracking_allocator.odin b/core/mem/tracking_allocator.odin
index d6462faf1..96a417d7a 100644
--- a/core/mem/tracking_allocator.odin
+++ b/core/mem/tracking_allocator.odin
@@ -82,6 +82,8 @@ Destroy the tracking allocator.
 tracking_allocator_destroy :: proc(t: ^Tracking_Allocator) {
 	delete(t.allocation_map)
 	delete(t.bad_free_array)
+	t.allocation_map = {}
+	t.bad_free_array = {}
 }
 
 /*
diff --git a/core/odin/parser/parser.odin b/core/odin/parser/parser.odin
index 2ad291aef..3b2a1481e 100644
--- a/core/odin/parser/parser.odin
+++ b/core/odin/parser/parser.odin
@@ -2651,7 +2651,7 @@ parse_operand :: proc(p: ^Parser, lhs: bool) -> ^ast.Expr {
 		specialization: ^ast.Expr
 		if allow_token(p, .Quo) {
 			specialization = parse_type(p)
-			end = specialization.pos
+			end = specialization.end
 		}
 		if is_blank_ident(type) {
 			error(p, type.pos, "invalid polymorphic type definition with a blank identifier")
diff --git a/core/os/path.odin b/core/os/path.odin
index 22ec2d3f7..9f2f33ebb 100644
--- a/core/os/path.odin
+++ b/core/os/path.odin
@@ -746,7 +746,7 @@ glob :: proc(pattern: string, allocator := context.allocator) -> (matches: []str
 	if !has_meta(pattern) {
 		// TODO(bill): os.lstat on here to check for error
 		m := make([]string, 1)
-		m[0] = pattern
+		m[0] = strings.clone(pattern)
 		return m[:], nil
 	}
 
diff --git a/core/rexcode/docs/x86_api.md b/core/rexcode/docs/x86_api.md
index 358367e8e..2f913159d 100644
--- a/core/rexcode/docs/x86_api.md
+++ b/core/rexcode/docs/x86_api.md
@@ -122,6 +122,7 @@ Memory :: bit_field u64 {
 	addr_size_override: bool | 1,
 	base_class:         u8   | 5,
 	index_class:        u8   | 5,
+	disp_is_label:      bool | 1,   // disp holds a label id -> REL32 relocation
 }
 MEM_BASE_RIP :: 30   MEM_BASE_NONE :: 31   MEM_INDEX_NONE :: 31
 ```
@@ -131,7 +132,17 @@ MEM_BASE_RIP :: 30   MEM_BASE_NONE :: 31   MEM_INDEX_NONE :: 31
 **Convenience constructors** (current names after the in-tree refactor):
 `mem_base_only(base)`, `mem_base_disp(base, disp)`,
 `mem_base_index(base, index, scale)`,
-`mem_base_index_disp(base, index, scale, disp)`, `mem_rip_disp(disp)`.
+`mem_base_index_disp(base, index, scale, disp)`, `mem_rip_disp(disp)`,
+`mem_rip_label(label_id)`.
+
+> **Label addressing.** `mem_rip_label(label_id)` builds a RIP-relative operand
+> whose displacement references a **label** rather than a literal: the encoder
+> writes a placeholder disp32 and emits a `REL32` relocation for `label_id` at
+> that field (addend 0), exactly as the `.RELATIVE` jump/call path does. This is
+> how `lea reg, [rip + <label>]` (position-independent data addressing) is
+> expressed. When the label is defined the disp resolves in place; otherwise the
+> relocation is appended to the caller's `relocs`. The `disp_is_label` bit reuses
+> one of `Memory`'s spare bits — no struct growth.
 
 > ⚠️ `mem_base` is an **accessor** (returns the base `Register`), not a
 > constructor — use `mem_base_only` for the no-displacement case.
@@ -158,17 +169,24 @@ Operand :: struct #packed {              // 16 bytes
 Broadcast :: enum u8 { NONE, B1TO2, B1TO4, B1TO8, B1TO16 }   // EVEX
 
 Operand_Flags :: bit_field u16 {   // EVEX-specific
-	mask:      u8        | 3,   // opmask K1–K7
-	zeroing:   bool      | 1,   // merge vs zero masking
-	broadcast: Broadcast | 3,
-	er_sae:    u8        | 2,   // embedded rounding / SAE
+	mask:         u8        | 3,   // opmask K1–K7
+	zeroing:      bool      | 1,   // merge vs zero masking
+	broadcast:    Broadcast | 3,
+	er_sae:       u8        | 2,   // embedded rounding / SAE
+	imm_is_label: bool      | 1,   // movabs imm64 holds a label id -> ABS64 reloc
 }
 ```
 
 ### Generic operand constructors
 
 `op_reg(r)`, `op_mem(m, size)`, `op_mem_from_parts(base, index, scale, disp, size)`,
-`op_imm8/16/32/64(v)`, `op_rel8/32(offset)`, `op_label(label_id, size=4)`.
+`op_imm8/16/32/64(v)`, `op_rel8/32(offset)`, `op_label(label_id, size=4)`,
+`op_imm_label(label_id)`.
+
+> `op_imm_label(label_id)` is a `movabs reg, <label>` immediate: it stays kind
+> `.IMMEDIATE` (form matching unchanged) but is flagged so the encoder emits an
+> `ABS64` relocation (size 8) for the imm64 instead of a literal. The label
+> always selects the full imm64 form regardless of the id's numeric value.
 
 ### Typed operand constructors (compile-time class safety)
 
diff --git a/core/rexcode/isa/x86/encoder.odin b/core/rexcode/isa/x86/encoder.odin
index 2ad591f5b..dc28256aa 100644
--- a/core/rexcode/isa/x86/encoder.odin
+++ b/core/rexcode/isa/x86/encoder.odin
@@ -178,8 +178,14 @@ encode :: proc(
 		if form_index >= 0 && form_index < len(ENCODE_RECIPES) {
 			recipe := &ENCODE_RECIPES[form_index]
 			if recipe.flags.eligible && transmute(u8)inst.flags == 0 {
-				imm_lit := recipe.imm_op < 0 || inst.ops[recipe.imm_op].kind == .IMMEDIATE
-				if imm_lit {
+				// The recipe emitter is contextless and cannot append relocations,
+				// so a labeled immediate or a labeled memory displacement must fall
+				// back to the interpreter (which emits the relocation).
+				imm_lit := recipe.imm_op < 0 ||
+					(inst.ops[recipe.imm_op].kind == .IMMEDIATE && !inst.ops[recipe.imm_op].flags.imm_is_label)
+				rm_lit := recipe.rm_op < 0 ||
+					inst.ops[recipe.rm_op].kind != .MEMORY || !inst.ops[recipe.rm_op].mem.disp_is_label
+				if imm_lit && rm_lit {
 					byte_count += emit_recipe(recipe, &inst, code[byte_count:])
 					continue
 				}
@@ -545,6 +551,8 @@ encode :: proc(
 			sib:               u8  = 0
 			disp:              i32 = 0
 			displacement_size: u8  = 0
+			disp_is_label          := false // disp32 references a label -> emit REL32
+			disp_label_id:     u32 = 0
 
 			// Reg field
 			if enc.flags.modrm_reg_ext {
@@ -572,6 +580,11 @@ encode :: proc(
 							rm = 0b101
 							disp = m.disp
 							displacement_size = 4
+							// A RIP-relative disp can carry a label id instead of a
+							// literal: emit a REL32 relocation at the disp32 offset
+							// (mirrors the .RELATIVE -> REL32 jump/call path).
+							disp_is_label = m.disp_is_label
+							disp_label_id = u32(m.disp)
 						} else if !mem_has_base(m) && !mem_has_index(m) {
 							mod = 0b00
 							rm = 0b100
@@ -633,13 +646,21 @@ encode :: proc(
 				pos += 1
 			}
 
-			// Displacement: bounded little-endian emit. Kept as a counted loop
-			// (0/1/4 trips, highly predictable per code pattern) so no buffer
-			// tail-slack is needed and no bytes are written past the real size.
-			for _ in 0..<displacement_size {
-				out[pos] = u8(disp & 0xFF)
-				disp >>= 8
-				pos += 1
+			// Displacement. A labeled disp emits a placeholder disp32 and records a
+			// REL32 relocation at its byte offset (addend 0). Otherwise a bounded
+			// little-endian emit -- kept as a counted loop (0/1/4 trips, highly
+			// predictable per code pattern) so no buffer tail-slack is needed and no
+			// bytes are written past the real size.
+			if disp_is_label {
+				append(&pending_relocations, Relocation{byte_count + pos, disp_label_id, 0, .REL32, 4, u16(instruction_index)})
+				out[pos] = 0; out[pos+1] = 0; out[pos+2] = 0; out[pos+3] = 0
+				pos += 4
+			} else {
+				for _ in 0..<displacement_size {
+					out[pos] = u8(disp & 0xFF)
+					disp >>= 8
+					pos += 1
+				}
 			}
 		}
 
@@ -693,10 +714,19 @@ encode :: proc(
 				}
 			case .IQ:
 				if user_op.kind == .IMMEDIATE {
-					v := u64(user_op.immediate)
-					out[pos]   = u8(v);       out[pos+1] = u8(v >> 8);  out[pos+2] = u8(v >> 16); out[pos+3] = u8(v >> 24)
-					out[pos+4] = u8(v >> 32); out[pos+5] = u8(v >> 40); out[pos+6] = u8(v >> 48); out[pos+7] = u8(v >> 56)
-					pos += 8
+					if user_op.flags.imm_is_label {
+						// movabs reg, <label>: placeholder imm64 + ABS64 relocation.
+						label_id := u32(user_op.immediate)
+						append(&pending_relocations, Relocation{byte_count + pos, label_id, 0, .ABS64, 8, u16(instruction_index)})
+						out[pos]   = 0; out[pos+1] = 0; out[pos+2] = 0; out[pos+3] = 0
+						out[pos+4] = 0; out[pos+5] = 0; out[pos+6] = 0; out[pos+7] = 0
+						pos += 8
+					} else {
+						v := u64(user_op.immediate)
+						out[pos]   = u8(v);       out[pos+1] = u8(v >> 8);  out[pos+2] = u8(v >> 16); out[pos+3] = u8(v >> 24)
+						out[pos+4] = u8(v >> 32); out[pos+5] = u8(v >> 40); out[pos+6] = u8(v >> 48); out[pos+7] = u8(v >> 56)
+						pos += 8
+					}
 				}
 			}
 		}
@@ -946,6 +976,12 @@ mem_matches_inline :: #force_inline proc "contextless" (op: ^Operand, op_type: O
 }
 
 imm_matches_inline :: #force_inline proc "contextless" (op: ^Operand, op_type: Operand_Type) -> bool {
+	// A labeled immediate is an address placeholder (movabs): it must select the
+	// full imm64 form regardless of the label id's numeric value, so a small id
+	// doesn't collapse to a shorter `mov r64, imm32` and lose the ABS64 slot.
+	if op.flags.imm_is_label {
+		return op_type == .IMM64
+	}
 	// Match based on whether the VALUE fits in the encoding's immediate size.
 	// x64 immediates are interpreted as both signed and unsigned depending on context:
 	// - ADD r32, imm8sx: sign-extended, so -1 becomes 0xFFFFFFFF
diff --git a/core/rexcode/isa/x86/operands.odin b/core/rexcode/isa/x86/operands.odin
index 996664d01..e3ad641c8 100644
--- a/core/rexcode/isa/x86/operands.odin
+++ b/core/rexcode/isa/x86/operands.odin
@@ -37,6 +37,11 @@ Memory :: bit_field u64 {
 	addr_size_override: bool | 1,
 	base_class:         u8   | 5,
 	index_class:        u8   | 5,
+	// When set, `disp` holds a label id (not a literal displacement): the
+	// encoder emits a REL32 relocation at the disp32's byte offset instead of
+	// the literal, so a RIP-relative operand can reference a label. Uses one of
+	// Memory's 4 spare bits -- no growth, and one bit-test on the hot path.
+	disp_is_label:      bool | 1,
 }
 
 @(require_results)
@@ -76,6 +81,10 @@ mem_make :: proc "contextless" (base: Register, index: Register, scale: u8, disp
 	}
 
 	mem.disp = disp
+	// Must be explicitly cleared: `mem` starts uninitialized (`= ---`) and the
+	// encoder reads this on the hot path -- garbage here would spuriously turn a
+	// literal displacement into a label reference. mem_rip_label sets it after.
+	mem.disp_is_label = false
 
 	return mem
 }
@@ -150,6 +159,20 @@ mem_rip_disp :: #force_inline proc "contextless" (disp: i32) -> Memory {
 	return mem_make(RIP, NONE, 1, disp, NONE)
 }
 
+// RIP-relative memory operand whose displacement references a label rather than
+// a literal. The encoder writes a placeholder disp32 and emits a REL32
+// relocation for `label_id` at that field's byte offset -- the native way to
+// express `lea reg, [rip + <label>]` (position-independent data addressing).
+// The relocation carries addend 0; any within-section offset is supplied by the
+// downstream object/JIT layer when it resolves the label.
+@(require_results)
+mem_rip_label :: #force_inline proc "contextless" (label_id: u32) -> Memory {
+	m := mem_make(RIP, NONE, 1, 0, NONE)
+	m.disp = i32(label_id)
+	m.disp_is_label = true
+	return m
+}
+
 // -----------------------------------------------------------------------------
 // SECTION: 2.5 Operand struct and Flags
 // -----------------------------------------------------------------------------
@@ -184,6 +207,10 @@ Operand_Flags :: bit_field u16 {
 	zeroing:   bool      | 1,      // merge (0) vs zero (1) masking
 	broadcast: Broadcast | 3, // broadcast mode (see Broadcast enum)
 	er_sae:    u8        | 2,         // embedded rounding / SAE (0=none, 1=RN-SAE, 2=RD-SAE, 3=RU-SAE/RZ-SAE)
+	// When set on a movabs (IQ) immediate operand, `Operand.immediate` holds a
+	// label id: the encoder writes a placeholder imm64 and emits an ABS64
+	// relocation at its byte offset. Uses one of Operand_Flags' spare bits.
+	imm_is_label: bool   | 1,
 }
 
 // -----------------------------------------------------------------------------
@@ -255,6 +282,16 @@ op_label :: #force_inline proc "contextless" (label_id: u32, size: u8 = 4) -> Op
 	return Operand{relative = i64(label_id), kind = .RELATIVE, size = size}
 }
 
+// A movabs imm64 that references a label: the immediate stays kind .IMMEDIATE
+// (so form matching is unchanged) but is flagged as a label, so the encoder
+// emits an ABS64 relocation for it instead of a literal. Use for
+// `movabs reg, <label>` (absolute addressing; the target address is filled in
+// at relocation time).
+@(require_results)
+op_imm_label :: #force_inline proc "contextless" (label_id: u32) -> Operand {
+	return Operand{immediate = i64(label_id), kind = .IMMEDIATE, size = 8, flags = {imm_is_label = true}}
+}
+
 // -----------------------------------------------------------------------------
 // SECTION: 2.7 Typed Operand Constructors (compile-time type safety)
 // -----------------------------------------------------------------------------
diff --git a/core/rexcode/isa/x86/tests/test.odin b/core/rexcode/isa/x86/tests/test.odin
index 121a12023..7a0be6d6b 100644
--- a/core/rexcode/isa/x86/tests/test.odin
+++ b/core/rexcode/isa/x86/tests/test.odin
@@ -3369,6 +3369,153 @@ run_i386_tests :: proc() {
 	}
 }
 
+// =============================================================================
+// SECTION 11: LABEL ADDRESSING (RIP-relative disp + movabs imm)
+// =============================================================================
+//
+// Native label references for a memory displacement (REL32) and a movabs imm64
+// (ABS64) -- the encoder emits the same relocations it already does for
+// jump/call targets, so a RIP-relative `lea reg, [rip + <label>]` and an
+// absolute `movabs reg, <label>` can be expressed directly.
+
+read_i32_le :: proc(b: []u8, off: int) -> i32 {
+	return i32(u32(b[off]) | (u32(b[off+1]) << 8) | (u32(b[off+2]) << 16) | (u32(b[off+3]) << 24))
+}
+
+run_label_addressing_tests :: proc() {
+	before := g_stats.failed
+
+	// -- lea rax, [rip + L], L DEFINED: disp32 must resolve to L - end_of_lea ----
+	{
+		// insts: 0=lea rax,[rip+L]  1=ret  2=ret   L (id 0) at inst index 2.
+		insts := []x86.Instruction{
+			{mnemonic = .LEA, operand_count = 2, ops = {x86.op_reg(x86.RAX), x86.op_mem(x86.mem_rip_label(0), 8), {}, {}}},
+			x86.inst_none(.RET),
+			x86.inst_none(.RET),
+		}
+		labels := [1]x86.Label_Definition{x86.Label_Definition(2)} // L -> inst index 2
+		code: [64]u8
+		relocs: [dynamic]x86.Relocation; errs: [dynamic]x86.Error
+		defer delete(relocs); defer delete(errs)
+
+		n, ok := x86.encode(insts, labels[:], code[:], &relocs, &errs, true, 0)
+		// lea rax,[rip+disp32] = 48 8D 05 dd dd dd dd (7 bytes); disp32 at offset 3.
+		disp := read_i32_le(code[:], 3)
+		target := i32(labels[0])          // now a byte offset
+		want := target - 7                 // next_pc = end of the 7-byte lea
+		prefix_ok := code[0] == 0x48 && code[1] == 0x8D && code[2] == 0x05
+		if ok && len(relocs) == 0 && prefix_ok && disp == want && n == 9 {
+			fmt.printf("%s[PASS]%s lea [rip+L] resolved: disp32=%d (L@%d)\n", GREEN, RESET, disp, target)
+			g_stats.passed += 1
+		} else {
+			fmt.printf("%s[FAIL]%s lea [rip+L] resolved: ok=%v relocs=%d prefix_ok=%v disp=%d want=%d n=%d\n",
+				RED, RESET, ok, len(relocs), prefix_ok, disp, want, n)
+			g_stats.failed += 1
+		}
+	}
+
+	// -- lea rax, [rip + L], L UNDEFINED: a REL32 reloc at the disp32 offset ------
+	{
+		insts := []x86.Instruction{
+			{mnemonic = .LEA, operand_count = 2, ops = {x86.op_reg(x86.RAX), x86.op_mem(x86.mem_rip_label(0), 8), {}, {}}},
+		}
+		labels := [1]x86.Label_Definition{x86.LABEL_UNDEFINED}
+		code: [64]u8
+		relocs: [dynamic]x86.Relocation; errs: [dynamic]x86.Error
+		defer delete(relocs); defer delete(errs)
+
+		_, ok := x86.encode(insts, labels[:], code[:], &relocs, &errs, true, 0)
+		r := len(relocs) == 1 ? relocs[0] : x86.Relocation{}
+		good := ok && len(relocs) == 1 &&
+			r.type == .REL32 && r.size == 4 && r.offset == 3 && r.label_id == 0 && r.addend == 0
+		// placeholder disp must be zero until relocation
+		good &&= read_i32_le(code[:], 3) == 0
+		if good {
+			fmt.printf("%s[PASS]%s lea [rip+L] unresolved: REL32 @off=%d size=%d label=%d\n",
+				GREEN, RESET, r.offset, r.size, r.label_id)
+			g_stats.passed += 1
+		} else {
+			fmt.printf("%s[FAIL]%s lea [rip+L] unresolved: ok=%v relocs=%d %v\n", RED, RESET, ok, len(relocs), r)
+			g_stats.failed += 1
+		}
+	}
+
+	// -- movabs rax, L: an ABS64 reloc at the imm64 offset -----------------------
+	{
+		insts := []x86.Instruction{
+			{mnemonic = .MOV, operand_count = 2, ops = {x86.op_reg(x86.RAX), x86.op_imm_label(0), {}, {}}},
+		}
+		labels := [1]x86.Label_Definition{x86.LABEL_UNDEFINED}
+		code: [64]u8
+		relocs: [dynamic]x86.Relocation; errs: [dynamic]x86.Error
+		defer delete(relocs); defer delete(errs)
+
+		n, ok := x86.encode(insts, labels[:], code[:], &relocs, &errs, true, 0)
+		r := len(relocs) == 1 ? relocs[0] : x86.Relocation{}
+		// movabs rax, imm64 = 48 B8 <imm64> (10 bytes); imm64 at offset 2.
+		prefix_ok := n == 10 && code[0] == 0x48 && code[1] == 0xB8
+		good := ok && len(relocs) == 1 &&
+			r.type == .ABS64 && r.size == 8 && r.offset == 2 && r.label_id == 0 && prefix_ok
+		if good {
+			fmt.printf("%s[PASS]%s movabs rax, L: ABS64 @off=%d size=%d (48 B8 ...)\n",
+				GREEN, RESET, r.offset, r.size)
+			g_stats.passed += 1
+		} else {
+			fmt.printf("%s[FAIL]%s movabs rax, L: ok=%v n=%d relocs=%d prefix_ok=%v %v\n",
+				RED, RESET, ok, n, len(relocs), prefix_ok, r)
+			g_stats.failed += 1
+		}
+	}
+
+	// -- lea [rip+L] with a nonzero-distance L, executed end-to-end --------------
+	// Prove the resolved displacement actually points at the datum: lay a known
+	// dword right after a `lea rax,[rip+L]; mov eax,[rax]; ret`, and check the
+	// loaded value comes back. The disp is derived from the real layout, not baked.
+	{
+		DATUM :: i32(0x5A17C0DE)
+		insts := []x86.Instruction{
+			// 0: lea rax, [rip + L]
+			{mnemonic = .LEA, operand_count = 2, ops = {x86.op_reg(x86.RAX), x86.op_mem(x86.mem_rip_label(0), 8), {}, {}}},
+			// 1: mov eax, [rax]   (load the datum L points at)
+			{mnemonic = .MOV, operand_count = 2, ops = {x86.op_reg(x86.EAX), x86.op_mem(x86.mem_base_only(x86.RAX), 4), {}, {}}},
+			// 2: ret
+			x86.inst_none(.RET),
+			// 3: filler that reserves >=4 bytes for the datum; its first 4 bytes are
+			//    overwritten below. Never executed (the ret at inst 2 returns first).
+			x86.inst_r_i(.MOV, x86.EAX, 0x1111_1111, 4),
+		}
+		labels := [1]x86.Label_Definition{x86.Label_Definition(3)} // L at inst index 3
+		code: [64]u8
+		relocs: [dynamic]x86.Relocation; errs: [dynamic]x86.Error
+		defer delete(relocs); defer delete(errs)
+
+		n, ok := x86.encode(insts, labels[:], code[:], &relocs, &errs, true, 0)
+		// L's byte offset is where inst 3 starts; the lea's disp resolved to it.
+		// Overwrite those 4 bytes with the datum the load should return.
+		datum_off := int(labels[0])
+		v := u32(DATUM)
+		code[datum_off] = u8(v); code[datum_off+1] = u8(v >> 8); code[datum_off+2] = u8(v >> 16); code[datum_off+3] = u8(v >> 24)
+
+		exec := alloc_exec(4096)
+		defer free_exec(exec)
+		copy(exec, code[:n])
+		fn := transmute(proc "c" () -> i64)raw_data(exec)
+		got := i32(fn())
+		if ok && len(relocs) == 0 && got == DATUM {
+			fmt.printf("%s[PASS]%s lea [rip+L] loads datum: got 0x%08X\n", GREEN, RESET, u32(got))
+			g_stats.passed += 1
+		} else {
+			fmt.printf("%s[FAIL]%s lea [rip+L] loads datum: ok=%v relocs=%d got 0x%08X want 0x%08X\n",
+				RED, RESET, ok, len(relocs), u32(got), u32(DATUM))
+			g_stats.failed += 1
+		}
+	}
+
+	if g_stats.failed == before {
+		fmt.printf("%s[PASS]%s label addressing (REL32 disp + ABS64 movabs)\n", GREEN, RESET)
+	}
+}
+
 // =============================================================================
 // MAIN
 // =============================================================================
@@ -3413,6 +3560,9 @@ main :: proc() {
 
 		log_header("LARGE FUNCTION TESTS")
 		run_large_tests()
+
+		log_header("LABEL ADDRESSING TESTS")
+		run_label_addressing_tests()
 	}
 
 	log_header("DECODE-ONLY TESTS")
diff --git a/core/simd/arm/crc32.odin b/core/simd/arm/crc32.odin
new file mode 100644
index 000000000..81564a7ff
--- /dev/null
+++ b/core/simd/arm/crc32.odin
@@ -0,0 +1,104 @@
+#+build arm64,arm32
+package simd_arm
+
+// CRC32 single round checksum for bytes (8 bits).
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32b)
+@(require_results, enable_target_feature = "crc")
+__crc32b :: #force_inline proc "c" (crc: uint32_t, data: uint8_t) -> uint32_t {
+	return ___crc32b(crc, uint32_t(data))
+}
+
+// CRC32-C single round checksum for bytes (8 bits).
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32cb)
+@(require_results, enable_target_feature = "crc")
+__crc32cb :: #force_inline proc "c" (crc: uint32_t, data: uint8_t) -> uint32_t {
+	return ___crc32cb(crc, uint32_t(data))
+}
+
+// CRC32 single round checksum for bytes (16 bits).
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32h)
+@(require_results, enable_target_feature = "crc")
+__crc32h :: #force_inline proc "c" (crc: uint32_t, data: uint16_t) -> uint32_t {
+	return ___crc32h(crc, uint32_t(data))
+}
+
+// CRC32-C single round checksum for bytes (16 bits).
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32ch)
+@(require_results, enable_target_feature = "crc")
+__crc32ch :: #force_inline proc "c" (crc: uint32_t, data: uint16_t) -> uint32_t {
+	return ___crc32ch(crc, uint32_t(data))
+}
+
+// CRC32 single round checksum for bytes (32 bits).
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32w)
+@(require_results, enable_target_feature = "crc")
+__crc32w :: #force_inline proc "c" (crc: uint32_t, data: uint32_t) -> uint32_t {
+	return ___crc32w(crc, data)
+}
+
+// CRC32-C single round checksum for bytes (32 bits).
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32cw)
+@(require_results, enable_target_feature = "crc")
+__crc32cw :: #force_inline proc "c" (crc: uint32_t, data: uint32_t) -> uint32_t {
+	return ___crc32cw(crc, data)
+}
+
+// CRC32 single round checksum for quad words (64 bits).
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32d)
+@(require_results, enable_target_feature = "crc")
+__crc32d :: #force_inline proc "c" (crc: uint32_t, data: uint64_t) -> uint32_t {
+	when ODIN_ARCH == .arm64 {
+		return ___crc32d(crc, data)
+	} else {
+		b := uint32_t(data & 0xffffffff)
+		c := uint32_t(data >> 32)
+		return ___crc32w(___crc32w(crc, b), c)
+	}
+}
+
+// CRC32-C single round checksum for quad words (64 bits).
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/__crc32cd)
+@(require_results, enable_target_feature = "crc")
+__crc32cd :: #force_inline proc "c" (crc: uint32_t, data: uint64_t) -> uint32_t {
+	when ODIN_ARCH == .arm64 {
+		return ___crc32cd(crc, data)
+	} else {
+		b := uint32_t(data & 0xffffffff)
+		c := uint32_t(data >> 32)
+		return ___crc32cw(___crc32cw(crc, b), c)
+	}
+}
+
+@(private, default_calling_convention = "none")
+foreign _ {
+	@(link_name = "llvm.aarch64.crc32b" when ODIN_ARCH == .arm64 else "llvm.arm.crc32b")
+	___crc32b :: proc(crc: uint32_t, data: uint32_t) -> uint32_t ---
+	@(link_name = "llvm.aarch64.crc32h" when ODIN_ARCH == .arm64 else "llvm.arm.crc32h")
+	___crc32h :: proc(crc: uint32_t, data: uint32_t) -> uint32_t ---
+	@(link_name = "llvm.aarch64.crc32w" when ODIN_ARCH == .arm64 else "llvm.arm.crc32w")
+	___crc32w :: proc(crc: uint32_t, data: uint32_t) -> uint32_t ---
+	@(link_name = "llvm.aarch64.crc32cb" when ODIN_ARCH == .arm64 else "llvm.arm.crc32cb")
+	___crc32cb :: proc(crc: uint32_t, data: uint32_t) -> uint32_t ---
+	@(link_name = "llvm.aarch64.crc32ch" when ODIN_ARCH == .arm64 else "llvm.arm.crc32ch")
+	___crc32ch :: proc(crc: uint32_t, data: uint32_t) -> uint32_t ---
+	@(link_name = "llvm.aarch64.crc32cw" when ODIN_ARCH == .arm64 else "llvm.arm.crc32cw")
+	___crc32cw :: proc(crc: uint32_t, data: uint32_t) -> uint32_t ---
+}
+
+when ODIN_ARCH == .arm64 {
+	@(private, default_calling_convention = "none")
+	foreign _ {
+		@(link_name = "llvm.aarch64.crc32x")
+		___crc32d :: proc(crc: uint32_t, data: uint64_t) -> uint32_t ---
+		@(link_name = "llvm.aarch64.crc32cx")
+		___crc32cd :: proc(crc: uint32_t, data: uint64_t) -> uint32_t ---
+	}
+}
diff --git a/core/simd/arm/pmull.odin b/core/simd/arm/pmull.odin
new file mode 100644
index 000000000..8d0707da9
--- /dev/null
+++ b/core/simd/arm/pmull.odin
@@ -0,0 +1,406 @@
+#+build arm64,arm32
+package simd_arm
+
+import "core:simd"
+
+// Join two smaller vectors into a single larger vector
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_p8)
+@(require_results, enable_target_feature = "neon")
+vcombine_p8 :: #force_inline proc "c" (low, high: poly8x8_t) -> poly8x16_t {
+	when ODIN_ENDIAN == .Little {
+		return simd.shuffle(low, high, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+	} else {
+		low := simd.shuffle(low, low, 7, 6, 5, 4, 3, 2, 1, 0)
+		high := simd.shuffle(high, high, 7, 6, 5, 4, 3, 2, 1, 0)
+		c := simd.shuffle(low, high, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+		return simd.shuffle(c, c, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+	}
+}
+
+// Join two smaller vectors into a single larger vector
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_p16)
+@(require_results, enable_target_feature = "neon")
+vcombine_p16 :: #force_inline proc "c" (low, high: poly16x4_t) -> poly16x8_t {
+	when ODIN_ENDIAN == .Little {
+		return simd.shuffle(low, high, 0, 1, 2, 3, 4, 5, 6, 7)
+	} else {
+		low := simd.shuffle(low, low, 3, 2, 1, 0)
+		high := simd.shuffle(high, high, 3, 2, 1, 0)
+		c := simd.shuffle(low, high, 0, 1, 2, 3, 4, 5, 6, 7)
+		return simd.shuffle(c, c, 7, 6, 5, 4, 3, 2, 1, 0)
+	}
+}
+
+// Join two smaller vectors into a single larger vector
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vcombine_p64)
+@(require_results, enable_target_feature = "neon")
+vcombine_p64 :: #force_inline proc "c" (low, high: poly64x1_t) -> poly64x2_t {
+	when ODIN_ENDIAN == .Little {
+		return simd.shuffle(low, high, 0, 1)
+	} else {
+		c := simd.shuffle(low, high, 0, 1)
+		return simd.shuffle(c, c, 1, 0)
+	}
+}
+
+// Insert vector element from another vector element
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_p8)
+@(require_results, enable_target_feature = "neon")
+vset_lane_p8 :: #force_inline proc "c" (a: poly8_t, v: poly8x8_t, $LANE: int32_t) -> poly8x8_t where 0 <= LANE, LANE < 8 {
+	when ODIN_ENDIAN == .Little {
+		return simd.replace(v, LANE, a)
+	} else {
+		v := simd.shuffle(v, v, 7, 6, 5, 4, 3, 2, 1, 0)
+		c := simd.replace(v, LANE, a)
+		return simd.shuffle(c, c, 7, 6, 5, 4, 3, 2, 1, 0)
+	}
+}
+
+// Insert vector element from another vector element
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_p16)
+@(require_results, enable_target_feature = "neon")
+vset_lane_p16 :: #force_inline proc "c" (a: poly16_t, v: poly16x4_t, $LANE: int32_t) -> poly16x4_t where 0 <= LANE, LANE < 4 {
+	when ODIN_ENDIAN == .Little {
+		return simd.replace(v, LANE, a)
+	} else {
+		v := simd.shuffle(v, v, 3, 2, 1, 0)
+		c := simd.replace(v, LANE, a)
+		return simd.shuffle(c, c, 3, 2, 1, 0)
+	}
+}
+
+// Insert vector element from another vector element
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vset_lane_p64)
+@(require_results, enable_target_feature = "neon")
+vset_lane_p64 :: #force_inline proc "c" (a: poly64_t, v: poly64x1_t, $LANE: int32_t) -> poly64x1_t where LANE == 0 {
+	return simd.replace(v, LANE, a)
+}
+
+// Move vector element to general-purpose register
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_p8)
+@(require_results, enable_target_feature = "neon")
+vget_lane_p8 :: #force_inline proc "c" (v: poly8x8_t, $LANE: int32_t) -> poly8_t where 0 <= LANE, LANE < 8 {
+	when ODIN_ENDIAN == .Little {
+		return simd.extract(v, LANE)
+	} else {
+		v := simd.shuffle(v, v, 7, 6, 5, 4, 3, 2, 1, 0)
+		return simd.extract(v, LANE)
+	}
+}
+
+// Move vector element to general-purpose register
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_p16)
+@(require_results, enable_target_feature = "neon")
+vget_lane_p16 :: #force_inline proc "c" (v: poly16x4_t, $LANE: int32_t) -> poly16_t where 0 <= LANE, LANE < 4 {
+	when ODIN_ENDIAN == .Little {
+		return simd.extract(v, LANE)
+	} else {
+		v := simd.shuffle(v, v, 3, 2, 1, 0)
+		return simd.extract(v, LANE)
+	}
+}
+
+// Move vector element to general-purpose register
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_lane_p64)
+@(require_results, enable_target_feature = "neon")
+vget_lane_p64 :: #force_inline proc "c" (v: poly64x1_t, $LANE: int32_t) -> poly64_t where LANE == 0 {
+	return simd.extract(v, LANE)
+}
+
+// Insert vector element from another vector element
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_p8)
+@(require_results, enable_target_feature = "neon")
+vsetq_lane_p8 :: #force_inline proc "c" (a: poly8_t, v: poly8x16_t, $LANE: int32_t) -> poly8x16_t where 0 <= LANE, LANE < 16 {
+	when ODIN_ENDIAN == .Little {
+		return simd.replace(v, LANE, a)
+	} else {
+		v := simd.shuffle(v, v, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+		c := simd.replace(v, LANE, a)
+		return simd.shuffle(c, c, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+	}
+}
+
+// Insert vector element from another vector element
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_p16)
+@(require_results, enable_target_feature = "neon")
+vsetq_lane_p16 :: #force_inline proc "c" (a: poly16_t, v: poly16x8_t, $LANE: int32_t) -> poly16x8_t where 0 <= LANE, LANE < 8 {
+	when ODIN_ENDIAN == .Little {
+		return simd.replace(v, LANE, a)
+	} else {
+		v := simd.shuffle(v, v, 7, 6, 5, 4, 3, 2, 1, 0)
+		c := simd.replace(v, LANE, a)
+		return simd_shuffle(c, c, 7, 6, 5, 4, 3, 2, 1, 0)
+	}
+}
+
+// Insert vector element from another vector element
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsetq_lane_p64)
+@(require_results, enable_target_feature = "neon")
+vsetq_lane_p64 :: #force_inline proc "c" (a: poly64_t, v: poly64x2_t, $LANE: int32_t) -> poly64x2_t where 0 <= LANE, LANE < 2 {
+	when ODIN_ENDIAN == .Little {
+		return simd.replace(v, LANE, a)
+	} else {
+		v := simd.shuffle(v, v, 1, 0)
+		c := simd.replace(v, LANE, a)
+		return simd.shuffle(c, c, 1, 0)
+	}
+}
+
+// Move vector element to general-purpose register
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_p8)
+@(require_results, enable_target_feature = "neon")
+vgetq_lane_p8 :: #force_inline proc "c" (v: poly8x16_t, $LANE: int32_t) -> poly8_t where 0 <= LANE, LANE < 16 {
+	when ODIN_ENDIAN == .Little {
+		return simd.extract(v, LANE)
+	} else {
+		v := simd.shuffle(v, v, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+		return simd.extract(v, LANE)
+	}
+}
+
+// Move vector element to general-purpose register
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_p16)
+@(require_results, enable_target_feature = "neon")
+vgetq_lane_p16 :: #force_inline proc "c" (v: poly16x8_t, $LANE: int32_t) -> poly16_t where 0 <= LANE, LANE < 8 {
+	when ODIN_ENDIAN == .Little {
+		return simd.extract(v, LANE)
+	} else {
+		v := simd.shuffle(v, v, 7, 6, 5, 4, 3, 2, 1, 0)
+		return simd.extract(v, LANE)
+	}
+}
+
+// Move vector element to general-purpose register
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vgetq_lane_p64)
+@(require_results, enable_target_feature = "neon")
+vgetq_lane_p64 :: #force_inline proc "c" (v: poly64x2_t, $LANE: int32_t) -> poly64_t where 0 <= LANE, LANE < 2 {
+	when ODIN_ENDIAN == .Little {
+		return simd.extract(v, LANE)
+	} else {
+		v := simd.shuffle(v, v, 1, 0)
+		return simd.extract(v, LANE)
+	}
+}
+
+// Duplicate vector element to vector or scalar
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_p8)
+@(require_results, enable_target_feature = "neon")
+vget_low_p8 :: #force_inline proc "c" (a: poly8x16_t) -> poly8x8_t {
+	when ODIN_ENDIAN == .Little {
+		return simd.shuffle(a, a, 0, 1, 2, 3, 4, 5, 6, 7)
+	} else {
+		a := simd.shuffle(a, a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+		b := simd.shuffle(a, a, 0, 1, 2, 3, 4, 5, 6, 7)
+		return simd.shuffle(b, b, 7, 6, 5, 4, 3, 2, 1, 0)
+	}
+}
+
+// Duplicate vector element to vector or scalar
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_p16)
+@(require_results, enable_target_feature = "neon")
+vget_low_p16 :: #force_inline proc "c" (a: poly16x8_t) -> poly16x4_t {
+	when ODIN_ENDIAN == .Little {
+		return simd.shuffle(a, a, 0, 1, 2, 3)
+	} else {
+		a := simd.shuffle(a, a, 7, 6, 5, 4, 3, 2, 1, 0)
+		b := simd.shuffle(a, a, 0, 1, 2, 3)
+		return simd.shuffle(b, b, 3, 2, 1, 0)
+	}
+}
+
+// Duplicate vector element to vector or scalar
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_low_p64)
+@(require_results, enable_target_feature = "neon")
+vget_low_p64 :: #force_inline proc "c" (a: poly64x2_t) -> poly64x1_t {
+	when ODIN_ENDIAN == .Little {
+		return transmute(poly64x1_t)simd.extract(a, 0)
+	} else {
+		a := simd.shuffle(a, a, 1, 0)
+		return transmute(poly64x1_t)simd.extract(a, 0)
+	}
+}
+
+// Duplicate vector element to vector or scalar
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_p8)
+@(require_results, enable_target_feature = "neon")
+vget_high_p8 :: #force_inline proc "c" (a: poly8x16_t) -> poly8x8_t {
+	when ODIN_ENDIAN == .Little {
+		return simd.shuffle(a, a, 8, 9, 10, 11, 12, 13, 14, 15)
+	} else {
+		a := simd.shuffle(a, a, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
+		b := simd.shuffle(a, a, 8, 9, 10, 11, 12, 13, 14, 15)
+		return simd.shuffle(b, b, 7, 6, 5, 4, 3, 2, 1, 0)
+	}
+}
+
+// Duplicate vector element to vector or scalar
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_p16)
+@(require_results, enable_target_feature = "neon")
+vget_high_p16 :: #force_inline proc "c" (a: poly16x8_t) -> poly16x4_t {
+	when ODIN_ENDIAN == .Little {
+		return simd.shuffle(a, a, 4, 5, 6, 7)
+	} else {
+		a := simd.shuffle(a, a, 7, 6, 5, 4, 3, 2, 1, 0)
+		b := simd.shuffle(a, a, 4, 5, 6, 7)
+		return simd.shuffle(b, b, 3, 2, 1, 0)
+	}
+}
+
+// Duplicate vector element to vector or scalar
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vget_high_p64)
+@(require_results, enable_target_feature = "neon")
+vget_high_p64 :: #force_inline proc "c" (a: poly64x2_t) -> poly64x1_t {
+	when ODIN_ENDIAN == .Little {
+		return transmute(poly64x1_t)simd.extract(a, 1)
+	} else {
+		a := simd.shuffle(a, a, 1, 0)
+		return transmute(poly64x1_t)simd.extract(a, 1)
+	}
+}
+
+// Bitwise exclusive OR
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_p8)
+@(require_results, enable_target_feature = "neon")
+vadd_p8 :: #force_inline proc "c" (a, b: poly8x8_t) -> poly8x8_t {
+	return simd.bit_xor(a, b)
+}
+
+// Bitwise exclusive OR
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_p16)
+@(require_results, enable_target_feature = "neon")
+vadd_p16 :: #force_inline proc "c" (a, b: poly16x4_t) -> poly16x4_t {
+	return simd.bit_xor(a, b)
+}
+
+// Bitwise exclusive OR
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vadd_p64)
+@(require_results, enable_target_feature = "neon")
+vadd_p64 :: #force_inline proc "c" (a, b: poly64x1_t) -> poly64x1_t {
+	return simd.bit_xor(a, b)
+}
+
+// Bitwise exclusive OR
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_p8)
+@(require_results, enable_target_feature = "neon")
+vaddq_p8 :: #force_inline proc "c" (a, b: poly8x16_t) -> poly8x16_t {
+	return simd.bit_xor(a, b)
+}
+
+// Bitwise exclusive OR
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_p16)
+@(require_results, enable_target_feature = "neon")
+vaddq_p16 :: #force_inline proc "c" (a, b: poly16x8_t) -> poly16x8_t {
+	return simd.bit_xor(a, b)
+}
+
+// Bitwise exclusive OR
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_p64)
+@(require_results, enable_target_feature = "neon")
+vaddq_p64 :: #force_inline proc "c" (a, b: poly64x2_t) -> poly64x2_t {
+	return simd.bit_xor(a, b)
+}
+
+// Bitwise exclusive OR
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vaddq_p128)
+@(require_results, enable_target_feature = "neon")
+vaddq_p128 :: #force_inline proc "c" (a, b: poly128_t) -> poly128_t {
+	return a ~ b
+}
+
+// Polynomial multiply
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmul_p8)
+@(require_results, enable_target_feature = "neon")
+vmul_p8 :: #force_inline proc "c" (a, b: poly8x8_t) -> poly8x8_t {
+	return _vmul_p8(a, b)
+}
+
+// Polynomial multiply
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmulq_p8)
+@(require_results, enable_target_feature = "neon")
+vmulq_p8 :: #force_inline proc "c" (a, b: poly8x16_t) -> poly8x16_t {
+	return _vmulq_p8(a, b)
+}
+
+// Polynomial multiply long
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_p8)
+@(require_results, enable_target_feature = "neon")
+vmull_p8 :: #force_inline proc "c" (a, b: poly8x8_t) -> poly16x8_t {
+	return _vmull_p8(a, b)
+}
+
+when ODIN_ARCH == .arm64 {
+	// Polynomial multiply long
+	//
+	// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_p8)
+	@(require_results, enable_target_feature = "neon")
+	vmull_high_p8 :: #force_inline proc "c" (a, b: poly8x16_t) -> poly16x8_t {
+		a := vget_high_p8(a)
+		b := vget_high_p8(b)
+		return vmull_p8(a, b)
+	}
+
+	// Polynomial multiply long
+	//
+	// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_p64)
+	@(require_results, enable_target_feature = "neon,aes")
+	vmull_p64 :: #force_inline proc "c" (a, b: poly64_t) -> poly128_t {
+		return transmute(poly128_t)_vmull_p64(a, b)
+	}
+
+	// Polynomial multiply long
+	//
+	// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vmull_high_p64)
+	@(require_results, enable_target_feature = "neon,aes")
+	vmull_high_p64 :: #force_inline proc "c" (a, b: poly64x2_t) -> poly128_t {
+		return vmull_p64(vgetq_lane_p64(a, 1), vgetq_lane_p64(b, 1))
+	}
+}
+
+@(private, default_calling_convention = "none")
+foreign _ {
+	@(link_name = "llvm.aarch64.neon.pmul.v8i8" when ODIN_ARCH == .arm64 else "llvm.arm.neon.vmulp.v8i8")
+	_vmul_p8 :: proc(a, b: poly8x8_t) -> poly8x8_t ---
+	@(link_name = "llvm.aarch64.neon.pmul.v16i8" when ODIN_ARCH == .arm64 else "llvm.arm.neon.vmulp.v16i8")
+	_vmulq_p8 :: proc(a, b: poly8x16_t) -> poly8x16_t ---
+	@(link_name = "llvm.aarch64.neon.pmull.v8i16" when ODIN_ARCH == .arm64 else "llvm.arm.neon.vmullp.v8i16")
+	_vmull_p8 :: proc(a, b: poly8x8_t) -> poly16x8_t ---
+}
+
+when ODIN_ARCH == .arm64 {
+	@(private, default_calling_convention = "none")
+	foreign _ {
+		@(link_name = "llvm.aarch64.neon.pmull64")
+		_vmull_p64 :: proc(a, b: poly64_t) -> int8x16_t ---
+	}
+}
diff --git a/core/simd/arm/sha.odin b/core/simd/arm/sha.odin
index ca87c9795..be1529823 100644
--- a/core/simd/arm/sha.odin
+++ b/core/simd/arm/sha.odin
@@ -1,88 +1,130 @@
 #+build arm64,arm32
 package simd_arm
 
+// SHA1 hash update, choose.
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1cq_u32)
 @(require_results, enable_target_feature = "sha2")
-vsha1cq_u32 :: #force_inline proc "c" (hash_abcd: uint32x4_t, e: uint32_t, wk: uint32x4_t) -> uint32x4_t {
-	return _vsha1cq_u32(hash_abcd, e, wk)
+vsha1cq_u32 :: #force_inline proc "c" (hash_abcd: uint32x4_t, hash_e: uint32_t, wk: uint32x4_t) -> uint32x4_t {
+	return _vsha1cq_u32(hash_abcd, hash_e, wk)
 }
 
+// SHA1 hash update, parity.
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1pq_u32)
 @(require_results, enable_target_feature = "sha2")
-vsha1pq_u32 :: #force_inline proc "c" (hash_abcd: uint32x4_t, e: uint32_t, wk: uint32x4_t) -> uint32x4_t {
-	return _vsha1pq_u32(hash_abcd, e, wk)
+vsha1pq_u32 :: #force_inline proc "c" (hash_abcd: uint32x4_t, hash_e: uint32_t, wk: uint32x4_t) -> uint32x4_t {
+	return _vsha1pq_u32(hash_abcd, hash_e, wk)
 }
 
+// SHA1 hash update, majority.
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1mq_u32)
 @(require_results, enable_target_feature = "sha2")
-vsha1mq_u32 :: #force_inline proc "c" (hash_abcd: uint32x4_t, e: uint32_t, wk: uint32x4_t) -> uint32x4_t {
-	return _vsha1mq_u32(hash_abcd, e, wk)
+vsha1mq_u32 :: #force_inline proc "c" (hash_abcd: uint32x4_t, hash_e: uint32_t, wk: uint32x4_t) -> uint32x4_t {
+	return _vsha1mq_u32(hash_abcd, hash_e, wk)
 }
 
+// SHA1 fixed rotate.
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1h_u32)
 @(require_results, enable_target_feature = "sha2")
-vsha1h_u32 :: #force_inline proc "c" (e: uint32_t) -> uint32_t {
-	return _vsha1h_u32(e)
+vsha1h_u32 :: #force_inline proc "c" (hash_e: uint32_t) -> uint32_t {
+	return _vsha1h_u32(hash_e)
 }
 
+// SHA1 schedule update, first part.
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1su0q_u32)
 @(require_results, enable_target_feature = "sha2")
 vsha1su0q_u32 :: #force_inline proc "c" (w0_3, w4_7, w8_11: uint32x4_t) -> uint32x4_t {
 	return _vsha1su0q_u32(w0_3, w4_7, w8_11)
 }
 
+// SHA1 schedule update, second part.
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha1su1q_u32)
 @(require_results, enable_target_feature = "sha2")
 vsha1su1q_u32 :: #force_inline proc "c" (tw0_3, w12_15: uint32x4_t) -> uint32x4_t {
 	return _vsha1su1q_u32(tw0_3, w12_15)
 }
 
+// SHA256 hash update, first part.
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha256hq_u32)
 @(require_results, enable_target_feature = "sha2")
 vsha256hq_u32 :: #force_inline proc "c" (hash_abcd, hash_efgh, wk: uint32x4_t) -> uint32x4_t {
 	return _vsha256hq_u32(hash_abcd, hash_efgh, wk)
 }
 
+// SHA256 hash update, second part.
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha256h2q_u32)
 @(require_results, enable_target_feature = "sha2")
 vsha256h2q_u32 :: #force_inline proc "c" (hash_efgh, hash_abcd, wk: uint32x4_t) -> uint32x4_t {
 	return _vsha256h2q_u32(hash_efgh, hash_abcd, wk)
 }
 
+// SHA256 schedule update, first part.
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha256su0q_u32)
 @(require_results, enable_target_feature = "sha2")
 vsha256su0q_u32 :: #force_inline proc "c" (w0_3, w4_7: uint32x4_t) -> uint32x4_t {
 	return _vsha256su0q_u32(w0_3, w4_7)
 }
 
+// SHA256 schedule update, second part.
+//
+// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha256su1q_u32)
 @(require_results, enable_target_feature = "sha2")
 vsha256su1q_u32 :: #force_inline proc "c" (tw0_3, w8_11, w12_15: uint32x4_t) -> uint32x4_t {
 	return _vsha256su1q_u32(tw0_3, w8_11, w12_15)
 }
 
-// Note: The SHA512 instructions are part of the `sha3` feature set.
+when ODIN_ARCH == .arm64 {
+	// SHA512 hash update, first part.
+	//
+	// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha512hq_u64)
+	@(require_results, enable_target_feature = "neon,sha3")
+	vsha512hq_u64 :: #force_inline proc "c" (hash_ed, hash_gf, kwh_kwh2: uint64x2_t) -> uint64x2_t {
+		return _vsha512hq_u64(hash_ed, hash_gf, kwh_kwh2)
+	}
 
-@(require_results, enable_target_feature = "sha3")
-vsha512hq_u64 :: #force_inline proc "c" (hash_ed, hash_gf, kwh_kwh2: uint64x2_t) -> uint64x2_t {
-	return _vsha512hq_u64(hash_ed, hash_gf, kwh_kwh2)
-}
+	// SHA512 hash update, second part.
+	//
+	// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha512h2q_u64)
+	@(require_results, enable_target_feature = "neon,sha3")
+	vsha512h2q_u64 :: #force_inline proc "c" (sum_ab, hash_c_, hash_ab: uint64x2_t) -> uint64x2_t {
+		return _vsha512h2q_u64(sum_ab, hash_c_, hash_ab)
+	}
 
-@(require_results, enable_target_feature = "sha3")
-vsha512h2q_u64 :: #force_inline proc "c" (sum_ab, hash_c_, hash_ab: uint64x2_t) -> uint64x2_t {
-	return _vsha512h2q_u64(sum_ab, hash_c_, hash_ab)
-}
+	// SHA512 schedule update, first part.
+	//
+	// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha512su0q_u64)
+	@(require_results, enable_target_feature = "neon,sha3")
+	vsha512su0q_u64 :: #force_inline proc "c" (w0_1, w2_: uint64x2_t) -> uint64x2_t {
+		return _vsha512su0q_u64(w0_1, w2_)
+	}
 
-@(require_results, enable_target_feature = "sha3")
-vsha512su0q_u64 :: #force_inline proc "c" (w0_1, w2_: uint64x2_t) -> uint64x2_t {
-	return _vsha512su0q_u64(w0_1, w2_)
-}
-
-@(require_results, enable_target_feature = "sha3")
-vsha512su1q_u64 :: #force_inline proc "c" (s01_s02, w14_15, w9_10: uint64x2_t) -> uint64x2_t {
-	return _vsha512su1q_u64(s01_s02, w14_15, w9_10)
+	// SHA512 schedule update, second part.
+	//
+	// [Arm's documentation](https://developer.arm.com/architectures/instruction-sets/intrinsics/vsha512su1q_u64)
+	@(require_results, enable_target_feature = "neon,sha3")
+	vsha512su1q_u64 :: #force_inline proc "c" (s01_s02, w14_15, w9_10: uint64x2_t) -> uint64x2_t {
+		return _vsha512su1q_u64(s01_s02, w14_15, w9_10)
+	}
 }
 
 @(private, default_calling_convention = "none")
 foreign _ {
 	@(link_name = "llvm.aarch64.crypto.sha1c" when ODIN_ARCH == .arm64 else "llvm.arm.neon.sha1c")
-	_vsha1cq_u32 :: proc(hash_abcd: uint32x4_t, e: uint32_t, wk: uint32x4_t) -> uint32x4_t ---
+	_vsha1cq_u32 :: proc(hash_abcd: uint32x4_t, hash_e: uint32_t, wk: uint32x4_t) -> uint32x4_t ---
 	@(link_name = "llvm.aarch64.crypto.sha1p" when ODIN_ARCH == .arm64 else "llvm.arm.neon.sha1p")
-	_vsha1pq_u32 :: proc(hash_abcd: uint32x4_t, e: uint32_t, wk: uint32x4_t) -> uint32x4_t ---
+	_vsha1pq_u32 :: proc(hash_abcd: uint32x4_t, hash_e: uint32_t, wk: uint32x4_t) -> uint32x4_t ---
 	@(link_name = "llvm.aarch64.crypto.sha1m" when ODIN_ARCH == .arm64 else "llvm.arm.neon.sha1m")
-	_vsha1mq_u32 :: proc(hash_abcd: uint32x4_t, e: uint32_t, wk: uint32x4_t) -> uint32x4_t ---
+	_vsha1mq_u32 :: proc(hash_abcd: uint32x4_t, hash_e: uint32_t, wk: uint32x4_t) -> uint32x4_t ---
 	@(link_name = "llvm.aarch64.crypto.sha1h" when ODIN_ARCH == .arm64 else "llvm.arm.neon.sha1h")
-	_vsha1h_u32 :: proc(e: uint32_t) -> uint32_t ---
+	_vsha1h_u32 :: proc(hash_e: uint32_t) -> uint32_t ---
 	@(link_name = "llvm.aarch64.crypto.sha1su0" when ODIN_ARCH == .arm64 else "llvm.arm.neon.sha1su0")
 	_vsha1su0q_u32 :: proc(w0_3, w4_7, w8_11: uint32x4_t) -> uint32x4_t ---
 	@(link_name = "llvm.aarch64.crypto.sha1su1" when ODIN_ARCH == .arm64 else "llvm.arm.neon.sha1su1")
@@ -96,13 +138,18 @@ foreign _ {
 	_vsha256su0q_u32 :: proc(w0_3, w4_7: uint32x4_t) -> uint32x4_t ---
 	@(link_name = "llvm.aarch64.crypto.sha256su1" when ODIN_ARCH == .arm64 else "llvm.arm.neon.sha256su1")
 	_vsha256su1q_u32 :: proc(tw0_3, w8_11, w12_15: uint32x4_t) -> uint32x4_t ---
-
-	@(link_name = "llvm.aarch64.crypto.sha512h" when ODIN_ARCH == .arm64 else "llvm.arm.neon.sha512h")
-	_vsha512hq_u64 :: proc(hash_ed, hash_gf, kwh_kwh2: uint64x2_t) -> uint64x2_t ---
-	@(link_name = "llvm.aarch64.crypto.sha512h2" when ODIN_ARCH == .arm64 else "llvm.arm.neon.sha512h2")
-	_vsha512h2q_u64 :: proc(sum_ab, hash_c_, hash_ab: uint64x2_t) -> uint64x2_t ---
-	@(link_name = "llvm.aarch64.crypto.sha512su0" when ODIN_ARCH == .arm64 else "llvm.arm.neon.sha512su0")
-	_vsha512su0q_u64 :: proc(w0_1, w2_: uint64x2_t) -> uint64x2_t ---
-	@(link_name = "llvm.aarch64.crypto.sha512su1" when ODIN_ARCH == .arm64 else "llvm.arm.neon.sha512su1")
-	_vsha512su1q_u64 :: proc(s01_s02, w14_15, w9_10: uint64x2_t) -> uint64x2_t ---
+}
+
+when ODIN_ARCH == .arm64 {
+	@(private, default_calling_convention = "none")
+	foreign _ {
+		@(link_name = "llvm.aarch64.crypto.sha512h")
+		_vsha512hq_u64 :: proc(hash_ed, hash_gf, kwh_kwh2: uint64x2_t) -> uint64x2_t ---
+		@(link_name = "llvm.aarch64.crypto.sha512h2")
+		_vsha512h2q_u64 :: proc(sum_ab, hash_c_, hash_ab: uint64x2_t) -> uint64x2_t ---
+		@(link_name = "llvm.aarch64.crypto.sha512su0")
+		_vsha512su0q_u64 :: proc(w0_1, w2_: uint64x2_t) -> uint64x2_t ---
+		@(link_name = "llvm.aarch64.crypto.sha512su1")
+		_vsha512su1q_u64 :: proc(s01_s02, w14_15, w9_10: uint64x2_t) -> uint64x2_t ---
+	}
 }
diff --git a/core/simd/arm/types.odin b/core/simd/arm/types.odin
index 05e3540b6..9379449e3 100644
--- a/core/simd/arm/types.odin
+++ b/core/simd/arm/types.odin
@@ -2,8 +2,26 @@
 package simd_arm
 
 // Type aliases to match `arm_neon.h`.
+uint8_t  :: u8
+uint16_t :: u16
 uint32_t :: u32
+uint64_t :: u64
+
+poly8_t   :: u8
+poly16_t  :: u16
+poly64_t  :: u64
+poly128_t :: u128
 
 uint8x16_t :: #simd[16]u8
 uint32x4_t :: #simd[4]u32
 uint64x2_t :: #simd[2]u64
+
+int32_t    :: i32
+int8x16_t  :: #simd[16]i8
+
+poly8x8_t  :: #simd[8]poly8_t
+poly8x16_t :: #simd[16]poly8_t
+poly16x4_t :: #simd[4]poly16_t
+poly16x8_t :: #simd[8]poly16_t
+poly64x1_t :: #simd[1]poly64_t
+poly64x2_t :: #simd[2]poly64_t
diff --git a/core/sys/posix/pthread.odin b/core/sys/posix/pthread.odin
index 84073c26f..1ee3875d8 100644
--- a/core/sys/posix/pthread.odin
+++ b/core/sys/posix/pthread.odin
@@ -5,7 +5,7 @@ import "core:c"
 
 when ODIN_OS == .Darwin {
 	foreign import lib "system:System"
-} else when ODIN_OS == .FreeBSD || ODIN_OS == .NetBSD || ODIN_OS == .Linux {
+} else when ODIN_OS == .FreeBSD || ODIN_OS == .NetBSD || ODIN_OS == .Linux || ODIN_OS == .OpenBSD {
 	foreign import lib "system:pthread"
 } else {
 	foreign import lib "system:c"
diff --git a/core/sys/windows/kernel32.odin b/core/sys/windows/kernel32.odin
index 9b08d7ba6..728bed485 100644
--- a/core/sys/windows/kernel32.odin
+++ b/core/sys/windows/kernel32.odin
@@ -180,7 +180,7 @@ foreign kernel32 {
 	ResumeThread         :: proc(thread: HANDLE) -> DWORD ---
 	GetThreadPriority    :: proc(thread: HANDLE) -> c_int ---
 	SetThreadPriority    :: proc(thread: HANDLE, priority: c_int) -> BOOL ---
-	GetThreadDescription :: proc(hThread: HANDLE, ppszThreadDescription: ^PCWSTR) -> HRESULT ---
+	GetThreadDescription :: proc(hThread: HANDLE, ppszThreadDescription: ^PWSTR) -> HRESULT ---
 	SetThreadDescription :: proc(hThread: HANDLE, lpThreadDescription: PCWSTR) -> HRESULT ---
 	GetExitCodeThread    :: proc(thread: HANDLE, exit_code: ^DWORD) -> BOOL ---
 	TerminateThread      :: proc(thread: HANDLE, exit_code: DWORD) -> BOOL ---
diff --git a/core/terminal/internal_os.odin b/core/terminal/internal_os.odin
index 127cbae54..f4be4480b 100644
--- a/core/terminal/internal_os.odin
+++ b/core/terminal/internal_os.odin
@@ -21,6 +21,15 @@ get_no_color :: proc() -> bool {
 	return false
 }
 
+get_is_dumb :: proc() -> bool {
+	buf: [128]u8
+	if term, err := os.lookup_env(buf[:], "TERM"); err == nil {
+		// "dumb" terminal overrides all other color and ansi capabilities logic
+		return term == "dumb"
+	}
+	return false
+}
+
 get_environment_color :: proc() -> Color_Depth {
 	buf: [128]u8
 	// `COLORTERM` is non-standard but widespread and unambiguous.
@@ -63,10 +72,10 @@ get_environment_color :: proc() -> Color_Depth {
 
 @(init)
 init_terminal :: proc "contextless" () {
-	_init_terminal()
-
 	context = runtime.default_context()
 
+	_init_terminal()
+
 	// We respect `NO_COLOR` specifically as a color-disabler but not as a
 	// blanket ban on any terminal manipulation codes, hence why this comes
 	// after `_init_terminal` which will allow Windows to enable Virtual
diff --git a/core/terminal/terminal.odin b/core/terminal/terminal.odin
index 86d928649..0f882b296 100644
--- a/core/terminal/terminal.odin
+++ b/core/terminal/terminal.odin
@@ -23,6 +23,11 @@ is_terminal :: proc(f: $T) -> bool {
 	return _is_terminal(f)
 }
 
+/*
+This is true if the terminal is dumb, i.e. cannot process ANSI control sequences.
+*/
+is_dumb: bool
+
 /*
 This is true if the terminal is accepting any form of colored text output.
 */
diff --git a/core/terminal/terminal_js.odin b/core/terminal/terminal_js.odin
index 78c6c240f..aafb3223a 100644
--- a/core/terminal/terminal_js.odin
+++ b/core/terminal/terminal_js.odin
@@ -8,6 +8,7 @@ _is_terminal :: proc "contextless" (handle: any) -> bool {
 
 _init_terminal :: proc "contextless" () {
 	color_depth = .None
+	is_dumb     = true
 }
 
 _fini_terminal :: proc "contextless" () { }
\ No newline at end of file
diff --git a/core/terminal/terminal_posix.odin b/core/terminal/terminal_posix.odin
index 62a79797b..3b6701722 100644
--- a/core/terminal/terminal_posix.odin
+++ b/core/terminal/terminal_posix.odin
@@ -12,6 +12,7 @@ _is_terminal :: proc "contextless" (f: ^os.File) -> bool {
 _init_terminal :: proc "contextless" () {
 	context = runtime.default_context()
 	color_depth = get_environment_color()
+	is_dumb     = get_is_dumb()
 }
 
 _fini_terminal :: proc "contextless" () { }
diff --git a/core/terminal/terminal_windows.odin b/core/terminal/terminal_windows.odin
index 64244e1ac..aff71b362 100644
--- a/core/terminal/terminal_windows.odin
+++ b/core/terminal/terminal_windows.odin
@@ -18,6 +18,8 @@ old_modes: [2]struct{
 }
 
 _init_terminal :: proc "contextless" () {
+	context = runtime.default_context()
+
 	vtp_enabled: bool
 
 	for &v in old_modes {
@@ -41,11 +43,11 @@ _init_terminal :: proc "contextless" () {
 		// This color depth is available on Windows 10 since build 10586.
 		color_depth = .Four_Bit
 	} else {
-		context = runtime.default_context()
-
 		// The user may be on a non-default terminal emulator.
 		color_depth = get_environment_color()
 	}
+
+	is_dumb = get_is_dumb()
 }
 
 _fini_terminal :: proc "contextless" () {
diff --git a/core/testing/runner.odin b/core/testing/runner.odin
index 9033d078e..e298cf47c 100644
--- a/core/testing/runner.odin
+++ b/core/testing/runner.odin
@@ -278,9 +278,8 @@ runner :: proc(internal_tests: []Internal_Test) -> bool {
 
 	// The animations are only ever shown through STDOUT;
 	// STDERR is used exclusively for logging regardless of error level.
-	global_log_colors_disabled = !terminal.color_enabled || !terminal.is_terminal(os.stderr)
-	global_ansi_disabled       = !terminal.is_terminal(os.stdout)
-
+	global_log_colors_disabled = terminal.is_dumb || !terminal.color_enabled || !terminal.is_terminal(os.stderr)
+	global_ansi_disabled       = terminal.is_dumb || !terminal.is_terminal(os.stdout)
 	should_show_animations := FANCY_OUTPUT && terminal.color_enabled && !global_ansi_disabled
 
 	// -- Parse CLI options
diff --git a/core/text/scanner/scanner.odin b/core/text/scanner/scanner.odin
index 9445df58c..e8596abb7 100644
--- a/core/text/scanner/scanner.odin
+++ b/core/text/scanner/scanner.odin
@@ -377,8 +377,13 @@ scan_number :: proc(s: ^Scanner, ch: rune, seen_dot: bool) -> (rune, rune) {
 		ch, ds = digits(s, ch, base, &invalid)
 		digsep |= ds
 		if ch == '.' && .Scan_Floats in s.flags {
+			prev_s := s^
 			ch = advance(s)
-			seen_dot = true
+			if ch == '.' {
+				s^ = prev_s
+			} else {
+				seen_dot = true
+			}
 		}
 	}
 
@@ -457,9 +462,9 @@ scan_string :: proc(s: ^Scanner, quote: rune) -> (n: int) {
 		if ch == '\\' {
 			ch = advance(s)
 			switch ch {
-			case quote, 'a', 'b', 'e', 'f', 'n', 'r', 't', 'v', '\\':
+			case 'a', 'b', 'e', 'f', 'n', 'r', 't', 'v', '\\', '\'', '\"':
 				ch = advance(s)
-			case '0'..='7': ch = scan_digits(s, advance(s), 8, 3)
+			case '0'..='7': ch = scan_digits(s, advance(s), 8, 2)
 			case 'x':       ch = scan_digits(s, advance(s), 16, 2)
 			case 'u':       ch = scan_digits(s, advance(s), 16, 4)
 			case 'U':       ch = scan_digits(s, advance(s), 16, 8)
diff --git a/core/thread/thread.odin b/core/thread/thread.odin
index a07801b98..14e266b20 100644
--- a/core/thread/thread.odin
+++ b/core/thread/thread.odin
@@ -52,6 +52,10 @@ Thread :: struct {
 	// started. Should be set after the thread has been created, but before
 	// it is started.
 	data: rawptr,
+	// Thread's Name/Description that will get set during thread creation
+	// it will be set using init_context's allocator to allocate and free a cstring buffer
+	// for thread's creation only : do not refer to it, use thread.get_name instead
+	name: Maybe(string),
 	// User-supplied integer, that will be available to the thread once it is
 	// started. Should be set after the thread has been created, but before
 	// it is started.
@@ -105,9 +109,13 @@ thread will be in a suspended state, until `start()` procedure is called.
 
 To start the thread, call `start()`. Also the `create_and_start()`
 procedure can be called to create and start the thread immediately.
+
+Optionally specify the thread's name/description.
+the name/description will be truncated to fit the OS's limit.
 */
-create :: proc(procedure: Thread_Proc, priority := Thread_Priority.Normal) -> ^Thread {
-	return _create(procedure, priority)
+
+create :: proc(procedure: Thread_Proc, priority := Thread_Priority.Normal, name: Maybe(string) = nil) -> ^Thread {
+	return _create(procedure, priority, name)
 }
 
 /*
@@ -159,6 +167,20 @@ yield :: proc() {
 	_yield()
 }
 
+/*
+Get thread's name/description.
+
+This procedure returns the name of the given thread. If `thread` is `nil`, this procedure returns the name of the calling thread.
+OS level errors are silently ignored.
+
+**Note(linux, bsd)**: Because the thread name is stored in as the `cmdline`, if the thread name was not set, the command that has been used to create the process will be used as the name of the thread.
+
+allocates memory for the returned string using provided allocator.
+*/
+get_name :: proc(thread: ^Thread = nil, allocator := context.temp_allocator, loc := #caller_location) -> (string, runtime.Allocator_Error) {
+	return _get_name(thread, allocator, loc)
+}
+
 /*
 Run a procedure on a different thread.
 
@@ -166,12 +188,15 @@ This procedure runs the given procedure on another thread. The context
 specified by `init_context` will be used as the context in which `fn` is going
 to execute. The thread will have priority specified by the `priority` parameter.
 
+Optionally specify the thread's name/description.
+the name/description will be truncated to fit the OS's limit.
+
 **IMPORTANT**: If `init_context` is specified and the default temporary allocator
 is used, the thread procedure needs to call `runtime.default_temp_allocator_destroy()`
 in order to free the resources associated with the temporary allocations.
 */
-run :: proc(fn: proc(), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal) {
-	create_and_start(fn, init_context, priority, true)
+run :: proc(fn: proc(), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, name: Maybe(string) = nil) {
+	create_and_start(fn, init_context, priority, true, name)
 }
 
 /*
@@ -181,12 +206,15 @@ This procedure runs the given procedure on another thread. The context
 specified by `init_context` will be used as the context in which `fn` is going
 to execute. The thread will have priority specified by the `priority` parameter.
 
+Optionally specify the thread's name/description.
+the name/description will be truncated to fit the OS's limit.
+
 **IMPORTANT**: If `init_context` is specified and the default temporary allocator
 is used, the thread procedure needs to call `runtime.default_temp_allocator_destroy()`
 in order to free the resources associated with the temporary allocations.
 */
-run_with_data :: proc(data: rawptr, fn: proc(data: rawptr), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal) {
-	create_and_start_with_data(data, fn, init_context, priority, true)
+run_with_data :: proc(data: rawptr, fn: proc(data: rawptr), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, name: Maybe(string) = nil) {
+	create_and_start_with_data(data, fn, init_context, priority, true, name)
 }
 
 /*
@@ -196,13 +224,16 @@ This procedure runs the given procedure on another thread. The context
 specified by `init_context` will be used as the context in which `fn` is going
 to execute. The thread will have priority specified by the `priority` parameter.
 
+Optionally specify the thread's name/description.
+the name/description will be truncated to fit the OS's limit.
+
 **IMPORTANT**: If `init_context` is specified and the default temporary allocator
 is used, the thread procedure needs to call `runtime.default_temp_allocator_destroy()`
 in order to free the resources associated with the temporary allocations.
 */
-run_with_poly_data :: proc(data: $T, fn: proc(data: T), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal)
+run_with_poly_data :: proc(data: $T, fn: proc(data: T), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, name: Maybe(string) = nil)
 	where size_of(T) <= size_of(rawptr) * MAX_USER_ARGUMENTS {
-	create_and_start_with_poly_data(data, fn, init_context, priority, true)
+	create_and_start_with_poly_data(data, fn, init_context, priority, true, name)
 }
 
 /*
@@ -212,13 +243,16 @@ This procedure runs the given procedure on another thread. The context
 specified by `init_context` will be used as the context in which `fn` is going
 to execute. The thread will have priority specified by the `priority` parameter.
 
+Optionally specify the thread's name/description.
+the name/description will be truncated to fit the OS's limit.
+
 **IMPORTANT**: If `init_context` is specified and the default temporary allocator
 is used, the thread procedure needs to call `runtime.default_temp_allocator_destroy()`
 in order to free the resources associated with the temporary allocations.
 */
-run_with_poly_data2 :: proc(arg1: $T1, arg2: $T2, fn: proc(T1, T2), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal)
+run_with_poly_data2 :: proc(arg1: $T1, arg2: $T2, fn: proc(T1, T2), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, name: Maybe(string) = nil)
 	where size_of(T1) + size_of(T2) <= size_of(rawptr) * MAX_USER_ARGUMENTS {
-	create_and_start_with_poly_data2(arg1, arg2, fn, init_context, priority, true)
+	create_and_start_with_poly_data2(arg1, arg2, fn, init_context, priority, true, name)
 }
 
 /*
@@ -228,13 +262,16 @@ This procedure runs the given procedure on another thread. The context
 specified by `init_context` will be used as the context in which `fn` is going
 to execute. The thread will have priority specified by the `priority` parameter.
 
+Optionally specify the thread's name/description.
+the name/description will be truncated to fit the OS's limit.
+
 **IMPORTANT**: If `init_context` is specified and the default temporary allocator
 is used, the thread procedure needs to call `runtime.default_temp_allocator_destroy()`
 in order to free the resources associated with the temporary allocations.
 */
-run_with_poly_data3 :: proc(arg1: $T1, arg2: $T2, arg3: $T3, fn: proc(arg1: T1, arg2: T2, arg3: T3), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal)
+run_with_poly_data3 :: proc(arg1: $T1, arg2: $T2, arg3: $T3, fn: proc(arg1: T1, arg2: T2, arg3: T3), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, name: Maybe(string) = nil)
 	where size_of(T1) + size_of(T2) + size_of(T3) <= size_of(rawptr) * MAX_USER_ARGUMENTS {
-	create_and_start_with_poly_data3(arg1, arg2, arg3, fn, init_context, priority, true)
+	create_and_start_with_poly_data3(arg1, arg2, arg3, fn, init_context, priority, true, name)
 }
 
 /*
@@ -244,13 +281,16 @@ This procedure runs the given procedure on another thread. The context
 specified by `init_context` will be used as the context in which `fn` is going
 to execute. The thread will have priority specified by the `priority` parameter.
 
+Optionally specify the thread's name/description.
+the name/description will be truncated to fit the OS's limit.
+
 **IMPORTANT**: If `init_context` is specified and the default temporary allocator
 is used, the thread procedure needs to call `runtime.default_temp_allocator_destroy()`
 in order to free the resources associated with the temporary allocations.
 */
-run_with_poly_data4 :: proc(arg1: $T1, arg2: $T2, arg3: $T3, arg4: $T4, fn: proc(arg1: T1, arg2: T2, arg3: T3, arg4: T4), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal)
+run_with_poly_data4 :: proc(arg1: $T1, arg2: $T2, arg3: $T3, arg4: $T4, fn: proc(arg1: T1, arg2: T2, arg3: T3, arg4: T4), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, name: Maybe(string) = nil)
 	where size_of(T1) + size_of(T2) + size_of(T3) + size_of(T4) <= size_of(rawptr) * MAX_USER_ARGUMENTS {
-	create_and_start_with_poly_data4(arg1, arg2, arg3, arg4, fn, init_context, priority, true)
+	create_and_start_with_poly_data4(arg1, arg2, arg3, arg4, fn, init_context, priority, true, name)
 }
 
 /*
@@ -264,6 +304,9 @@ If `self_cleanup` is specified, after the thread finishes the execution of the
 `fn` procedure, the resources associated with the thread are going to be
 automatically freed.
 
+Optionally specify the thread's name/description.
+the name/description will be truncated to fit the OS's limit.
+
 **Do not** dereference the `^Thread` pointer, if this flag is specified.
 That includes calling `join`, which needs to dereference ^Thread`.
 
@@ -271,12 +314,12 @@ That includes calling `join`, which needs to dereference ^Thread`.
 is used, the thread procedure needs to call `runtime.default_temp_allocator_destroy()`
 in order to free the resources associated with the temporary allocations.
 */
-create_and_start :: proc(fn: proc(), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, self_cleanup := false) -> (t: ^Thread) {
+create_and_start :: proc(fn: proc(), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, self_cleanup := false, name: Maybe(string) = nil) -> (t: ^Thread) {
 	thread_proc :: proc(t: ^Thread) {
 		fn := cast(proc())t.data
 		fn()
 	}
-	if t = create(thread_proc, priority); t == nil {
+	if t = create(thread_proc, priority, name); t == nil {
 		return
 	}
 	t.data = rawptr(fn)
@@ -299,6 +342,9 @@ If `self_cleanup` is specified, after the thread finishes the execution of the
 `fn` procedure, the resources associated with the thread are going to be
 automatically freed.
 
+Optionally specify the thread's name/description.
+the name/description will be truncated to fit the OS's limit.
+
 **Do not** dereference the `^Thread` pointer, if this flag is specified.
 That includes calling `join`, which needs to dereference ^Thread`.
 
@@ -306,14 +352,14 @@ That includes calling `join`, which needs to dereference ^Thread`.
 is used, the thread procedure needs to call `runtime.default_temp_allocator_destroy()`
 in order to free the resources associated with the temporary allocations.
 */
-create_and_start_with_data :: proc(data: rawptr, fn: proc(data: rawptr), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, self_cleanup := false) -> (t: ^Thread) {
+create_and_start_with_data :: proc(data: rawptr, fn: proc(data: rawptr), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, self_cleanup := false, name: Maybe(string) = nil) -> (t: ^Thread) {
 	thread_proc :: proc(t: ^Thread) {
 		fn := cast(proc(rawptr))t.data
 		assert(t.user_index >= 1)
 		data := t.user_args[0]
 		fn(data)
 	}
-	if t = create(thread_proc, priority); t == nil {
+	if t = create(thread_proc, priority, name); t == nil {
 		return
 	}
 	t.data = rawptr(fn)
@@ -338,6 +384,9 @@ If `self_cleanup` is specified, after the thread finishes the execution of the
 `fn` procedure, the resources associated with the thread are going to be
 automatically freed.
 
+Optionally specify the thread's name/description.
+the name/description will be truncated to fit the OS's limit.
+
 **Do not** dereference the `^Thread` pointer, if this flag is specified.
 That includes calling `join`, which needs to dereference ^Thread`.
 
@@ -345,7 +394,7 @@ That includes calling `join`, which needs to dereference ^Thread`.
 is used, the thread procedure needs to call `runtime.default_temp_allocator_destroy()`
 in order to free the resources associated with the temporary allocations.
 */
-create_and_start_with_poly_data :: proc(data: $T, fn: proc(data: T), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, self_cleanup := false) -> (t: ^Thread)
+create_and_start_with_poly_data :: proc(data: $T, fn: proc(data: T), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, self_cleanup := false, name: Maybe(string) = nil) -> (t: ^Thread)
 	where size_of(T) <= size_of(rawptr) * MAX_USER_ARGUMENTS {
 	thread_proc :: proc(t: ^Thread) {
 		fn := cast(proc(T))t.data
@@ -355,7 +404,7 @@ create_and_start_with_poly_data :: proc(data: $T, fn: proc(data: T), init_contex
 
 		fn(data)
 	}
-	if t = create(thread_proc, priority); t == nil {
+	if t = create(thread_proc, priority, name); t == nil {
 		return
 	}
 	t.data = rawptr(fn)
@@ -383,6 +432,9 @@ If `self_cleanup` is specified, after the thread finishes the execution of the
 `fn` procedure, the resources associated with the thread are going to be
 automatically freed.
 
+Optionally specify the thread's name/description.
+the name/description will be truncated to fit the OS's limit.
+
 **Do not** dereference the `^Thread` pointer, if this flag is specified.
 That includes calling `join`, which needs to dereference ^Thread`.
 
@@ -390,7 +442,7 @@ That includes calling `join`, which needs to dereference ^Thread`.
 is used, the thread procedure needs to call `runtime.default_temp_allocator_destroy()`
 in order to free the resources associated with the temporary allocations.
 */
-create_and_start_with_poly_data2 :: proc(arg1: $T1, arg2: $T2, fn: proc(T1, T2), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, self_cleanup := false) -> (t: ^Thread)
+create_and_start_with_poly_data2 :: proc(arg1: $T1, arg2: $T2, fn: proc(T1, T2), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, self_cleanup := false, name: Maybe(string) = nil) -> (t: ^Thread)
 	where size_of(T1) + size_of(T2) <= size_of(rawptr) * MAX_USER_ARGUMENTS {
 	thread_proc :: proc(t: ^Thread) {
 		fn := cast(proc(T1, T2))t.data
@@ -403,7 +455,7 @@ create_and_start_with_poly_data2 :: proc(arg1: $T1, arg2: $T2, fn: proc(T1, T2),
 
 		fn(arg1, arg2)
 	}
-	if t = create(thread_proc, priority); t == nil {
+	if t = create(thread_proc, priority, name); t == nil {
 		return
 	}
 	t.data = rawptr(fn)
@@ -434,6 +486,9 @@ If `self_cleanup` is specified, after the thread finishes the execution of the
 `fn` procedure, the resources associated with the thread are going to be
 automatically freed.
 
+Optionally specify the thread's name/description.
+the name/description will be truncated to fit the OS's limit.
+
 **Do not** dereference the `^Thread` pointer, if this flag is specified.
 That includes calling `join`, which needs to dereference ^Thread`.
 
@@ -441,7 +496,7 @@ That includes calling `join`, which needs to dereference ^Thread`.
 is used, the thread procedure needs to call `runtime.default_temp_allocator_destroy()`
 in order to free the resources associated with the temporary allocations.
 */
-create_and_start_with_poly_data3 :: proc(arg1: $T1, arg2: $T2, arg3: $T3, fn: proc(arg1: T1, arg2: T2, arg3: T3), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, self_cleanup := false) -> (t: ^Thread)
+create_and_start_with_poly_data3 :: proc(arg1: $T1, arg2: $T2, arg3: $T3, fn: proc(arg1: T1, arg2: T2, arg3: T3), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, self_cleanup := false, name: Maybe(string) = nil) -> (t: ^Thread)
 	where size_of(T1) + size_of(T2) + size_of(T3) <= size_of(rawptr) * MAX_USER_ARGUMENTS {
 	thread_proc :: proc(t: ^Thread) {
 		fn := cast(proc(T1, T2, T3))t.data
@@ -455,7 +510,7 @@ create_and_start_with_poly_data3 :: proc(arg1: $T1, arg2: $T2, arg3: $T3, fn: pr
 
 		fn(arg1, arg2, arg3)
 	}
-	if t = create(thread_proc, priority); t == nil {
+	if t = create(thread_proc, priority, name); t == nil {
 		return
 	}
 	t.data = rawptr(fn)
@@ -487,6 +542,9 @@ If `self_cleanup` is specified, after the thread finishes the execution of the
 `fn` procedure, the resources associated with the thread are going to be
 automatically freed.
 
+Optionally specify the thread's name/description.
+the name/description will be truncated to fit the OS's limit.
+
 **Do not** dereference the `^Thread` pointer, if this flag is specified.
 That includes calling `join`, which needs to dereference ^Thread`.
 
@@ -494,7 +552,7 @@ That includes calling `join`, which needs to dereference ^Thread`.
 is used, the thread procedure needs to call `runtime.default_temp_allocator_destroy()`
 in order to free the resources associated with the temporary allocations.
 */
-create_and_start_with_poly_data4 :: proc(arg1: $T1, arg2: $T2, arg3: $T3, arg4: $T4, fn: proc(arg1: T1, arg2: T2, arg3: T3, arg4: T4), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, self_cleanup := false) -> (t: ^Thread)
+create_and_start_with_poly_data4 :: proc(arg1: $T1, arg2: $T2, arg3: $T3, arg4: $T4, fn: proc(arg1: T1, arg2: T2, arg3: T3, arg4: T4), init_context: Maybe(runtime.Context) = nil, priority := Thread_Priority.Normal, self_cleanup := false, name: Maybe(string) = nil) -> (t: ^Thread)
 	where size_of(T1) + size_of(T2) + size_of(T3) + size_of(T4) <= size_of(rawptr) * MAX_USER_ARGUMENTS {
 	thread_proc :: proc(t: ^Thread) {
 		fn := cast(proc(T1, T2, T3, T4))t.data
@@ -508,7 +566,7 @@ create_and_start_with_poly_data4 :: proc(arg1: $T1, arg2: $T2, arg3: $T3, arg4:
 
 		fn(arg1, arg2, arg3, arg4)
 	}
-	if t = create(thread_proc, priority); t == nil {
+	if t = create(thread_proc, priority, name); t == nil {
 		return
 	}
 	t.data = rawptr(fn)
@@ -560,4 +618,4 @@ _maybe_destroy_default_temp_allocator :: proc(init_context: Maybe(runtime.Contex
 	if context.temp_allocator.procedure == runtime.default_temp_allocator_proc {
 		runtime.default_temp_allocator_destroy(auto_cast context.temp_allocator.data)
 	}
-}
\ No newline at end of file
+}
diff --git a/core/thread/thread_name_darwin.odin b/core/thread/thread_name_darwin.odin
new file mode 100644
index 000000000..7a01e0371
--- /dev/null
+++ b/core/thread/thread_name_darwin.odin
@@ -0,0 +1,15 @@
+#+build darwin
+#+private
+package thread
+
+import "core:sys/posix"
+import "core:c"
+
+_MAX_PTHREAD_NAME_LENGTH :: 64
+
+foreign import pthread "system:System.framework"
+
+foreign pthread {
+	pthread_getname_np :: proc(thread: posix.pthread_t, name: [^]u8, len: c.size_t) -> posix.Errno ---
+	pthread_setname_np :: proc(name: [^]u8) -> posix.Errno ---
+}
diff --git a/core/thread/thread_name_freebsd.odin b/core/thread/thread_name_freebsd.odin
new file mode 100644
index 000000000..5b79728a2
--- /dev/null
+++ b/core/thread/thread_name_freebsd.odin
@@ -0,0 +1,15 @@
+#+build freebsd
+#+private
+package thread
+
+import "core:sys/posix"
+import "core:c"
+
+_MAX_PTHREAD_NAME_LENGTH :: 20
+
+foreign import pthread "system:pthread"
+
+foreign pthread {
+	pthread_getname_np :: proc(thread: posix.pthread_t, name: [^]u8, len: c.size_t) -> posix.Errno ---
+	pthread_setname_np :: proc(thread: posix.pthread_t, name: [^]u8) -> posix.Errno ---
+}
diff --git a/core/thread/thread_name_linux.odin b/core/thread/thread_name_linux.odin
new file mode 100644
index 000000000..b84bf999c
--- /dev/null
+++ b/core/thread/thread_name_linux.odin
@@ -0,0 +1,15 @@
+#+build linux
+#+private
+package thread
+
+import "core:sys/posix"
+import "core:c"
+
+_MAX_PTHREAD_NAME_LENGTH :: 16
+
+foreign import pthread "system:pthread"
+
+foreign pthread {
+	pthread_getname_np :: proc(thread: posix.pthread_t, name: [^]u8, len: c.size_t) -> posix.Errno ---
+	pthread_setname_np :: proc(thread: posix.pthread_t, name: [^]u8) -> posix.Errno ---
+}
diff --git a/core/thread/thread_name_netbsd.odin b/core/thread/thread_name_netbsd.odin
new file mode 100644
index 000000000..c62c8c8f4
--- /dev/null
+++ b/core/thread/thread_name_netbsd.odin
@@ -0,0 +1,15 @@
+#+build netbsd
+#+private
+package thread
+
+import "core:sys/posix"
+import "core:c"
+
+_MAX_PTHREAD_NAME_LENGTH :: 32
+
+foreign import pthread "system:pthread"
+
+foreign pthread {
+	pthread_getname_np :: proc(thread: posix.pthread_t, name: [^]u8, len: c.size_t) -> posix.Errno ---
+	pthread_setname_np :: proc(thread: posix.pthread_t, name: cstring, arg: rawptr) -> posix.Errno ---
+}
diff --git a/core/thread/thread_name_openbsd.odin b/core/thread/thread_name_openbsd.odin
new file mode 100644
index 000000000..b349c2566
--- /dev/null
+++ b/core/thread/thread_name_openbsd.odin
@@ -0,0 +1,15 @@
+#+build openbsd
+#+private
+package thread
+
+import "core:sys/posix"
+import "core:c"
+
+foreign import pthread "system:pthread"
+
+_MAX_PTHREAD_NAME_LENGTH :: 20
+
+foreign pthread {
+	pthread_get_name_np :: proc(thread: posix.pthread_t, name: [^]u8, len: c.size_t) ---
+	pthread_set_name_np :: proc(thread: posix.pthread_t, name: [^]u8) ---
+}
diff --git a/core/thread/thread_other.odin b/core/thread/thread_other.odin
index 878119cbd..aa310d41e 100644
--- a/core/thread/thread_other.odin
+++ b/core/thread/thread_other.odin
@@ -2,6 +2,7 @@
 package thread
 
 import "base:intrinsics"
+import "base:runtime"
 
 _IS_SUPPORTED :: false
 
@@ -13,7 +14,7 @@ _thread_priority_map := [Thread_Priority]i32{
 	.High = +2,
 }
 
-_create :: proc(procedure: Thread_Proc, priority := Thread_Priority.Normal) -> ^Thread {
+_create :: proc(procedure: Thread_Proc, priority := Thread_Priority.Normal, name: Maybe(string) = nil) -> ^Thread {
 	unimplemented("core:thread procedure not supported on target")
 }
 
@@ -45,3 +46,10 @@ _yield :: proc() {
 	unimplemented("core:thread procedure not supported on target")
 }
 
+_get_name :: proc(thread: ^Thread, allocator : runtime.Allocator, loc : runtime.Source_Code_Location) -> (string, runtime.Allocator_Error) {
+	unimplemented("core:thread procedure not supported on this target")
+}
+
+_set_name :: proc(thread: ^Thread, name:string) {
+	unimplemented("core:thread procedure not supported on this target")
+}
diff --git a/core/thread/thread_unix.odin b/core/thread/thread_unix.odin
index 02e628df5..fef0db9f8 100644
--- a/core/thread/thread_unix.odin
+++ b/core/thread/thread_unix.odin
@@ -5,9 +5,9 @@ package thread
 import "base:runtime"
 import "core:sync"
 import "core:sys/posix"
+import "core:strings"
 
 _IS_SUPPORTED :: true
-
 // NOTE(tetra): Aligned here because of core/unix/pthread_linux.odin/pthread_t.
 // Also see core/sys/darwin/mach_darwin.odin/semaphore_t.
 Thread_Os_Specific :: struct #align(16) {
@@ -18,7 +18,7 @@ Thread_Os_Specific :: struct #align(16) {
 // Creates a thread which will run the given procedure.
 // It then waits for `start` to be called.
 //
-_create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread {
+_create :: proc(procedure: Thread_Proc, priority: Thread_Priority, name: Maybe(string)) -> ^Thread {
 	__unix_thread_entry_proc :: proc "c" (t: rawptr) -> rawptr {
 		t := (^Thread)(t)
 
@@ -50,6 +50,8 @@ _create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread {
 				runtime.run_thread_local_cleaners()
 			}
 
+			_set_name(t)
+
 			t.procedure(t)
 		}
 
@@ -122,6 +124,9 @@ _create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread {
 		free(thread, thread.creation_allocator)
 		return nil
 	}
+
+	thread.name = name
+
 	return thread
 }
 
@@ -184,3 +189,50 @@ _terminate :: proc(t: ^Thread, exit_code: int) {
 _yield :: proc() {
 	posix.sched_yield()
 }
+
+_get_name :: proc(thread: ^Thread, allocator: runtime.Allocator, loc: runtime.Source_Code_Location) -> (name: string, err: runtime.Allocator_Error) {
+	tid: posix.pthread_t
+	if thread == nil {
+		tid = posix.pthread_self()
+	} else {
+		tid = thread.unix_thread
+	}
+	
+	buf : [_MAX_PTHREAD_NAME_LENGTH]u8
+
+	when ODIN_OS == .OpenBSD {
+		pthread_get_name_np(tid, raw_data(buf[:]), len(buf))
+	} else {
+		pthread_getname_np(tid, raw_data(buf[:]), len(buf))
+	}
+
+	name, err = strings.clone_from_cstring(cstring(raw_data(buf[:])), allocator, loc)
+	return
+}
+
+_set_name :: proc(thread: ^Thread) {
+	name, ok := thread.name.?
+	if !ok {
+		return
+	}
+
+	when ODIN_OS != .Darwin {
+		tid := thread.unix_thread
+	}
+
+	// _MAX_PTHREAD_NAME_LENGTH includes terminating null
+	buflen := len(name) + 1 < _MAX_PTHREAD_NAME_LENGTH ? len(name) + 1 : _MAX_PTHREAD_NAME_LENGTH
+	buf := make([]u8, buflen)
+	defer delete(buf)
+	copy(buf[:len(buf) - 1], name)
+
+	when ODIN_OS == .Darwin {
+		pthread_setname_np(raw_data(buf[:]))
+	} else when ODIN_OS == .OpenBSD {
+		pthread_set_name_np(tid, raw_data(buf[:]))
+	} else when ODIN_OS == .NetBSD {
+		pthread_setname_np(tid, "%s", raw_data(buf[:]))
+	} else {
+		pthread_setname_np(tid, raw_data(buf[:]))
+	}
+}
diff --git a/core/thread/thread_windows.odin b/core/thread/thread_windows.odin
index 358e3e7f1..f13d550f7 100644
--- a/core/thread/thread_windows.odin
+++ b/core/thread/thread_windows.odin
@@ -6,9 +6,13 @@ import "base:intrinsics"
 import "base:runtime"
 import "core:sync"
 import win32 "core:sys/windows"
+import "core:unicode/utf16"
 
 _IS_SUPPORTED :: true
 
+//NOTE(peperronii): this is the system limit for windows api call, not specific to thread description
+_THREAD_DESCRIPTION_LENGTH :: 32_767
+
 Thread_Os_Specific :: struct {
 	win32_thread:    win32.HANDLE,
 	win32_thread_id: win32.DWORD,
@@ -22,7 +26,7 @@ _thread_priority_map := [Thread_Priority]i32{
 	.High = +2,
 }
 
-_create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread {
+_create :: proc(procedure: Thread_Proc, priority: Thread_Priority, name: Maybe(string)) -> ^Thread {
 	win32_thread_id: win32.DWORD
 
 	__windows_thread_entry_proc :: proc "system" (t_: rawptr) -> win32.DWORD {
@@ -44,6 +48,8 @@ _create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread {
 				runtime.run_thread_local_cleaners()
 			}
 
+			_set_name(t)
+
 			t.procedure(t)
 		}
 
@@ -76,6 +82,7 @@ _create :: proc(procedure: Thread_Proc, priority: Thread_Priority) -> ^Thread {
 	thread.win32_thread    = win32_thread
 	thread.win32_thread_id = win32_thread_id
 	thread.id              = int(win32_thread_id)
+	thread.name            = name
 
 	ok := win32.SetThreadPriority(win32_thread, _thread_priority_map[priority])
 	assert(ok == true)
@@ -152,3 +159,38 @@ _yield :: proc() {
 	win32.SwitchToThread()
 }
 
+_get_name :: proc(thread: ^Thread, allocator: runtime.Allocator, loc: runtime.Source_Code_Location) -> (name: string, err: runtime.Allocator_Error) {
+	t_handle: win32.HANDLE
+	if thread == nil {
+		t_handle = win32.GetCurrentThread()
+	} else {
+		t_handle = thread.win32_thread
+	}
+	
+	buf: win32.PWSTR
+
+	hr := win32.GetThreadDescription(t_handle, &buf)
+
+	if win32.SUCCEEDED(hr) {
+		defer win32.LocalFree(rawptr(buf))
+		name, err = win32.wstring_to_utf8(buf, -1, allocator)
+	}
+	return
+}
+
+_set_name :: proc(thread: ^Thread) {
+	name, ok := thread.name.?
+	if !ok {
+		return
+	}
+
+	t_handle := thread.win32_thread
+
+	// _THREAD_DESCRIPTION_LENGTH includes terminating null
+	buflen := len(name) + 1 < _THREAD_DESCRIPTION_LENGTH ? len(name) + 1 : _THREAD_DESCRIPTION_LENGTH
+	buf :=  make([]u16, buflen)
+	defer delete(buf)
+	utf16.encode_string(buf[:len(buf) - 1], name)
+	win32.SetThreadDescription(t_handle, cstring16(raw_data(buf[:])))
+}
+
diff --git a/src/big_int.cpp b/src/big_int.cpp
index f59dccf24..ffb7a6ad6 100644
--- a/src/big_int.cpp
+++ b/src/big_int.cpp
@@ -249,13 +249,28 @@ gb_internal void big_int_from_string(BigInt *dst, String const &s, bool *success
 	}
 	if (i < len && (text[i] == 'e' || text[i] == 'E')) {
 		i += 1;
-		GB_ASSERT(base == 10);
-		GB_ASSERT(text[i] != '-');
+		if (base != 10) {
+			// An exponent is only meaningful for a base 10 literal.
+			*success = false;
+			return;
+		}
+		if (i >= len) {
+			// Nothing follows the exponent marker.
+			*success = false;
+			return;
+		}
+		if (text[i] == '-') {
+			// A negative exponent is never an integer.
+			// The caller is expected to parse the value as a float instead.
+			*success = false;
+			return;
+		}
 		if (text[i] == '+') {
 			i += 1;
 		}
 
 		u64 exp = 0;
+		isize exp_digits = 0;
 		for (; i < len; i++) {
 			char r = cast(char)text[i];
 			if (r == '_') {
@@ -270,6 +285,11 @@ gb_internal void big_int_from_string(BigInt *dst, String const &s, bool *success
 			}
 			exp *= 10;
 			exp += v;
+			exp_digits += 1;
+		}
+		if (exp_digits == 0) {
+			*success = false;
+			return;
 		}
 
 		// NOTE(Jeroen): A valid integer can never have an exponent larger than 308 (per `max(f64)`).
diff --git a/src/build_settings_microarch.cpp b/src/build_settings_microarch.cpp
index d3010522d..0396d2d40 100644
--- a/src/build_settings_microarch.cpp
+++ b/src/build_settings_microarch.cpp
@@ -21,7 +21,7 @@ gb_global String target_microarch_list[TargetArch_COUNT] = {
 	// TargetArch_wasm64p32:
 	str_lit("bleeding-edge,generic,lime1,mvp"),
 	// TargetArch_riscv64:
-	str_lit("andes-45-series,andes-a25,andes-a45,andes-ax25,andes-ax45,andes-ax45mpv,andes-n45,andes-nx45,generic,generic-ooo,generic-rv32,generic-rv64,mips-p8700,rocket,rocket-rv32,rocket-rv64,rp2350-hazard3,sifive-7-series,sifive-e20,sifive-e21,sifive-e24,sifive-e31,sifive-e34,sifive-e76,sifive-p450,sifive-p470,sifive-p550,sifive-p670,sifive-p870,sifive-s21,sifive-s51,sifive-s54,sifive-s76,sifive-u54,sifive-u74,sifive-x280,sifive-x390,spacemit-x60,syntacore-scr1-base,syntacore-scr1-max,syntacore-scr3-rv32,syntacore-scr3-rv64,syntacore-scr4-rv32,syntacore-scr4-rv64,syntacore-scr5-rv32,syntacore-scr5-rv64,syntacore-scr7,tt-ascalon-d8,veyron-v1,xiangshan-kunminghu,xiangshan-nanhu"),
+	str_lit("andes-45-series,andes-a25,andes-a45,andes-ax25,andes-ax45,andes-ax45mpv,andes-n45,andes-nx45,generic,generic-ooo,generic-rv32,generic-rv64,mips-p8700,rocket,rocket-rv32,rocket-rv64,rp2350-hazard3,sifive-7-series,sifive-e20,sifive-e21,sifive-e24,sifive-e31,sifive-e34,sifive-e76,sifive-p450,sifive-p470,sifive-p550,sifive-p670,sifive-p870,sifive-s21,sifive-s51,sifive-s54,sifive-s76,sifive-u54,sifive-u74,sifive-x280,sifive-x390,spacemit-a100,spacemit-x100,spacemit-x60,syntacore-scr1-base,syntacore-scr1-max,syntacore-scr3-rv32,syntacore-scr3-rv64,syntacore-scr4-rv32,syntacore-scr4-rv64,syntacore-scr5-rv32,syntacore-scr5-rv64,syntacore-scr7,tt-ascalon-d8,veyron-v1,xiangshan-kunminghu,xiangshan-nanhu"),
 };
 
 // Generated with the featuregen script in `misc/featuregen`
@@ -41,7 +41,7 @@ gb_global String target_features_list[TargetArch_COUNT] = {
 	// TargetArch_wasm64p32:
 	str_lit("atomics,bulk-memory,bulk-memory-opt,call-indirect-overlong,exception-handling,extended-const,fp16,gc,multimemory,multivalue,mutable-globals,nontrapping-fptoint,reference-types,relaxed-simd,sign-ext,simd128,tail-call,wide-arithmetic"),
 	// TargetArch_riscv64:
-	str_lit("32bit,64bit,a,add-load-fusion,addi-load-fusion,andes45,auipc-addi-fusion,auipc-load-fusion,b,bfext-fusion,c,conditional-cmv-fusion,d,disable-latency-sched-heuristic,disable-misched-load-clustering,disable-misched-store-clustering,disable-postmisched-load-clustering,disable-postmisched-store-clustering,dlen-factor-2,e,enable-vsetvli-sched-heuristic,exact-asm,experimental,experimental-p,experimental-rvm23u32,experimental-smpmpmt,experimental-svukte,experimental-xrivosvisni,experimental-xrivosvizip,experimental-xsfmclic,experimental-xsfsclic,experimental-zibi,experimental-zicfilp,experimental-zicfiss,experimental-zvbc32e,experimental-zvfbfa,experimental-zvfofp8min,experimental-zvkgs,experimental-zvqdotq,f,forced-atomics,h,i,ld-add-fusion,log-vrgather,lui-addi-fusion,lui-load-fusion,m,mips-p8700,no-default-unroll,no-sink-splat-operands,no-trailing-seq-cst-fence,optimized-nf2-segment-load-store,optimized-nf3-segment-load-store,optimized-nf4-segment-load-store,optimized-nf5-segment-load-store,optimized-nf6-segment-load-store,optimized-nf7-segment-load-store,optimized-nf8-segment-load-store,optimized-zero-stride-load,permissive-zalrsc,predictable-select-expensive,prefer-vsetvli-over-read-vlenb,prefer-w-inst,q,relax,reserve-x1,reserve-x10,reserve-x11,reserve-x12,reserve-x13,reserve-x14,reserve-x15,reserve-x16,reserve-x17,reserve-x18,reserve-x19,reserve-x2,reserve-x20,reserve-x21,reserve-x22,reserve-x23,reserve-x24,reserve-x25,reserve-x26,reserve-x27,reserve-x28,reserve-x29,reserve-x3,reserve-x30,reserve-x31,reserve-x4,reserve-x5,reserve-x6,reserve-x7,reserve-x8,reserve-x9,rva20s64,rva20u64,rva22s64,rva22u64,rva23s64,rva23u64,rvb23s64,rvb23u64,rvi20u32,rvi20u64,save-restore,sdext,sdtrig,sha,shcounterenw,shgatpa,shifted-zextw-fusion,shlcofideleg,short-forward-branch-ialu,short-forward-branch-iload,short-forward-branch-iminmax,short-forward-branch-imul,shtvala,shvsatpa,shvstvala,shvstvecd,shxadd-load-fusion,sifive7,single-element-vec-fp64,smaia,smcdeleg,smcntrpmf,smcsrind,smctr,smdbltrp,smepmp,smmpm,smnpm,smrnmi,smstateen,ssaia,ssccfg,ssccptr,sscofpmf,sscounterenw,sscsrind,ssctr,ssdbltrp,ssnpm,sspm,ssqosid,ssstateen,ssstrict,sstc,sstvala,sstvecd,ssu64xl,supm,svade,svadu,svbare,svinval,svnapot,svpbmt,svvptc,tagged-globals,unaligned-scalar-mem,unaligned-vector-mem,use-postra-scheduler,v,ventana-veyron,vl-dependent-latency,vxrm-pipeline-flush,xandesbfhcvt,xandesperf,xandesvbfhcvt,xandesvdot,xandesvpackfph,xandesvsinth,xandesvsintload,xcvalu,xcvbi,xcvbitmanip,xcvelw,xcvmac,xcvmem,xcvsimd,xmipscbop,xmipscmov,xmipsexectl,xmipslsp,xqccmp,xqci,xqcia,xqciac,xqcibi,xqcibm,xqcicli,xqcicm,xqcics,xqcicsr,xqciint,xqciio,xqcilb,xqcili,xqcilia,xqcilo,xqcilsm,xqcisim,xqcisls,xqcisync,xsfcease,xsfmm128t,xsfmm16t,xsfmm32a16f,xsfmm32a32f,xsfmm32a8f,xsfmm32a8i,xsfmm32t,xsfmm64a64f,xsfmm64t,xsfmmbase,xsfvcp,xsfvfbfexp16e,xsfvfexp16e,xsfvfexp32e,xsfvfexpa,xsfvfexpa64e,xsfvfnrclipxfqf,xsfvfwmaccqqq,xsfvqmaccdod,xsfvqmaccqoq,xsifivecdiscarddlone,xsifivecflushdlone,xsmtvdot,xtheadba,xtheadbb,xtheadbs,xtheadcmo,xtheadcondmov,xtheadfmemidx,xtheadmac,xtheadmemidx,xtheadmempair,xtheadsync,xtheadvdot,xventanacondops,xwchc,za128rs,za64rs,zaamo,zabha,zacas,zalasr,zalrsc,zama16b,zawrs,zba,zbb,zbc,zbkb,zbkc,zbkx,zbs,zca,zcb,zcd,zce,zcf,zclsd,zcmop,zcmp,zcmt,zdinx,zexth-fusion,zextw-fusion,zfa,zfbfmin,zfh,zfhmin,zfinx,zhinx,zhinxmin,zic64b,zicbom,zicbop,zicboz,ziccamoa,ziccamoc,ziccif,zicclsm,ziccrse,zicntr,zicond,zicsr,zifencei,zihintntl,zihintpause,zihpm,zilsd,zilsd-4byte-align,zimop,zk,zkn,zknd,zkne,zknh,zkr,zks,zksed,zksh,zkt,zmmul,ztso,zvbb,zvbc,zve32f,zve32x,zve64d,zve64f,zve64x,zvfbfmin,zvfbfwma,zvfh,zvfhmin,zvkb,zvkg,zvkn,zvknc,zvkned,zvkng,zvknha,zvknhb,zvks,zvksc,zvksed,zvksg,zvksh,zvkt,zvl1024b,zvl128b,zvl16384b,zvl2048b,zvl256b,zvl32768b,zvl32b,zvl4096b,zvl512b,zvl64b,zvl65536b,zvl8192b"),
+	str_lit("32bit,64bit,a,add-mem-fusion,add-or-sub-andi-fusion,addi-mem-fusion,andes45,andi-add-fusion,andi-sub-fusion,auipc-addi-fusion,b,branch-fusion,c,conditional-cmv-fusion,d,disable-latency-sched-heuristic,dlen-factor-2,e,exact-asm,experimental,experimental-p,experimental-rvm23u32,experimental-smctr,experimental-ssctr,experimental-svukte,experimental-xqccmp,experimental-xqcia,experimental-xqciac,experimental-xqcibi,experimental-xqcibm,experimental-xqcicli,experimental-xqcicm,experimental-xqcics,experimental-xqcicsr,experimental-xqciint,experimental-xqciio,experimental-xqcilb,experimental-xqcili,experimental-xqcilia,experimental-xqcilo,experimental-xqcilsm,experimental-xqcisim,experimental-xqcisls,experimental-xqcisync,experimental-xrivosvisni,experimental-xrivosvizip,experimental-xsfmclic,experimental-xsfsclic,experimental-zalasr,experimental-zicfilp,experimental-zicfiss,experimental-zvbc32e,experimental-zvkgs,experimental-zvqdotq,f,fcvt-fmul-or-fmuladd-fusion,forced-atomics,h,i,ld-add-fusion,log-vrgather,logic-imm-imm-fusion,logic-imm-reg-fusion,logic-reg-imm-fusion,logic-reg-reg-fusion,lui-addi-fusion,lui-mem-fusion,m,mips-p8700,mul-add-fusion,mulw-addw-fusion,no-default-unroll,no-sink-splat-operands,no-trailing-seq-cst-fence,optimized-nf2-segment-load-store,optimized-nf3-segment-load-store,optimized-nf4-segment-load-store,optimized-nf5-segment-load-store,optimized-nf6-segment-load-store,optimized-nf7-segment-load-store,optimized-nf8-segment-load-store,optimized-zero-stride-load,predictable-select-expensive,prefer-vsetvli-over-read-vlenb,prefer-w-inst,q,relax,reserve-x1,reserve-x10,reserve-x11,reserve-x12,reserve-x13,reserve-x14,reserve-x15,reserve-x16,reserve-x17,reserve-x18,reserve-x19,reserve-x2,reserve-x20,reserve-x21,reserve-x22,reserve-x23,reserve-x24,reserve-x25,reserve-x26,reserve-x27,reserve-x28,reserve-x29,reserve-x3,reserve-x30,reserve-x31,reserve-x4,reserve-x5,reserve-x6,reserve-x7,reserve-x8,reserve-x9,rva20s64,rva20u64,rva22s64,rva22u64,rva23s64,rva23u64,rvb23s64,rvb23u64,rvi20u32,rvi20u64,save-restore,sdext,sdtrig,sh1adduw-lh-fusion,sha,shcounterenw,shgatpa,shift-imm-op-fusion,shifted-zextw-fusion,shlcofideleg,short-forward-branch-opt,shtvala,shvsatpa,shvstvala,shvstvecd,sifive7,smaia,smcdeleg,smcntrpmf,smcsrind,smdbltrp,smepmp,smmpm,smnpm,smrnmi,smstateen,ssaia,ssccfg,ssccptr,sscofpmf,sscounterenw,sscsrind,ssdbltrp,ssnpm,sspm,ssqosid,ssstateen,ssstrict,sstc,sstvala,sstvecd,ssu64xl,sub-sltiu-fusion,sub-sltu-fusion,supm,svade,svadu,svbare,svinval,svnapot,svpbmt,svvptc,tagged-globals,unaligned-scalar-mem,unaligned-vector-mem,use-postra-scheduler,v,ventana-veyron,vl-dependent-latency,vxrm-pipeline-flush,xandesbfhcvt,xandesperf,xandesvbfhcvt,xandesvdot,xandesvpackfph,xandesvsintload,xcvalu,xcvbi,xcvbitmanip,xcvelw,xcvmac,xcvmem,xcvsimd,xmipscbop,xmipscmov,xmipslsp,xsfcease,xsfmm128t,xsfmm16t,xsfmm32a16f,xsfmm32a32f,xsfmm32a8f,xsfmm32a8i,xsfmm32t,xsfmm64a64f,xsfmm64t,xsfmmbase,xsfvcp,xsfvfnrclipxfqf,xsfvfwmaccqqq,xsfvqmaccdod,xsfvqmaccqoq,xsifivecdiscarddlone,xsifivecflushdlone,xsmtvdot,xsmtvdotii,xtheadba,xtheadbb,xtheadbs,xtheadcmo,xtheadcondmov,xtheadfmemidx,xtheadmac,xtheadmemidx,xtheadmempair,xtheadsync,xtheadvdot,xventanacondops,xwchc,za128rs,za64rs,zaamo,zabha,zacas,zalrsc,zama16b,zawrs,zba,zbb,zbc,zbkb,zbkc,zbkx,zbs,zca,zcb,zcd,zce,zcf,zclsd,zcmop,zcmp,zcmt,zdinx,zexth-fusion,zextw-fusion,zfa,zfbfmin,zfh,zfhmin,zfinx,zhinx,zhinxmin,zic64b,zicbom,zicbop,zicboz,ziccamoa,ziccamoc,ziccif,zicclsm,ziccrse,zicntr,zicond,zicsr,zifencei,zihintntl,zihintpause,zihpm,zilsd,zimop,zk,zkn,zknd,zkne,zknh,zkr,zks,zksed,zksh,zkt,zmmul,ztso,zvbb,zvbc,zve32f,zve32x,zve64d,zve64f,zve64x,zvfbfmin,zvfbfwma,zvfh,zvfhmin,zvkb,zvkg,zvkn,zvknc,zvkned,zvkng,zvknha,zvknhb,zvks,zvksc,zvksed,zvksg,zvksh,zvkt,zvl1024b,zvl128b,zvl16384b,zvl2048b,zvl256b,zvl32768b,zvl32b,zvl4096b,zvl512b,zvl64b,zvl65536b,zvl8192b"),
 };
 
 // Generated with the featuregen script in `misc/featuregen`
@@ -61,7 +61,7 @@ gb_global int target_microarch_counts[TargetArch_COUNT] = {
 	// TargetArch_wasm64p32:
 	4,
 	// TargetArch_riscv64:
-	51,
+	53,
 };
 
 // Generated with the featuregen script in `misc/featuregen`
@@ -574,6 +574,8 @@ gb_global MicroarchFeatureList microarch_features_list[] = {
 	{ str_lit("sifive-u74"), str_lit("64bit,a,c,d,f,i,m,no-default-unroll,short-forward-branch-ialu,sifive7,use-postra-scheduler,zaamo,zalrsc,zca,zicsr,zifencei,zmmul") },
 	{ str_lit("sifive-x280"), str_lit("64bit,a,c,d,dlen-factor-2,f,i,m,no-default-unroll,optimized-nf2-segment-load-store,optimized-zero-stride-load,short-forward-branch-ialu,sifive7,use-postra-scheduler,v,vl-dependent-latency,zaamo,zalrsc,zba,zbb,zca,zfh,zfhmin,zicsr,zifencei,zmmul,zve32f,zve32x,zve64d,zve64f,zve64x,zvfh,zvfhmin,zvl128b,zvl256b,zvl32b,zvl512b,zvl64b") },
 	{ str_lit("sifive-x390"), str_lit("64bit,a,b,c,d,dlen-factor-2,experimental-zicfilp,experimental-zicfiss,f,i,m,no-default-unroll,optimized-nf2-segment-load-store,optimized-zero-stride-load,short-forward-branch-ialu,sifive7,single-element-vec-fp64,use-postra-scheduler,v,vl-dependent-latency,xsifivecdiscarddlone,xsifivecflushdlone,za64rs,zaamo,zalrsc,zawrs,zba,zbb,zbs,zca,zcb,zcmop,zfa,zfbfmin,zfh,zfhmin,zic64b,zicbom,zicbop,zicboz,ziccamoa,ziccif,ziccrse,zicntr,zicond,zicsr,zifencei,zihintntl,zihintpause,zihpm,zimop,zkr,zkt,zmmul,zvbb,zve32f,zve32x,zve64d,zve64f,zve64x,zvfbfmin,zvfbfwma,zvfh,zvfhmin,zvkb,zvkt,zvl1024b,zvl128b,zvl256b,zvl32b,zvl512b,zvl64b") },
+	{ str_lit("spacemit-a100"), str_lit("64bit,a,add-or-sub-andi-fusion,addi-mem-fusion,andi-add-fusion,andi-sub-fusion,auipc-addi-fusion,b,branch-fusion,c,d,dlen-factor-2,f,fcvt-fmul-or-fmuladd-fusion,h,i,logic-imm-imm-fusion,logic-imm-reg-fusion,logic-reg-imm-fusion,logic-reg-reg-fusion,lui-addi-fusion,lui-mem-fusion,m,no-default-unroll,optimized-nf2-segment-load-store,optimized-nf3-segment-load-store,optimized-nf4-segment-load-store,prefer-w-inst,sh1adduw-lh-fusion,sha,shcounterenw,shgatpa,shtvala,shvsatpa,shvstvala,shvstvecd,smepmp,smnpm,smstateen,ssccptr,sscofpmf,sscounterenw,ssnpm,sspm,ssstateen,sstc,sstvala,sstvecd,ssu64xl,sub-sltiu-fusion,sub-sltu-fusion,supm,svade,svbare,svinval,svnapot,svpbmt,use-postra-scheduler,v,vxrm-pipeline-flush,xsmtvdotii,za64rs,zaamo,zalrsc,zawrs,zba,zbb,zbc,zbkc,zbs,zca,zcb,zcd,zcmop,zfa,zfbfmin,zfh,zfhmin,zic64b,zicbom,zicbop,zicboz,ziccamoa,ziccif,zicclsm,ziccrse,zicntr,zicond,zicsr,zifencei,zihintntl,zihintpause,zihpm,zimop,zkt,zmmul,zvbb,zvbc,zve32f,zve32x,zve64d,zve64f,zve64x,zvfbfmin,zvfbfwma,zvfh,zvfhmin,zvkb,zvkg,zvkn,zvkned,zvkng,zvknha,zvknhb,zvks,zvksc,zvksed,zvksg,zvksh,zvkt,zvl1024b,zvl128b,zvl256b,zvl32b,zvl512b,zvl64b") },
+        { str_lit("spacemit-x100"), str_lit("64bit,a,add-mem-fusion,b,c,d,dlen-factor-2,f,h,i,logic-imm-reg-fusion,logic-reg-imm-fusion,logic-reg-reg-fusion,lui-addi-fusion,m,mul-add-fusion,mulw-addw-fusion,no-default-unroll,optimized-nf2-segment-load-store,optimized-nf3-segment-load-store,optimized-nf4-segment-load-store,sha,shcounterenw,shgatpa,shift-imm-op-fusion,shtvala,shvsatpa,shvstvala,shvstvecd,smepmp,smnpm,smstateen,ssccptr,sscofpmf,sscounterenw,ssnpm,sspm,ssstateen,sstc,sstvala,sstvecd,ssu64xl,supm,svade,svbare,svinval,svnapot,svpbmt,use-postra-scheduler,v,vxrm-pipeline-flush,xsmtvdot,za64rs,zaamo,zalrsc,zawrs,zba,zbb,zbc,zbkc,zbs,zca,zcb,zcd,zcmop,zfa,zfbfmin,zfh,zfhmin,zic64b,zicbom,zicbop,zicboz,ziccamoa,ziccif,zicclsm,ziccrse,zicntr,zicond,zicsr,zifencei,zihintntl,zihintpause,zihpm,zimop,zkt,zmmul,zvbb,zvbc,zve32f,zve32x,zve64d,zve64f,zve64x,zvfbfmin,zvfbfwma,zvfh,zvfhmin,zvkb,zvkg,zvkn,zvkned,zvkng,zvknha,zvknhb,zvks,zvksc,zvksed,zvksg,zvksh,zvkt,zvl128b,zvl256b,zvl32b,zvl64b") },
 	{ str_lit("spacemit-x60"), str_lit("64bit,a,b,c,d,dlen-factor-2,f,i,m,optimized-nf2-segment-load-store,optimized-nf3-segment-load-store,optimized-nf4-segment-load-store,ssccptr,sscofpmf,sscounterenw,sstc,sstvala,sstvecd,svade,svbare,svinval,svnapot,svpbmt,unaligned-scalar-mem,v,vxrm-pipeline-flush,xsmtvdot,za64rs,zaamo,zalrsc,zba,zbb,zbc,zbkc,zbs,zca,zfh,zfhmin,zic64b,zicbom,zicbop,zicboz,ziccamoa,ziccif,zicclsm,ziccrse,zicntr,zicond,zicsr,zifencei,zihintpause,zihpm,zkt,zmmul,zve32f,zve32x,zve64d,zve64f,zve64x,zvfh,zvfhmin,zvkt,zvl128b,zvl256b,zvl32b,zvl64b") },
 	{ str_lit("syntacore-scr1-base"), str_lit("32bit,c,i,no-default-unroll,zca,zicsr,zifencei") },
 	{ str_lit("syntacore-scr1-max"), str_lit("32bit,c,i,m,no-default-unroll,zca,zicsr,zifencei,zmmul") },
@@ -608,7 +610,7 @@ gb_global String target_microarch_list[TargetArch_COUNT] = {
 	// TargetArch_wasm64p32:
 	str_lit("bleeding-edge,generic,lime1,mvp"),
 	// TargetArch_riscv64:
-	str_lit("andes-45-series,andes-a25,andes-a45,andes-ax25,andes-ax45,andes-ax45mpv,andes-n45,andes-nx45,generic,generic-ooo,generic-rv32,generic-rv64,mips-p8700,rocket,rocket-rv32,rocket-rv64,rp2350-hazard3,sifive-7-series,sifive-e20,sifive-e21,sifive-e24,sifive-e31,sifive-e34,sifive-e76,sifive-p450,sifive-p470,sifive-p550,sifive-p670,sifive-p870,sifive-s21,sifive-s51,sifive-s54,sifive-s76,sifive-u54,sifive-u74,sifive-x280,sifive-x390,spacemit-x60,syntacore-scr1-base,syntacore-scr1-max,syntacore-scr3-rv32,syntacore-scr3-rv64,syntacore-scr4-rv32,syntacore-scr4-rv64,syntacore-scr5-rv32,syntacore-scr5-rv64,syntacore-scr7,tt-ascalon-d8,veyron-v1,xiangshan-kunminghu,xiangshan-nanhu"),
+	str_lit("andes-45-series,andes-a25,andes-a45,andes-ax25,andes-ax45,andes-ax45mpv,andes-n45,andes-nx45,generic,generic-ooo,generic-rv32,generic-rv64,mips-p8700,rocket,rocket-rv32,rocket-rv64,rp2350-hazard3,sifive-7-series,sifive-e20,sifive-e21,sifive-e24,sifive-e31,sifive-e34,sifive-e76,sifive-p450,sifive-p470,sifive-p550,sifive-p670,sifive-p870,sifive-s21,sifive-s51,sifive-s54,sifive-s76,sifive-u54,sifive-u74,sifive-x280,sifive-x390,spacemit-a100,spacemit-x100,spacemit-x60,syntacore-scr1-base,syntacore-scr1-max,syntacore-scr3-rv32,syntacore-scr3-rv64,syntacore-scr4-rv32,syntacore-scr4-rv64,syntacore-scr5-rv32,syntacore-scr5-rv64,syntacore-scr7,tt-ascalon-d8,veyron-v1,xiangshan-kunminghu,xiangshan-nanhu"),
 };
 
 // Generated with the featuregen script in `misc/featuregen`
@@ -628,7 +630,7 @@ gb_global String target_features_list[TargetArch_COUNT] = {
 	// TargetArch_wasm64p32:
 	str_lit("atomics,bulk-memory,bulk-memory-opt,call-indirect-overlong,exception-handling,extended-const,fp16,multimemory,multivalue,mutable-globals,nontrapping-fptoint,reference-types,relaxed-simd,sign-ext,simd128,tail-call,wide-arithmetic"),
 	// TargetArch_riscv64:
-	str_lit("32bit,64bit,a,andes45,auipc-addi-fusion,b,c,conditional-cmv-fusion,d,disable-latency-sched-heuristic,dlen-factor-2,e,exact-asm,experimental,experimental-p,experimental-rvm23u32,experimental-smctr,experimental-ssctr,experimental-svukte,experimental-xqccmp,experimental-xqcia,experimental-xqciac,experimental-xqcibi,experimental-xqcibm,experimental-xqcicli,experimental-xqcicm,experimental-xqcics,experimental-xqcicsr,experimental-xqciint,experimental-xqciio,experimental-xqcilb,experimental-xqcili,experimental-xqcilia,experimental-xqcilo,experimental-xqcilsm,experimental-xqcisim,experimental-xqcisls,experimental-xqcisync,experimental-xrivosvisni,experimental-xrivosvizip,experimental-xsfmclic,experimental-xsfsclic,experimental-zalasr,experimental-zicfilp,experimental-zicfiss,experimental-zvbc32e,experimental-zvkgs,experimental-zvqdotq,f,forced-atomics,h,i,ld-add-fusion,log-vrgather,lui-addi-fusion,m,mips-p8700,no-default-unroll,no-sink-splat-operands,no-trailing-seq-cst-fence,optimized-nf2-segment-load-store,optimized-nf3-segment-load-store,optimized-nf4-segment-load-store,optimized-nf5-segment-load-store,optimized-nf6-segment-load-store,optimized-nf7-segment-load-store,optimized-nf8-segment-load-store,optimized-zero-stride-load,predictable-select-expensive,prefer-vsetvli-over-read-vlenb,prefer-w-inst,q,relax,reserve-x1,reserve-x10,reserve-x11,reserve-x12,reserve-x13,reserve-x14,reserve-x15,reserve-x16,reserve-x17,reserve-x18,reserve-x19,reserve-x2,reserve-x20,reserve-x21,reserve-x22,reserve-x23,reserve-x24,reserve-x25,reserve-x26,reserve-x27,reserve-x28,reserve-x29,reserve-x3,reserve-x30,reserve-x31,reserve-x4,reserve-x5,reserve-x6,reserve-x7,reserve-x8,reserve-x9,rva20s64,rva20u64,rva22s64,rva22u64,rva23s64,rva23u64,rvb23s64,rvb23u64,rvi20u32,rvi20u64,save-restore,sdext,sdtrig,sha,shcounterenw,shgatpa,shifted-zextw-fusion,shlcofideleg,short-forward-branch-opt,shtvala,shvsatpa,shvstvala,shvstvecd,sifive7,smaia,smcdeleg,smcntrpmf,smcsrind,smdbltrp,smepmp,smmpm,smnpm,smrnmi,smstateen,ssaia,ssccfg,ssccptr,sscofpmf,sscounterenw,sscsrind,ssdbltrp,ssnpm,sspm,ssqosid,ssstateen,ssstrict,sstc,sstvala,sstvecd,ssu64xl,supm,svade,svadu,svbare,svinval,svnapot,svpbmt,svvptc,tagged-globals,unaligned-scalar-mem,unaligned-vector-mem,use-postra-scheduler,v,ventana-veyron,vl-dependent-latency,vxrm-pipeline-flush,xandesbfhcvt,xandesperf,xandesvbfhcvt,xandesvdot,xandesvpackfph,xandesvsintload,xcvalu,xcvbi,xcvbitmanip,xcvelw,xcvmac,xcvmem,xcvsimd,xmipscbop,xmipscmov,xmipslsp,xsfcease,xsfmm128t,xsfmm16t,xsfmm32a16f,xsfmm32a32f,xsfmm32a8f,xsfmm32a8i,xsfmm32t,xsfmm64a64f,xsfmm64t,xsfmmbase,xsfvcp,xsfvfnrclipxfqf,xsfvfwmaccqqq,xsfvqmaccdod,xsfvqmaccqoq,xsifivecdiscarddlone,xsifivecflushdlone,xtheadba,xtheadbb,xtheadbs,xtheadcmo,xtheadcondmov,xtheadfmemidx,xtheadmac,xtheadmemidx,xtheadmempair,xtheadsync,xtheadvdot,xventanacondops,xwchc,za128rs,za64rs,zaamo,zabha,zacas,zalrsc,zama16b,zawrs,zba,zbb,zbc,zbkb,zbkc,zbkx,zbs,zca,zcb,zcd,zce,zcf,zclsd,zcmop,zcmp,zcmt,zdinx,zexth-fusion,zextw-fusion,zfa,zfbfmin,zfh,zfhmin,zfinx,zhinx,zhinxmin,zic64b,zicbom,zicbop,zicboz,ziccamoa,ziccamoc,ziccif,zicclsm,ziccrse,zicntr,zicond,zicsr,zifencei,zihintntl,zihintpause,zihpm,zilsd,zimop,zk,zkn,zknd,zkne,zknh,zkr,zks,zksed,zksh,zkt,zmmul,ztso,zvbb,zvbc,zve32f,zve32x,zve64d,zve64f,zve64x,zvfbfmin,zvfbfwma,zvfh,zvfhmin,zvkb,zvkg,zvkn,zvknc,zvkned,zvkng,zvknha,zvknhb,zvks,zvksc,zvksed,zvksg,zvksh,zvkt,zvl1024b,zvl128b,zvl16384b,zvl2048b,zvl256b,zvl32768b,zvl32b,zvl4096b,zvl512b,zvl64b,zvl65536b,zvl8192b"),
+	str_lit("32bit,64bit,a,add-mem-fusion,add-or-sub-andi-fusion,addi-mem-fusion,andes45,andi-add-fusion,andi-sub-fusion,auipc-addi-fusion,b,branch-fusion,c,conditional-cmv-fusion,d,disable-latency-sched-heuristic,dlen-factor-2,e,exact-asm,experimental,experimental-p,experimental-rvm23u32,experimental-smctr,experimental-ssctr,experimental-svukte,experimental-xqccmp,experimental-xqcia,experimental-xqciac,experimental-xqcibi,experimental-xqcibm,experimental-xqcicli,experimental-xqcicm,experimental-xqcics,experimental-xqcicsr,experimental-xqciint,experimental-xqciio,experimental-xqcilb,experimental-xqcili,experimental-xqcilia,experimental-xqcilo,experimental-xqcilsm,experimental-xqcisim,experimental-xqcisls,experimental-xqcisync,experimental-xrivosvisni,experimental-xrivosvizip,experimental-xsfmclic,experimental-xsfsclic,experimental-zalasr,experimental-zicfilp,experimental-zicfiss,experimental-zvbc32e,experimental-zvkgs,experimental-zvqdotq,f,fcvt-fmul-or-fmuladd-fusion,forced-atomics,h,i,ld-add-fusion,log-vrgather,logic-imm-imm-fusion,logic-imm-reg-fusion,logic-reg-imm-fusion,logic-reg-reg-fusion,lui-addi-fusion,lui-mem-fusion,m,mips-p8700,mul-add-fusion,mulw-addw-fusion,no-default-unroll,no-sink-splat-operands,no-trailing-seq-cst-fence,optimized-nf2-segment-load-store,optimized-nf3-segment-load-store,optimized-nf4-segment-load-store,optimized-nf5-segment-load-store,optimized-nf6-segment-load-store,optimized-nf7-segment-load-store,optimized-nf8-segment-load-store,optimized-zero-stride-load,predictable-select-expensive,prefer-vsetvli-over-read-vlenb,prefer-w-inst,q,relax,reserve-x1,reserve-x10,reserve-x11,reserve-x12,reserve-x13,reserve-x14,reserve-x15,reserve-x16,reserve-x17,reserve-x18,reserve-x19,reserve-x2,reserve-x20,reserve-x21,reserve-x22,reserve-x23,reserve-x24,reserve-x25,reserve-x26,reserve-x27,reserve-x28,reserve-x29,reserve-x3,reserve-x30,reserve-x31,reserve-x4,reserve-x5,reserve-x6,reserve-x7,reserve-x8,reserve-x9,rva20s64,rva20u64,rva22s64,rva22u64,rva23s64,rva23u64,rvb23s64,rvb23u64,rvi20u32,rvi20u64,save-restore,sdext,sdtrig,sh1adduw-lh-fusion,sha,shcounterenw,shgatpa,shift-imm-op-fusion,shifted-zextw-fusion,shlcofideleg,short-forward-branch-opt,shtvala,shvsatpa,shvstvala,shvstvecd,sifive7,smaia,smcdeleg,smcntrpmf,smcsrind,smdbltrp,smepmp,smmpm,smnpm,smrnmi,smstateen,ssaia,ssccfg,ssccptr,sscofpmf,sscounterenw,sscsrind,ssdbltrp,ssnpm,sspm,ssqosid,ssstateen,ssstrict,sstc,sstvala,sstvecd,ssu64xl,sub-sltiu-fusion,sub-sltu-fusion,supm,svade,svadu,svbare,svinval,svnapot,svpbmt,svvptc,tagged-globals,unaligned-scalar-mem,unaligned-vector-mem,use-postra-scheduler,v,ventana-veyron,vl-dependent-latency,vxrm-pipeline-flush,xandesbfhcvt,xandesperf,xandesvbfhcvt,xandesvdot,xandesvpackfph,xandesvsintload,xcvalu,xcvbi,xcvbitmanip,xcvelw,xcvmac,xcvmem,xcvsimd,xmipscbop,xmipscmov,xmipslsp,xsfcease,xsfmm128t,xsfmm16t,xsfmm32a16f,xsfmm32a32f,xsfmm32a8f,xsfmm32a8i,xsfmm32t,xsfmm64a64f,xsfmm64t,xsfmmbase,xsfvcp,xsfvfnrclipxfqf,xsfvfwmaccqqq,xsfvqmaccdod,xsfvqmaccqoq,xsifivecdiscarddlone,xsifivecflushdlone,xsmtvdot,xsmtvdotii,xtheadba,xtheadbb,xtheadbs,xtheadcmo,xtheadcondmov,xtheadfmemidx,xtheadmac,xtheadmemidx,xtheadmempair,xtheadsync,xtheadvdot,xventanacondops,xwchc,za128rs,za64rs,zaamo,zabha,zacas,zalrsc,zama16b,zawrs,zba,zbb,zbc,zbkb,zbkc,zbkx,zbs,zca,zcb,zcd,zce,zcf,zclsd,zcmop,zcmp,zcmt,zdinx,zexth-fusion,zextw-fusion,zfa,zfbfmin,zfh,zfhmin,zfinx,zhinx,zhinxmin,zic64b,zicbom,zicbop,zicboz,ziccamoa,ziccamoc,ziccif,zicclsm,ziccrse,zicntr,zicond,zicsr,zifencei,zihintntl,zihintpause,zihpm,zilsd,zimop,zk,zkn,zknd,zkne,zknh,zkr,zks,zksed,zksh,zkt,zmmul,ztso,zvbb,zvbc,zve32f,zve32x,zve64d,zve64f,zve64x,zvfbfmin,zvfbfwma,zvfh,zvfhmin,zvkb,zvkg,zvkn,zvknc,zvkned,zvkng,zvknha,zvknhb,zvks,zvksc,zvksed,zvksg,zvksh,zvkt,zvl1024b,zvl128b,zvl16384b,zvl2048b,zvl256b,zvl32768b,zvl32b,zvl4096b,zvl512b,zvl64b,zvl65536b,zvl8192b"),
 };
 
 // Generated with the featuregen script in `misc/featuregen`
@@ -648,7 +650,7 @@ gb_global int target_microarch_counts[TargetArch_COUNT] = {
 	// TargetArch_wasm64p32:
 	4,
 	// TargetArch_riscv64:
-	51,
+	53,
 };
 
 // Generated with the featuregen script in `misc/featuregen`
@@ -1149,6 +1151,8 @@ gb_global MicroarchFeatureList microarch_features_list[] = {
 	{ str_lit("sifive-u74"), str_lit("64bit,a,c,d,f,i,m,no-default-unroll,short-forward-branch-opt,sifive7,use-postra-scheduler,zaamo,zalrsc,zca,zicsr,zifencei,zmmul") },
 	{ str_lit("sifive-x280"), str_lit("64bit,a,c,d,dlen-factor-2,f,i,m,no-default-unroll,optimized-nf2-segment-load-store,optimized-zero-stride-load,short-forward-branch-opt,sifive7,use-postra-scheduler,v,vl-dependent-latency,zaamo,zalrsc,zba,zbb,zca,zfh,zfhmin,zicsr,zifencei,zmmul,zve32f,zve32x,zve64d,zve64f,zve64x,zvfh,zvfhmin,zvl128b,zvl256b,zvl32b,zvl512b,zvl64b") },
 	{ str_lit("sifive-x390"), str_lit("64bit,a,b,c,d,dlen-factor-2,experimental-zicfilp,experimental-zicfiss,f,i,m,no-default-unroll,optimized-nf2-segment-load-store,optimized-zero-stride-load,short-forward-branch-opt,sifive7,use-postra-scheduler,v,vl-dependent-latency,xsifivecdiscarddlone,xsifivecflushdlone,za64rs,zaamo,zalrsc,zawrs,zba,zbb,zbs,zca,zcb,zcmop,zfa,zfbfmin,zfh,zfhmin,zic64b,zicbom,zicbop,zicboz,ziccamoa,ziccif,ziccrse,zicntr,zicond,zicsr,zifencei,zihintntl,zihintpause,zihpm,zimop,zkr,zkt,zmmul,zvbb,zve32f,zve32x,zve64d,zve64f,zve64x,zvfbfmin,zvfbfwma,zvfh,zvfhmin,zvkb,zvkt,zvl1024b,zvl128b,zvl256b,zvl32b,zvl512b,zvl64b") },
+	{ str_lit("spacemit-a100"), str_lit("64bit,a,add-or-sub-andi-fusion,addi-mem-fusion,andi-add-fusion,andi-sub-fusion,auipc-addi-fusion,b,branch-fusion,c,d,dlen-factor-2,f,fcvt-fmul-or-fmuladd-fusion,h,i,logic-imm-imm-fusion,logic-imm-reg-fusion,logic-reg-imm-fusion,logic-reg-reg-fusion,lui-addi-fusion,lui-mem-fusion,m,no-default-unroll,optimized-nf2-segment-load-store,optimized-nf3-segment-load-store,optimized-nf4-segment-load-store,prefer-w-inst,sh1adduw-lh-fusion,sha,shcounterenw,shgatpa,shtvala,shvsatpa,shvstvala,shvstvecd,smepmp,smnpm,smstateen,ssccptr,sscofpmf,sscounterenw,ssnpm,sspm,ssstateen,sstc,sstvala,sstvecd,ssu64xl,sub-sltiu-fusion,sub-sltu-fusion,supm,svade,svbare,svinval,svnapot,svpbmt,use-postra-scheduler,v,vxrm-pipeline-flush,xsmtvdotii,za64rs,zaamo,zalrsc,zawrs,zba,zbb,zbc,zbkc,zbs,zca,zcb,zcd,zcmop,zfa,zfbfmin,zfh,zfhmin,zic64b,zicbom,zicbop,zicboz,ziccamoa,ziccif,zicclsm,ziccrse,zicntr,zicond,zicsr,zifencei,zihintntl,zihintpause,zihpm,zimop,zkt,zmmul,zvbb,zvbc,zve32f,zve32x,zve64d,zve64f,zve64x,zvfbfmin,zvfbfwma,zvfh,zvfhmin,zvkb,zvkg,zvkn,zvkned,zvkng,zvknha,zvknhb,zvks,zvksc,zvksed,zvksg,zvksh,zvkt,zvl1024b,zvl128b,zvl256b,zvl32b,zvl512b,zvl64b") },
+        { str_lit("spacemit-x100"), str_lit("64bit,a,add-mem-fusion,b,c,d,dlen-factor-2,f,h,i,logic-imm-reg-fusion,logic-reg-imm-fusion,logic-reg-reg-fusion,lui-addi-fusion,m,mul-add-fusion,mulw-addw-fusion,no-default-unroll,optimized-nf2-segment-load-store,optimized-nf3-segment-load-store,optimized-nf4-segment-load-store,sha,shcounterenw,shgatpa,shift-imm-op-fusion,shtvala,shvsatpa,shvstvala,shvstvecd,smepmp,smnpm,smstateen,ssccptr,sscofpmf,sscounterenw,ssnpm,sspm,ssstateen,sstc,sstvala,sstvecd,ssu64xl,supm,svade,svbare,svinval,svnapot,svpbmt,use-postra-scheduler,v,vxrm-pipeline-flush,xsmtvdot,za64rs,zaamo,zalrsc,zawrs,zba,zbb,zbc,zbkc,zbs,zca,zcb,zcd,zcmop,zfa,zfbfmin,zfh,zfhmin,zic64b,zicbom,zicbop,zicboz,ziccamoa,ziccif,zicclsm,ziccrse,zicntr,zicond,zicsr,zifencei,zihintntl,zihintpause,zihpm,zimop,zkt,zmmul,zvbb,zvbc,zve32f,zve32x,zve64d,zve64f,zve64x,zvfbfmin,zvfbfwma,zvfh,zvfhmin,zvkb,zvkg,zvkn,zvkned,zvkng,zvknha,zvknhb,zvks,zvksc,zvksed,zvksg,zvksh,zvkt,zvl128b,zvl256b,zvl32b,zvl64b") },
 	{ str_lit("spacemit-x60"), str_lit("64bit,a,b,c,d,dlen-factor-2,f,i,m,optimized-nf2-segment-load-store,optimized-nf3-segment-load-store,optimized-nf4-segment-load-store,ssccptr,sscofpmf,sscounterenw,sstc,sstvala,sstvecd,svade,svbare,svinval,svnapot,svpbmt,unaligned-scalar-mem,v,vxrm-pipeline-flush,za64rs,zaamo,zalrsc,zba,zbb,zbc,zbkc,zbs,zca,zfh,zfhmin,zic64b,zicbom,zicbop,zicboz,ziccamoa,ziccif,zicclsm,ziccrse,zicntr,zicond,zicsr,zifencei,zihintpause,zihpm,zkt,zmmul,zve32f,zve32x,zve64d,zve64f,zve64x,zvfh,zvfhmin,zvkt,zvl128b,zvl256b,zvl32b,zvl64b") },
 	{ str_lit("syntacore-scr1-base"), str_lit("32bit,c,i,no-default-unroll,zca,zicsr,zifencei") },
 	{ str_lit("syntacore-scr1-max"), str_lit("32bit,c,i,m,no-default-unroll,zca,zicsr,zifencei,zmmul") },
diff --git a/src/check_builtin.cpp b/src/check_builtin.cpp
index e87c75e88..5dd4cf290 100644
--- a/src/check_builtin.cpp
+++ b/src/check_builtin.cpp
@@ -2447,7 +2447,7 @@ gb_internal bool check_builtin_procedure_directive(CheckerContext *c, Operand *o
 			} else {
 				Operand o = {};
 				Entity *e = check_ident(c, &o, arg, nullptr, nullptr, true);
-				if (e == nullptr || (e->flags & EntityFlag_Param) == 0) {
+				if (e == nullptr || (e->kind != Entity_Procedure && (e->flags & EntityFlag_Param) == 0)) {
 					error(arg, "'#caller_expression' expected a valid earlier parameter name");
 				}
 				arg->Ident.entity = e;
@@ -5282,6 +5282,62 @@ gb_internal bool check_builtin_procedure(CheckerContext *c, Operand *operand, As
 		break;
 	}
 
+	case BuiltinProc_soa_copy_from_slice: {
+		Operand array_ptr = {};
+		Operand offset    = {};
+		Operand args      = {};
+		check_expr(c, &array_ptr, ce->args[0]);
+		if (array_ptr.mode == Addressing_Invalid) {
+			return false;
+		}
+		if (!is_type_pointer(array_ptr.type)) {
+			gbString s = type_to_string(array_ptr.type);
+			error(array_ptr.expr, "Expected a pointer to a #soa dynamic array, got %s", s);
+			gb_string_free(s);
+			return false;
+		}
+		Type *array_type = type_deref(array_ptr.type);
+		if (!is_type_soa_dynamic_array(array_type)) {
+			gbString s = type_to_string(array_ptr.type);
+			error(array_ptr.expr, "Expected a pointer to a #soa dynamic array, got %s", s);
+			gb_string_free(s);
+			return false;
+		}
+		Type *at = base_type(array_type);
+		GB_ASSERT(at->kind == Type_Struct);
+		Type *elem = at->Struct.soa_elem;
+
+		check_expr_with_type_hint(c, &offset, ce->args[1], t_int);
+		if (offset.mode == Addressing_Invalid) {
+			return false;
+		}
+		if (!is_type_integer(offset.type)) {
+			gbString s = type_to_string(array_ptr.type);
+			error(array_ptr.expr, "Expected an integer as the offset for '%.*s', got %s", s, LIT(builtin_name));
+			gb_string_free(s);
+			return false;
+		}
+
+		Type *slice_hint = alloc_type_slice(elem);
+
+		check_expr_with_type_hint(c, &args, ce->args[2], slice_hint);
+		if (args.mode == Addressing_Invalid) {
+			return false;
+		}
+		if (!are_types_identical(base_type(args.type), slice_hint)) {
+			gbString s = type_to_string(slice_hint);
+			gbString t = type_to_string(args.type);
+			error(array_ptr.expr, "Expected a %s to use as the slice '%.*s', got %s", s, LIT(builtin_name), t);
+			gb_string_free(t);
+			gb_string_free(s);
+			return false;
+		}
+
+		operand->mode = Addressing_NoValue;
+		operand->type = nullptr;
+		break;
+	}
+
 	case BuiltinProc_concatenate: {
 		Operand lhs = {};
 
diff --git a/src/check_expr.cpp b/src/check_expr.cpp
index 81dee46bb..48372f701 100644
--- a/src/check_expr.cpp
+++ b/src/check_expr.cpp
@@ -1311,9 +1311,13 @@ gb_internal void check_assignment(CheckerContext *c, Operand *operand, Type *typ
 				if (context_name == "procedure argument") {
 					if (is_type_slice(src) && are_types_identical(src->Slice.elem, dst)) {
 						gbString a = expr_to_string(operand->expr);
-						error_line("\tSuggestion: Did you mean to pass the slice into the variadic parameter with ..%s?\n\n", a);
+						error_line("\tSuggestion: Did you mean to pass the slice into the variadic parameter with ..%s?\n", a);
 						gb_string_free(a);
 					}
+				} else if (context_name == "bit_set 'in'") {
+					if (is_type_bit_set(operand->type)) {
+						error_line("\tSuggestion: Prefer <= if you want a superset\n");
+					}
 				}
 				if (src->kind == dst->kind && src->kind == Type_Proc) {
 					Type *x = src;
@@ -4425,7 +4429,12 @@ gb_internal void check_binary_expr(CheckerContext *c, Operand *x, Ast *node, Typ
 
 		if (is_type_bit_set(rhs_type)) {
 			Type *elem = base_type(rhs_type)->BitSet.elem;
-			check_expr_with_type_hint(c, x, be->left, elem);
+			Type *type_hint = elem;
+			Ast *left = unparen_expr(be->left);
+			if (left != nullptr && left->kind == Ast_CompoundLit) {
+				type_hint = rhs_type;
+			}
+			check_expr_with_type_hint(c, x, left, type_hint);
 		} else if (is_type_map(rhs_type)) {
 			Type *key = base_type(rhs_type)->Map.key;
 			check_expr_with_type_hint(c, x, be->left, key);
diff --git a/src/checker_builtin_procs.hpp b/src/checker_builtin_procs.hpp
index e492ca7b2..457591615 100644
--- a/src/checker_builtin_procs.hpp
+++ b/src/checker_builtin_procs.hpp
@@ -60,6 +60,7 @@ enum BuiltinProcId {
 	BuiltinProc_matrix_flatten,
 	
 	BuiltinProc_soa_struct,
+	BuiltinProc_soa_copy_from_slice,
 
 	BuiltinProc_concatenate,
 
@@ -99,12 +100,12 @@ enum BuiltinProcId {
 
 	BuiltinProc_volatile_store,
 	BuiltinProc_volatile_load,
-	
+
 	BuiltinProc_unaligned_store,
 	BuiltinProc_unaligned_load,
 	BuiltinProc_non_temporal_store,
 	BuiltinProc_non_temporal_load,
-	
+
 	BuiltinProc_prefetch_read_instruction,
 	BuiltinProc_prefetch_read_data,
 	BuiltinProc_prefetch_write_instruction,
@@ -242,7 +243,7 @@ BuiltinProc__simd_begin,
 	// Platform specific SIMD intrinsics
 	BuiltinProc_simd_x86__MM_SHUFFLE,
 BuiltinProc__simd_end,
-	
+
 	// Platform specific intrinsics
 	BuiltinProc_syscall,
 	BuiltinProc_syscall_bsd,
@@ -328,7 +329,7 @@ BuiltinProc__type_simple_boolean_end,
 
 	BuiltinProc_type_has_field,
 	BuiltinProc_type_field_type,
-	
+
 	BuiltinProc_type_field_bit_offset,
 	BuiltinProc_type_field_bit_size,
 
@@ -467,8 +468,9 @@ gb_global BuiltinProc builtin_procs[BuiltinProc_COUNT] = {
 	{STR_LIT("outer_product"),    2, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 	{STR_LIT("hadamard_product"), 2, false, Expr_Expr, BuiltinProcPkg_intrinsics},
 	{STR_LIT("matrix_flatten"),   1, false, Expr_Expr, BuiltinProcPkg_intrinsics},
-		
+
 	{STR_LIT("soa_struct"),  2, false, Expr_Expr, BuiltinProcPkg_intrinsics}, // Type
+	{STR_LIT("soa_copy_from_slice"), 3, false, Expr_Stmt, BuiltinProcPkg_intrinsics},
 
 	{STR_LIT("concatenate"), 2, true, Expr_Expr, BuiltinProcPkg_intrinsics},
 
diff --git a/src/common.cpp b/src/common.cpp
index 89964309b..76ace2755 100644
--- a/src/common.cpp
+++ b/src/common.cpp
@@ -640,7 +640,7 @@ gb_internal gb_inline f64 gb_sqrt(f64 x) {
 
 #if defined(GB_SYSTEM_WINDOWS)
 
-gb_internal wchar_t **command_line_to_wargv(wchar_t *cmd_line, int *_argc) {
+gb_internal wchar_t **command_line_to_wargv(wchar_t *cmd_line, int *_argc, isize *_double_dash_pos, wchar_t **_after_double_dash_raw) {
 	u32 i, j;
 
 	u32 len = cast(u32)string16_len(cast(u16 *)cmd_line);
@@ -649,6 +649,9 @@ gb_internal wchar_t **command_line_to_wargv(wchar_t *cmd_line, int *_argc) {
 	wchar_t **argv = cast(wchar_t **)GlobalAlloc(GMEM_FIXED, i + (len+2)*gb_size_of(wchar_t));
 	wchar_t *_argv = cast(wchar_t *)((cast(u8 *)argv)+i);
 
+	wchar_t *after_double_dash_raw = nullptr;
+	isize double_dash_pos = -1;
+
 	u32 argc = 0;
 	argv[argc] = _argv;
 	bool in_quote = false;
@@ -657,6 +660,18 @@ gb_internal wchar_t **command_line_to_wargv(wchar_t *cmd_line, int *_argc) {
 	i = 0;
 	j = 0;
 
+	auto const check_double_dash = [&]() {
+		if (double_dash_pos == -1 &&
+			argc >= 1 &&
+			argv[argc - 1][0] == '-' &&
+			argv[argc - 1][1] == '-' &&
+			argv[argc - 1][2] == '\0') {
+
+			double_dash_pos = argc - 1;
+			after_double_dash_raw = cmd_line + i;
+		}
+	};
+
 	for (;;) {
 		wchar_t a = cmd_line[i];
 		if (a == 0) {
@@ -673,7 +688,10 @@ gb_internal wchar_t **command_line_to_wargv(wchar_t *cmd_line, int *_argc) {
 			case '\"':
 				in_quote = true;
 				in_text = true;
-				if (in_space) argv[argc++] = _argv+j;
+				if (in_space) {
+					check_double_dash();
+					argv[argc++] = _argv + j;
+				}
 				in_space = false;
 				break;
 			case ' ':
@@ -686,7 +704,10 @@ gb_internal wchar_t **command_line_to_wargv(wchar_t *cmd_line, int *_argc) {
 				break;
 			default:
 				in_text = true;
-				if (in_space) argv[argc++] = _argv+j;
+				if (in_space) {
+					check_double_dash();
+					argv[argc++] = _argv + j;
+				}
 				_argv[j++] = a;
 				in_space = false;
 				break;
@@ -696,8 +717,11 @@ gb_internal wchar_t **command_line_to_wargv(wchar_t *cmd_line, int *_argc) {
 	}
 	_argv[j] = '\0';
 	argv[argc] = nullptr;
+	check_double_dash();
 
 	if (_argc) *_argc = argc;
+	if (_double_dash_pos) *_double_dash_pos = double_dash_pos;
+	if (_after_double_dash_raw) *_after_double_dash_raw = after_double_dash_raw;
 	return argv;
 }
 
diff --git a/src/llvm_backend_general.cpp b/src/llvm_backend_general.cpp
index d9a807d18..7af1c52be 100644
--- a/src/llvm_backend_general.cpp
+++ b/src/llvm_backend_general.cpp
@@ -330,6 +330,29 @@ gb_internal lbLoopData lb_loop_start(lbProcedure *p, isize count, Type *index_ty
 	return data;
 }
 
+gb_internal lbLoopData lb_loop_start_runtime(lbProcedure *p, lbValue count) {
+	lbLoopData data = {};
+
+	lbValue max = count;
+
+	data.idx_addr = lb_add_local_generated(p, count.type, true);
+
+	data.body = lb_create_block(p, "loop.body");
+	data.done = lb_create_block(p, "loop.done");
+	data.loop = lb_create_block(p, "loop.loop");
+
+	lb_emit_jump(p, data.loop);
+	lb_start_block(p, data.loop);
+
+	data.idx = lb_addr_load(p, data.idx_addr);
+
+	lbValue cond = lb_emit_comp(p, Token_Lt, data.idx, max);
+	lb_emit_if(p, cond, data.body, data.done);
+	lb_start_block(p, data.body);
+
+	return data;
+}
+
 gb_internal void lb_loop_end(lbProcedure *p, lbLoopData const &data) {
 	if (data.idx_addr.addr.value != nullptr) {
 		lb_emit_increment(p, data.idx_addr.addr);
diff --git a/src/llvm_backend_proc.cpp b/src/llvm_backend_proc.cpp
index 9f1b5dd3f..41352d490 100644
--- a/src/llvm_backend_proc.cpp
+++ b/src/llvm_backend_proc.cpp
@@ -278,13 +278,17 @@ gb_internal lbProcedure *lb_create_procedure(lbModule *m, Entity *entity, bool i
 
 	// NOTE(bill): offset==0 is the return value
 	isize offset = 1;
-	if (pt->Proc.return_by_pointer) {
+	lbFunctionType *ft = p->abi_function_type;
+	GB_ASSERT(ft != nullptr);
+	if (ft->ret.kind == lbArg_Indirect) {
+		// return by pointer prepends an sret param
 		offset = 2;
 	}
 
-	isize parameter_index = 0;
 	if (pt->Proc.param_count) {
 		TypeTuple *params = &pt->Proc.params->Tuple;
+		isize parameter_index = 0;   // 0-based position among the Odin proc params in the LLVM function signature
+		isize ft_args_index = 0;     // index into ft->args
 		for (isize i = 0; i < pt->Proc.param_count; i++) {
 			Entity *e = params->variables[i];
 			if (e->kind != Entity_Variable) {
@@ -295,6 +299,13 @@ gb_internal lbProcedure *lb_create_procedure(lbModule *m, Entity *entity, bool i
 				continue;
 			}
 
+			GB_ASSERT(ft_args_index < ft->args.count);
+			lbArgType *arg = &ft->args[ft_args_index++];
+			if (arg->kind == lbArg_Ignore) {
+				// these are not present in the LLVM function signature, don't advance parameter_index
+				continue;
+			}
+
 			if (e->flags&EntityFlag_NoAlias) {
 				lb_add_proc_attribute_at_index(p, offset+parameter_index, "noalias");
 			}
@@ -642,7 +653,8 @@ gb_internal void lb_begin_procedure_body(lbProcedure *p) {
 
 			bool is_odin_cc = is_calling_convention_odin(ft->calling_convention);
 
-			unsigned param_index = 0;
+			unsigned param_index = 0;      // index into ft->args and the source param position used for debug info
+			unsigned llvm_param_index = 0; // 0-based position among the Odin proc params in the LLVM function signature
 			for_array(i, params->variables) {
 				Entity *e = params->variables[i];
 				if (e->kind != Entity_Variable) {
@@ -656,6 +668,9 @@ gb_internal void lb_begin_procedure_body(lbProcedure *p) {
 
 				lbArgType *arg_type = &ft->args[param_index];
 				defer (param_index += 1);
+				// lbArg_Ignore params are not present in the LLVM function signature, 
+				// so they don't advance the LLVM signature position
+				defer (if (arg_type->kind != lbArg_Ignore) { llvm_param_index += 1; });
 
 				if (arg_type->kind == lbArg_Ignore) {
 					// Even though it is an ignored argument, it might still be referenced in the
@@ -665,7 +680,7 @@ gb_internal void lb_begin_procedure_body(lbProcedure *p) {
 				} else if (arg_type->kind == lbArg_Direct) {
 					if (e->token.string.len != 0 && !is_blank_ident(e->token.string)) {
 						LLVMTypeRef param_type = lb_type(p->module, e->type);
-						LLVMValueRef original_value = LLVMGetParam(p->value, param_offset+param_index);
+						LLVMValueRef original_value = LLVMGetParam(p->value, param_offset+llvm_param_index);
 						LLVMValueRef value = OdinLLVMBuildTransmute(p, original_value, param_type);
 
 						lbValue param = {};
@@ -692,7 +707,7 @@ gb_internal void lb_begin_procedure_body(lbProcedure *p) {
 						}
 
 						lbValue ptr = {};
-						ptr.value = LLVMGetParam(p->value, param_offset+param_index);
+						ptr.value = LLVMGetParam(p->value, param_offset+llvm_param_index);
 						ptr.type = alloc_type_pointer(e->type);
 
 						if (do_callee_copy) {
@@ -3355,6 +3370,95 @@ gb_internal lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValu
 
 	// "Intrinsics"
 
+	case BuiltinProc_soa_copy_from_slice:
+		{
+			lbValue ptr    = lb_build_expr(p, ce->args[0]);
+			lbValue offset = lb_build_expr(p, ce->args[1]);
+			lbValue args   = lb_build_expr(p, ce->args[2]);
+
+			Type *ptr_type = base_type(ptr.type);
+			Type *array_type = base_type(type_deref(ptr_type));
+			GB_ASSERT(is_type_soa_dynamic_array(array_type));
+
+			Type *elem = array_type->Struct.soa_elem;
+
+			i32 field_count = 0;
+			if (is_type_array(elem)) {
+				field_count = cast(i32)get_array_type_count(elem);
+			} else {
+				Type *bt = base_type(elem);
+				GB_ASSERT(bt->kind == Type_Struct);
+				field_count = cast(i32)bt->Struct.fields.count;
+			}
+			if (field_count == 0) {
+				return {};
+			}
+			GB_ASSERT(field_count >= 1);
+
+			Type *slice_type = base_type(args.type);
+			GB_ASSERT(slice_type->kind == Type_Slice);
+			GB_ASSERT(are_types_identical(slice_type->Slice.elem, elem));
+
+			lbValue arg_ptr = lb_slice_elem(p, args);
+			lbValue arg_len = lb_slice_len(p, args);
+
+			lbValue soa_array_len = lb_soa_struct_len(p, ptr);
+
+			offset = lb_emit_conv(p, offset, t_int);
+			lbValue max_soa_len = lb_emit_arith(p, Token_Sub, soa_array_len, offset, t_int);
+			lbValue max_len = lb_emit_min(p, t_int, arg_len, max_soa_len);
+
+			if (field_count <= 16) {
+				lbValue *ps = gb_alloc_array(temporary_allocator(), lbValue, field_count);
+				for (i32 field_index = 0; field_index < field_count; field_index++) {
+					ps[field_index] = lb_emit_load(p, lb_emit_struct_ep(p, ptr, field_index));
+				}
+
+				for (i32 field_index = 0; field_index < field_count; field_index++) {
+					auto loop_data = lb_loop_start_runtime(p, max_len);
+
+					lbValue j = loop_data.idx;
+					lbValue index = lb_emit_arith(p, Token_Add, j, offset, t_int);
+
+					lbValue dst = lb_emit_ptr_offset(p, ps[field_index], index);
+					// make sure it's ^T and not [^]T
+					dst.type = alloc_type_multi_pointer_to_pointer(dst.type);
+
+					lbValue src_ptr = lb_emit_ptr_offset(p, arg_ptr, j);
+					src_ptr = lb_emit_struct_ep(p, src_ptr, field_index);
+
+					lbValue src = lb_emit_load(p, src_ptr);
+					lb_emit_store(p, dst, src);
+
+					lb_loop_end(p, loop_data);
+				}
+			} else {
+				for (i32 field_index = 0; field_index < field_count; field_index++) {
+					Type *type = array_type->Struct.fields[field_index]->type;
+					GB_ASSERT(type->kind == Type_MultiPointer);
+					type = type->MultiPointer.elem;
+
+					lbValue dst = lb_emit_load(p, lb_emit_struct_ep(p, ptr, field_index));
+					dst = lb_emit_ptr_offset(p, dst, offset);
+					dst.type = alloc_type_multi_pointer_to_pointer(dst.type);
+
+					auto loop_data = lb_loop_start_runtime(p, max_len);
+
+					lbValue src = lb_emit_ptr_offset(p, arg_ptr, loop_data.idx);
+
+					lbValue d = lb_emit_ptr_offset(p, dst, loop_data.idx);
+					lbValue s = lb_emit_struct_ep(p, src, field_index);
+
+					GB_ASSERT(are_types_identical(d.type, s.type));
+
+					lb_mem_copy_non_overlapping(p, d, s, lb_const_int(p->module, t_int, type_size_of(type)), false);
+
+					lb_loop_end(p, loop_data);
+				}
+			}
+			return {};
+		}
+
 	case BuiltinProc_alloca:
 		{
 			lbValue sz = lb_build_expr(p, ce->args[0]);
@@ -3418,6 +3522,18 @@ gb_internal lbValue lb_build_builtin_proc(lbProcedure *p, Ast *expr, TypeAndValu
 				LLVMValueRef the_asm = llvm_get_inline_asm(func_type, str_lit("mrs $0, cntvct_el0"), str_lit("=r"), has_side_effects);
 				GB_ASSERT(the_asm != nullptr);
 				res.value = LLVMBuildCall2(p->builder, func_type, the_asm, nullptr, 0, "");
+			#if LLVM_VERSION_MAJOR > 19 || (LLVM_VERSION_MAJOR == 19 && LLVM_VERSION_MINOR >= 1)
+			} else if (build_context.metrics.arch == TargetArch_riscv64 && build_context.metrics.os == TargetOs_linux) {
+				// Linux in it's infinite wisdom decided that `rdcycle` should not be
+				// available to userland past Linux 6.6.  Some inline assembly with
+				// `rdtime` would also work, but LLVM issue #117701 suggests just
+				// using this intrinsic.
+				//
+				// Support for this was introduced in commit `b8ed69e`, and is present
+				// in LLVM tags 19.1.0-rc1.
+				char const *name = "llvm.readsteadycounter";
+				res.value = lb_call_intrinsic(p, name, nullptr, 0, nullptr, 0);
+			#endif
 			} else {
 				char const *name = "llvm.readcyclecounter";
 				res.value = lb_call_intrinsic(p, name, nullptr, 0, nullptr, 0);
diff --git a/src/llvm_backend_stmt.cpp b/src/llvm_backend_stmt.cpp
index 54447820a..1d42b497a 100644
--- a/src/llvm_backend_stmt.cpp
+++ b/src/llvm_backend_stmt.cpp
@@ -2201,7 +2201,9 @@ gb_internal void lb_build_type_switch_stmt(lbProcedure *p, AstTypeSwitchStmt *ss
 	LLVMValueRef switch_instr = nullptr;
 	if (type_size_of(parent_base_type) == 0) {
 		GB_ASSERT(tag.value == nullptr);
-		switch_instr = LLVMBuildSwitch(p->builder, lb_const_bool(p->module, t_llvm_bool, false).value, else_block->block, cast(unsigned)num_cases);
+		GB_ASSERT(switch_kind == TypeSwitch_Union); // zero size only possible for union{}
+		Type *ut = type_deref(parent.type);
+		switch_instr = LLVMBuildSwitch(p->builder, lb_const_int(m, union_tag_type(ut), 0).value, else_block->block, cast(unsigned)num_cases);
 	} else {
 		GB_ASSERT(tag.value != nullptr);
 		switch_instr = LLVMBuildSwitch(p->builder, tag.value, else_block->block, cast(unsigned)num_cases);
diff --git a/src/main.cpp b/src/main.cpp
index c4b4441d8..74900587f 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -178,17 +178,63 @@ gb_internal i32 system_exec_command_line_app(char const *name, char const *fmt,
 	return exit_code;
 }
 
-#if defined(GB_SYSTEM_WINDOWS)
-#include <process.h>
-#else
+#if !defined(GB_SYSTEM_WINDOWS)
 #include <spawn.h>
 extern char **environ;
 #endif
 
-int run_subprocess(const char *name, const char **args) {
 #if defined(GB_SYSTEM_WINDOWS)
-	return (int)_spawnv(_P_WAIT, name, args);
+int run_subprocess(String const &exe_name, wchar_t *after_double_dash_raw) {
+	gbAllocator a = heap_allocator();
+
+	String16 wexe_name = string_to_string16(a, exe_name);
+	defer (gb_free(a, wexe_name.text));
+
+	isize args_len = 0;
+	if (after_double_dash_raw) {
+		args_len = string16_len(cast(u16 *)after_double_dash_raw);
+	}
+
+	isize cmd_len = wexe_name.len + 2;
+	if (args_len > 0) cmd_len += args_len + 1;
+
+	wchar_t *cmd_line = gb_alloc_array(a, wchar_t, cmd_len + 1);
+	defer (gb_free(a, cmd_line));
+
+	isize n = 0;
+	cmd_line[n++] = '"';
+	gb_memmove(cmd_line + n, wexe_name.text, wexe_name.len * gb_size_of(wchar_t));
+	n += wexe_name.len;
+	cmd_line[n++] = '"';
+	if (args_len > 0) {
+		cmd_line[n++] = ' ';
+		gb_memmove(cmd_line + n, after_double_dash_raw, args_len * gb_size_of(wchar_t));
+		n += args_len;
+	}
+	cmd_line[n] = '\0';
+
+	STARTUPINFOW start_info = {gb_size_of(STARTUPINFOW)};
+	PROCESS_INFORMATION pi = {0};
+	int exit_code = 0;
+
+	if (CreateProcessW(nullptr, cmd_line,
+	                   nullptr, nullptr, true, 0, nullptr, nullptr,
+	                   &start_info, &pi)) {
+		WaitForSingleObject(pi.hProcess, INFINITE);
+		GetExitCodeProcess(pi.hProcess, cast(DWORD *)&exit_code);
+
+		CloseHandle(pi.hProcess);
+		CloseHandle(pi.hThread);
+	} else {
+		String cmd_line_utf8 = string16_to_string(a, make_string16(cast(u16 *)cmd_line, n));
+		gb_printf_err("Failed to execute command:\n\t%.*s\n", LIT(cmd_line_utf8));
+		gb_free(a, cmd_line_utf8.text);
+		exit_code = -1;
+	}
+	return exit_code;
+}
 #else
+int run_subprocess(const char *name, const char **args) {
 	pid_t pid;
 	int status;
 	status = posix_spawn(&pid, name, NULL, NULL, (char *const *)args, environ);
@@ -215,8 +261,8 @@ int run_subprocess(const char *name, const char **args) {
 		}
 	}
 	GB_PANIC("Subprocess failure");
-#endif
 }
+#endif
 
 #if defined(GB_SYSTEM_WINDOWS)
 #define popen _popen
@@ -250,12 +296,12 @@ gb_internal bool system_exec_command_line_app_output(char const *command, gbStri
 	return true;
 }
 
-gb_internal Array<String> setup_args(int argc, char const **argv) {
+gb_internal Array<String> setup_args(int argc, char const **argv, isize *double_dash_pos, wchar_t **after_double_dash_raw) {
 	gbAllocator a = heap_allocator();
 
 #if defined(GB_SYSTEM_WINDOWS)
 	int wargc = 0;
-	wchar_t **wargv = command_line_to_wargv(GetCommandLineW(), &wargc);
+	wchar_t **wargv = command_line_to_wargv(GetCommandLineW(), &wargc, double_dash_pos, after_double_dash_raw);
 	auto args = array_make<String>(a, 0, wargc);
 	for (isize i = 0; i < wargc; i++) {
 		u16 *warg = cast(u16 *)wargv[i];
@@ -264,6 +310,8 @@ gb_internal Array<String> setup_args(int argc, char const **argv) {
 		String arg = string16_to_string(a, wstr);
 		if (arg.len > 0) {
 			array_add(&args, arg);
+		} else if (double_dash_pos && *double_dash_pos > 0 && args.count < *double_dash_pos) {
+			*double_dash_pos -= 1;
 		}
 	}
 	return args;
@@ -489,6 +537,27 @@ gb_internal void add_flag(Array<BuildFlag> *build_flags, BuildFlagKind kind, Str
 	array_add(build_flags, flag);
 }
 
+// A value such as `1e-5` is a float, not an integer. Base prefixed literals are excluded because
+// `e` is a valid digit in bases 16 and above, e.g. `0x1e`.
+gb_internal bool build_param_looks_like_float(String const &param) {
+	if (string_contains_char(param, '.')) {
+		return true;
+	}
+	isize i = 0;
+	if (param.len > 0 && (param[0] == '-' || param[0] == '+')) {
+		i = 1;
+	}
+	if (param.len > i+1 && param[i] == '0' && !gb_char_is_digit(cast(char)param[i+1])) {
+		return false;
+	}
+	for (; i < param.len; i++) {
+		if (param[i] == 'e' || param[i] == 'E') {
+			return true;
+		}
+	}
+	return false;
+}
+
 gb_internal ExactValue build_param_to_exact_value(String name, String param) {
 	ExactValue value = {};
 
@@ -514,7 +583,7 @@ gb_internal ExactValue build_param_to_exact_value(String name, String param) {
 		Try to parse as an integer or float
 	*/
 	if (param[0] == '-' || param[0] == '+' || gb_is_between(param[0], '0', '9')) {
-		if (string_contains_char(param, '.')) {
+		if (build_param_looks_like_float(param)) {
 			value = exact_value_float_from_string(param);
 		} else {
 			value = exact_value_integer_from_string(param);
@@ -3757,17 +3826,23 @@ int main(int arg_count, char const **arg_ptr) {
 	
 	init_build_context_error_pos_style();
 
-	Array<String> args = setup_args(arg_count, arg_ptr);
+	isize double_dash_pos = -1;
+	wchar_t *after_double_dash_raw = nullptr;
+	Array<String> args = setup_args(arg_count, arg_ptr, &double_dash_pos, &after_double_dash_raw);
+#if !defined(GB_SYSTEM_WINDOWS)
 	Array<String> run_args = array_make<String>(heap_allocator(), 0, arg_count);
 	defer (array_free(&run_args));
+#endif
 
 	String command = args[1];
 	String init_filename = {};
 	isize  last_non_run_arg = args.count;
 
-	isize double_dash_pos = -1;
 	for_array(i, args) {
 		if (args[i] == "--") {
+#if defined(GB_SYSTEM_WINDOWS)
+			GB_ASSERT(double_dash_pos == i);
+#endif
 			double_dash_pos = i;
 			break;
 		}
@@ -3811,25 +3886,20 @@ int main(int arg_count, char const **arg_ptr) {
 			build_context.command_kind = Command_test;
 		}
 
-		isize run_args_start_idx = -1;
-		for_array(i, args) {
-			if (args[i] == "--") {
-				run_args_start_idx = i;
-				break;
-			}
-		}
-		if (run_args_start_idx != -1) {
-			last_non_run_arg = run_args_start_idx;
+		if (double_dash_pos != -1) {
+			last_non_run_arg = double_dash_pos;
 
-			if (run_args_start_idx == 2) {
+			if (double_dash_pos == 2) {
 				// missing src path on argv[2], invocation: odin [run|test] --
 				usage(args[0]);
 				return 1;
 			}
 
-			for(isize i = run_args_start_idx+1; i < args.count; ++i) {
+#if !defined(GB_SYSTEM_WINDOWS)
+			for(isize i = double_dash_pos+1; i < args.count; ++i) {
 				array_add(&run_args, args[i]);
 			}
+#endif
 		}
 		args = array_slice(args, 0, last_non_run_arg);
 
@@ -4422,6 +4492,9 @@ end_of_code_gen:;
 		String exe_name = path_to_string(heap_allocator(), build_context.build_paths[BuildPath_Output]);
 		defer (gb_free(heap_allocator(), exe_name.text));
 
+#if defined(GB_SYSTEM_WINDOWS)
+		int subprocess_res = run_subprocess(exe_name, after_double_dash_raw);
+#else
 		const char* exe_name_cstring = alloc_cstring(heap_allocator(), exe_name);
 		Array<const char *> run_args_cstring = array_make<const char *>(heap_allocator(), 0, run_args.count);
 		defer({
@@ -4436,6 +4509,7 @@ end_of_code_gen:;
 		array_add(&run_args_cstring, NULL);
 
 		int subprocess_res = run_subprocess(exe_name_cstring, run_args_cstring.data);
+#endif
 		if (subprocess_res) {
 			gb_exit(subprocess_res);
 		}
diff --git a/src/parser.cpp b/src/parser.cpp
index 64112e085..a527bc7ec 100644
--- a/src/parser.cpp
+++ b/src/parser.cpp
@@ -6587,6 +6587,8 @@ gb_internal u64 parse_vet_tag(Token token_for_pos, String s, u64 base_vet_flags)
 			error_line("\tusing-param\n");
 			error_line("\tstyle\n");
 			error_line("\textra\n");
+			error_line("\tsemicolon\n");
+			error_line("\tdeprecated\n");
 			error_line("\tcast\n");
 			error_line("\ttabs\n");
 			error_line("\texplicit-allocators\n");
diff --git a/src/types.cpp b/src/types.cpp
index ff5147574..0e41b1b9b 100644
--- a/src/types.cpp
+++ b/src/types.cpp
@@ -2001,6 +2001,11 @@ gb_internal bool is_type_soa_struct(Type *t) {
 	if (t == nullptr) { return false; }
 	return t->kind == Type_Struct && t->Struct.soa_kind != StructSoa_None;
 }
+gb_internal bool is_type_soa_dynamic_array(Type *t) {
+	t = base_type(t);
+	if (t == nullptr) { return false; }
+	return t->kind == Type_Struct && t->Struct.soa_kind == StructSoa_Dynamic;
+}
 
 gb_internal bool is_type_raw_union(Type *t) {
 	t = base_type(t);
diff --git a/tests/core/normal.odin b/tests/core/normal.odin
index 1d0074918..99a30343c 100644
--- a/tests/core/normal.odin
+++ b/tests/core/normal.odin
@@ -53,6 +53,7 @@ download_assets :: proc "contextless" () {
 @(require) import "text/i18n"
 @(require) import "text/match"
 @(require) import "text/regex"
+@(require) import "text/scanner"
 @(require) import "thread"
 @(require) import "time"
 @(require) import "unicode"
\ No newline at end of file
diff --git a/tests/core/os/path.odin b/tests/core/os/path.odin
index 3a7611757..50ee6bc87 100644
--- a/tests/core/os/path.odin
+++ b/tests/core/os/path.odin
@@ -380,6 +380,13 @@ glob_tests := []Glob_Test{
 		},
 		err     = {},
 	},
+	{
+		pattern = ODIN_ROOT + "tests/core/os/path.odin",
+		matches = {
+			ODIN_ROOT + "tests/core/os/path.odin",
+		},
+		err     = {},
+	},
 }
 
 @(test)
diff --git a/tests/core/runtime/test_core_runtime.odin b/tests/core/runtime/test_core_runtime.odin
index f3559954d..5f2d852d7 100644
--- a/tests/core/runtime/test_core_runtime.odin
+++ b/tests/core/runtime/test_core_runtime.odin
@@ -425,3 +425,196 @@ test_memory_compare_zero :: proc(t: ^testing.T) {
 		}
 	}
 }
+
+// Runs identical append/inject/remove sequences for a #soa[dynamic] array
+// and an AoS [dynamic] reference, comparing all elements after each
+// stage. Covers appends, injections (interior, at the end, and past the
+// end where the gap must read as zero elements), unordered and ordered
+// removes.
+@(test)
+test_soa_array_append_inject_remove :: proc(t: ^testing.T) {
+	check :: proc(t: ^testing.T, $E: typeid, mk: proc(i: int) -> E) {
+		expect_same :: proc(t: ^testing.T, soa: #soa[dynamic]$T, model: [dynamic]T) {
+			testing.expect_value(t, len(soa), len(model))
+			for i in 0..<min(len(soa), len(model)) {
+				testing.expect_value(t, soa[i], model[i])
+			}
+		}
+
+		soa: #soa[dynamic]E
+		defer delete(soa)
+		ref: [dynamic]E
+		defer delete(ref)
+
+		// single appends
+		for i in 0..<10 {
+			n, err := append(&soa, mk(i))
+			testing.expect_value(t, n, 1)
+			testing.expect_value(t, err, nil)
+			append(&ref, mk(i))
+		}
+		expect_same(t, soa, ref)
+
+		// batch appends
+		buf: [32]E
+		for i in 0..<32 { buf[i] = mk(123 + i) }
+		BATCH_LEN :: 5
+		n, err := append(&soa, ..buf[:BATCH_LEN])
+		testing.expect_value(t, n, BATCH_LEN)
+		testing.expect_value(t, err, nil)
+		append(&ref, ..buf[:BATCH_LEN])
+		expect_same(t, soa, ref)
+
+		n, err = append(&soa, ..buf[:])
+		testing.expect_value(t, n, 32)
+		testing.expect_value(t, err, nil)
+		append(&ref, ..buf[:])
+		expect_same(t, soa, ref)
+
+		// single injections
+		ok: bool
+		ok, err = inject_at_soa(&soa, 0, mk(300))
+		testing.expect(t, ok)
+		testing.expect_value(t, err, nil)
+		inject_at(&ref, 0, mk(300))
+		expect_same(t, soa, ref)
+
+		ok, err = inject_at_soa(&soa, len(soa)/2, mk(301))
+		testing.expect(t, ok)
+		testing.expect_value(t, err, nil)
+		inject_at(&ref, len(ref)/2, mk(301))
+		expect_same(t, soa, ref)
+
+		// inject at the end
+		ok, err = inject_at_soa(&soa, len(soa), mk(302))
+		testing.expect(t, ok)
+		testing.expect_value(t, err, nil)
+		inject_at(&ref, len(ref), mk(302))
+		expect_same(t, soa, ref)
+
+		// batch injections
+		ok, err = inject_at_soa(&soa, 3, ..buf[:BATCH_LEN])
+		testing.expect(t, ok)
+		testing.expect_value(t, err, nil)
+		inject_at(&ref, 3, ..buf[:BATCH_LEN])
+		expect_same(t, soa, ref)
+
+		ok, err = inject_at_soa(&soa, len(soa), ..buf[:])
+		testing.expect(t, ok)
+		testing.expect_value(t, err, nil)
+		inject_at(&ref, len(ref), ..buf[:])
+		expect_same(t, soa, ref)
+
+		// injecting nothing is a no-op
+		ok, err = inject_at_soa(&soa, 4, ..buf[:0])
+		testing.expect(t, ok)
+		testing.expect_value(t, err, nil)
+		inject_at(&ref, 4, ..buf[:0])
+		expect_same(t, soa, ref)
+
+		// single injection past the end: the gap [len, index) reads as zero
+		// elements. Poison the spare capacity first (fresh heap pages are
+		// already zero, which would hide a missing gap zero), then shrink back.
+		for i in 0..<8 {
+			n, err = append(&soa, mk(900 + i))
+			testing.expect_value(t, n, 1)
+			testing.expect_value(t, err, nil)
+		}
+		testing.expect_value(t, resize_soa(&soa, len(soa) - 8), nil)
+		ok, err = inject_at_soa(&soa, len(soa) + 3, mk(500))
+		testing.expect(t, ok)
+		testing.expect_value(t, err, nil)
+		inject_at(&ref, len(ref) + 3, mk(500))
+		expect_same(t, soa, ref)
+
+		// batch injection past the end (its gap slots reuse the poison above)
+		ok, err = inject_at_soa(&soa, len(soa) + 2, ..buf[:BATCH_LEN])
+		testing.expect(t, ok)
+		testing.expect_value(t, err, nil)
+		inject_at(&ref, len(ref) + 2, ..buf[:BATCH_LEN])
+		expect_same(t, soa, ref)
+
+		// unordered removes
+		unordered_remove_soa(&soa, 20)
+		unordered_remove(&ref, 20)
+		unordered_remove_soa(&soa, 0)
+		unordered_remove(&ref, 0)
+		unordered_remove_soa(&soa, len(soa)-1)
+		unordered_remove(&ref, len(ref)-1)
+		expect_same(t, soa, ref)
+
+		// ordered removes
+		ordered_remove_soa(&soa, 17)
+		ordered_remove(&ref, 17)
+		ordered_remove_soa(&soa, 0)
+		ordered_remove(&ref, 0)
+		ordered_remove_soa(&soa, len(soa)-1)
+		ordered_remove(&ref, len(ref)-1)
+		expect_same(t, soa, ref)
+
+		// interleaved removes, appends and injections
+		for i in 0..<8 {
+			unordered_remove_soa(&soa, i)
+			unordered_remove(&ref, i)
+			n, err = append(&soa, mk(200 + i))
+			testing.expect_value(t, n, 1)
+			testing.expect_value(t, err, nil)
+			append(&ref, mk(200 + i))
+			ok, err = inject_at_soa(&soa, i, mk(400 + i))
+			testing.expect(t, ok)
+			testing.expect_value(t, err, nil)
+			inject_at(&ref, i, mk(400 + i))
+		}
+		expect_same(t, soa, ref)
+
+		// remove till empty, then reuse
+		for len(soa) > 0 {
+			unordered_remove_soa(&soa, 0)
+			unordered_remove(&ref, 0)
+		}
+		testing.expect_value(t, len(soa), 0)
+
+		// inject into an empty array
+		ok, err = inject_at_soa(&soa, 0, mk(998))
+		testing.expect(t, ok)
+		testing.expect_value(t, err, nil)
+		inject_at(&ref, 0, mk(998))
+		expect_same(t, soa, ref)
+
+		// non-zero append
+		n, err = non_zero_append(&soa, mk(42))
+		testing.expect_value(t, n, 1)
+		testing.expect_value(t, err, nil)
+		non_zero_append(&ref, mk(42))
+		expect_same(t, soa, ref)
+	}
+
+	// mixed field widths + padding
+	Padded :: struct { a: u8, b: u64, c: u16 }
+	check(t, Padded, proc(i: int) -> Padded { return {u8(i*3), u64(i)*257 + 7, u16(i*5 + 1)} })
+	// array element type
+	check(t, [4]u16, proc(i: int) -> [4]u16 { return {u16(i), u16(i + 1), u16(i*3), u16(i*7)} })
+	// eight fields at varying widths, no two neighbouring fields share a stride
+	Eight :: struct { a: u8, b: u16, c: u32, d: u64, e: i8, f: i16, g: f32, h: f64 }
+	check(t, Eight, proc(i: int) -> Eight {
+		return {
+			u8(i), u16(i*3 + 1), u32(i)*5 + 2, u64(i)*7 + 3,
+			i8(i >> 1), i16(i*11 + 4), f32(i)*1.5, f64(i)*2.25,
+		}
+	})
+	// #packed struct with > 16 fields, field offsets diverging from default
+	// layout (u8/u64 alternate, align_of == 1), and the field count takes
+	// the type-erased batch appends compile time branch.
+	Packed17 :: struct #packed {
+		f0: u8, f1: u64, f2: u8, f3: u64, f4: u8, f5: u64, f6: u8, f7: u64,
+		f8: u8, f9: u64, f10: u8, f11: u64, f12: u8, f13: u64, f14: u8, f15: u64,
+		f16: u8,
+	}
+	check(t, Packed17, proc(i: int) -> Packed17 {
+		return {
+			u8(i), u64(i)*3 + 1, u8(i >> 1), u64(i)*5 + 2, u8(i >> 2), u64(i)*7 + 3, u8(i >> 3), u64(i)*11 + 4,
+			u8(i >> 4), u64(i)*13 + 5, u8(i >> 5), u64(i)*17 + 6, u8(i >> 6), u64(i)*19 + 7, u8(i >> 7), u64(i)*23 + 8,
+			u8(i*3),
+		}
+	})
+}
diff --git a/tests/core/speed.odin b/tests/core/speed.odin
index 0da7c1b82..c043aefe7 100644
--- a/tests/core/speed.odin
+++ b/tests/core/speed.odin
@@ -5,4 +5,5 @@ package tests_core
 @(require) import "crypto/bigint"
 @(require) import "hash"
 @(require) import "image"
-@(require) import "math/big"
\ No newline at end of file
+@(require) import "math/big"
+@(require) import "runtime"
\ No newline at end of file
diff --git a/tests/core/text/scanner/test_core_text_scanner.odin b/tests/core/text/scanner/test_core_text_scanner.odin
new file mode 100644
index 000000000..592782095
--- /dev/null
+++ b/tests/core/text/scanner/test_core_text_scanner.odin
@@ -0,0 +1,212 @@
+package test_core_text_scanner
+
+import "base:runtime"
+import "core:fmt"
+import "core:testing"
+import "core:text/scanner"
+
+Test_Context :: struct {
+	t: ^testing.T,
+	expected_fail_locations: []int,
+	checking_errors: bool,
+	loc: runtime.Source_Code_Location,
+}
+
+string_of_token :: proc(token: rune) -> string {
+	switch token {
+	case scanner.EOF: return "EOF"
+	case scanner.Ident: return "Ident"
+	case scanner.Int: return "Int"
+	case scanner.Float: return "Float"
+	case scanner.Char: return "Char"
+	case scanner.String: return "String"
+	case scanner.Raw_String: return "Raw_String"
+	case scanner.Comment: return "Comment"
+	case: return fmt.tprintf("%c", token)
+	}
+}
+
+scanner_testing_error :: proc(s: ^scanner.Scanner, msg: string) {
+	tc := cast(^Test_Context)context.user_ptr
+	p := s.pos
+	if !scanner.position_is_valid(p) {
+		p = scanner.position(s)
+	}
+
+	if scanner.position_is_valid(p) {
+		testing.expectf(tc.t, false, "[core:text/scanner] `%s`(%d:%d): %s\n", p.filename, p.line, p.column, msg, loc=tc.loc)
+	} else {
+		testing.expectf(tc.t, false, "[core:text/scanner] `%s`: %s\n", p.filename, msg, loc=tc.loc)
+	}
+}
+
+check_expected_error :: proc(s: ^scanner.Scanner, msg: string) {
+	tc := cast(^Test_Context)context.user_ptr
+
+	p := s.pos
+	if !scanner.position_is_valid(p) {
+		p = scanner.position(s)
+	}
+
+	if !scanner.position_is_valid(p) {
+		testing.expectf(tc.t, false, "invalid scanner position for %s",
+			p.filename, loc=tc.loc)
+		return
+	}
+
+	if tc.checking_errors {
+		error_index :=  s.error_count-1 
+		expected_locations_number := len(tc.expected_fail_locations)
+		if expected_locations_number <= error_index {
+			testing.expectf(tc.t, expected_locations_number > error_index,
+				"more errors than expected: %s(%d:%d): %s",
+				p.filename, p.line, p.column, msg, loc=tc.loc)
+			return
+		}
+		expected_location := tc.expected_fail_locations[error_index]
+		testing.expectf(tc.t, p.offset == expected_location,
+			"incorrect location of error; expected %d, got %d; msg: %s(%d:%d): %s",
+			expected_location, p.offset, p.filename, p.line, p.column, msg, loc=tc.loc)
+	}
+}
+
+// Should be used separetly for the cases where `text` is correct and where
+// it is not. To select a mode set the `should_fail` parameter.
+test_scanner :: proc(
+	t: ^testing.T,
+	text: string,
+	flags := scanner.Odin_Like_Tokens,
+	expected_tokens := []rune{},
+	expected_words := []string{},
+	expected_fail_locations := []int{},
+	should_fail := false,
+	loc := #caller_location,
+) {
+	scratch := runtime.default_temp_allocator_temp_begin()
+	defer runtime.default_temp_allocator_temp_end(scratch)
+
+	tc: Test_Context
+	expected_token_number := -1
+
+	checking_tokens := len(expected_tokens) != 0
+	checking_words 	:= len(expected_words) != 0
+	checking_errors := len(expected_fail_locations) != 0
+
+	source_name: string
+	if text == "" || len(text) > 85 {
+		source_name = loc.procedure
+	} else {
+		source_name = text
+	}
+
+	if checking_tokens && checking_words {
+		testing.expectf(t, len(expected_tokens) == len(expected_words),
+			"`%s`: `expected_tokens` and `expected_words` should be of the same length",
+			source_name, loc=loc)
+	}
+	if checking_tokens {
+		expected_token_number = len(expected_tokens)
+	} else if checking_words {
+		expected_token_number = len(expected_words)
+	}
+
+	counting_tokens := expected_token_number != -1
+
+	tc.t = t
+	tc.expected_fail_locations = expected_fail_locations
+	tc.checking_errors = checking_errors
+	tc.loc = loc
+	context.user_ptr = &tc
+
+	if !should_fail {
+		assert(!checking_errors, "test_scanner does not accept non-empty `expected_fail_locations` with `should_fail = false`", loc)
+	}
+
+	s: scanner.Scanner
+	scanner.init(&s, text, source_name)
+	s.flags = flags
+	s.error = scanner_testing_error
+
+	if !should_fail {
+		s.error = scanner_testing_error
+	} else {
+		s.error = check_expected_error
+	}
+
+	token_counter := 0
+	for token := scanner.scan(&s); token != scanner.EOF; token = scanner.scan(&s) {
+		
+		if counting_tokens {
+			if ok := token_counter < expected_token_number; !ok {
+				testing.expectf(t, false, "`%s`: more tokens than expected(%d)",
+					source_name, expected_token_number, loc=loc)
+				break
+			}
+			if checking_tokens {
+				expected_token := expected_tokens[token_counter]
+				testing.expectf(t, token == expected_token,  "`%s`(%d:%d): expected token `%s`, got `%s`",
+					source_name, s.pos.line, s.pos.column, string_of_token(expected_token), string_of_token(token), loc=loc)
+			}
+			if checking_words {
+				token_word := scanner.token_text(&s)
+				expected_word := expected_words[token_counter]
+				testing.expectf(t, token_word == expected_word,  "`%s`(%d:%d): expected word `%s`, got `%s`",
+					source_name, s.pos.line, s.pos.column, expected_word, token_word, loc=loc)
+			}
+		}
+
+		token_counter += 1
+	}
+
+	if counting_tokens {
+		testing.expectf(t, token_counter == expected_token_number,
+			"`%s`: fewer tokens than expected; expected %d, got %d",
+			source_name, expected_token_number, token_counter, loc=loc)
+	}
+	
+	if !should_fail {
+		testing.expectf(t, s.error_count == 0, "`%s`: unexpected scanning errors", source_name, loc=loc)
+	} else {
+		testing.expect(t, s.error_count > 0, "`%s`: case did not fail", source_name, loc=loc)
+		if checking_errors {
+			testing.expectf(t, s.error_count == len(expected_fail_locations),
+				"`%s`: case failed incorrect number of times; expected: %d, got %d",
+				source_name, len(expected_fail_locations), s.error_count, loc=loc)
+		}
+	}
+}
+
+@test
+numbers :: proc(t: ^testing.T) {
+	test_scanner(
+		t = t,
+		text = "0x1.2, 0h1.2",
+		expected_fail_locations = {0, 7},
+		should_fail = true,
+	)
+}
+
+@test 
+range_operator :: proc(t: ^testing.T) {
+	test_scanner(
+		t = t,
+		text = "0x00..=0xff",
+		expected_tokens = {scanner.Int, '.', '.', '=', scanner.Int},
+		expected_words = {"0x00", ".", ".", "=", "0xff"},
+	)
+}
+
+@test
+escape_sequences :: proc(t: ^testing.T) {
+	test_scanner(
+		t = t,
+		text = `"\0""\11""\u""\u123""\U1ff1234"`,
+		expected_fail_locations = {0,4,9,13,20},
+		should_fail = true,
+	)
+
+	test_scanner(
+		t = t,
+		text = `"\a\b\e\f\n\r\t\v\\\"\'\567\x1f\u1f34\U1ff1234e"`,
+	)
+}
diff --git a/tests/core/thread/test_core_thread.odin b/tests/core/thread/test_core_thread.odin
index 0b77ad511..e06fcc3cf 100644
--- a/tests/core/thread/test_core_thread.odin
+++ b/tests/core/thread/test_core_thread.odin
@@ -49,4 +49,40 @@ poly_data_test :: proc(_t: ^testing.T) {
 	defer free(t4)
 
 	thread.join_multiple(t1, t2, t3, t4)
-}
\ No newline at end of file
+}
+
+@(test)
+name_test :: proc(_t: ^testing.T) {
+	@static name_test_t: ^testing.T
+	@static main_wait := true
+	@static child_wait := true
+	name_test_t = _t
+
+	t := thread.create_and_start(name = "test_name", fn = proc() {
+		main_wait = false
+
+		for (child_wait) {}
+
+		n, err  := thread.get_name()
+		defer if err != nil {
+			delete(n)
+		}
+		testing.expect(name_test_t, err == nil, "thread name allocation failed")
+		testing.expectf(name_test_t, n == "test_name","thread name on self did not match : got %v", n)
+
+	})
+	defer free(t)
+
+	for (main_wait) {}
+
+	n, err := thread.get_name(t)
+	defer if err != nil {
+		delete(n)
+	}
+	testing.expect(name_test_t, err == nil, "thread name allocation failed")
+	testing.expectf(name_test_t, n == "test_name","thread name on main did not match : got %v", n)
+
+	child_wait = false
+
+	thread.join(t)
+}
diff --git a/tests/internal/test_map.odin b/tests/internal/test_map.odin
index 4d305024e..16171007a 100644
--- a/tests/internal/test_map.odin
+++ b/tests/internal/test_map.odin
@@ -1,7 +1,7 @@
 package test_internal
 
 import "core:log"
-import "base:intrinsics"
+import "base:runtime"
 import "core:math/rand"
 import "core:testing"
 
@@ -201,6 +201,54 @@ map_delete_random_key_value :: proc(t: ^testing.T) {
 	}
 }
 
+@test
+map_shrink :: proc(t: ^testing.T) {
+	m: map[int]int
+	defer delete(m)
+
+	{
+		reserve(&m, 8)
+		did_shrink, err := shrink(&m)
+		testing.expect_value(t, did_shrink, false)
+		testing.expect_value(t, err, runtime.Allocator_Error.None)
+		testing.expect_value(t, cap(m), 8)
+	}
+
+	{
+		reserve(&m, 64)
+		did_shrink, err := shrink(&m)
+		testing.expect_value(t, did_shrink, true)
+		testing.expect_value(t, err, runtime.Allocator_Error.None)
+		testing.expect_value(t, cap(m), 8)
+	}
+
+	{
+		reserve(&m, 128)
+
+		for i in 0 ..< 50 {
+			m[i] = i
+		}
+
+		did_shrink, err := shrink(&m)
+		testing.expect_value(t, did_shrink, false)
+		testing.expect_value(t, err, runtime.Allocator_Error.None)
+		testing.expect_value(t, cap(m), 128)
+	}
+
+	{
+		reserve(&m, 256)
+
+		for i in 0 ..< 50 {
+			m[i] = i
+		}
+
+		did_shrink, err := shrink(&m)
+		testing.expect_value(t, did_shrink, true)
+		testing.expect_value(t, err, runtime.Allocator_Error.None)
+		testing.expect_value(t, cap(m), 128)
+	}
+}
+
 @test
 set_insert_random_key_value :: proc(t: ^testing.T) {
 	seed_incr := u64(0)
diff --git a/tests/issues/run.sh b/tests/issues/run.sh
index ce97a570a..aa66d9886 100755
--- a/tests/issues/run.sh
+++ b/tests/issues/run.sh
@@ -4,7 +4,9 @@ set -eu
 mkdir -p build
 pushd build
 ODIN=../../../odin
-COMMON="-define:ODIN_TEST_FANCY=false -file -vet -strict-style -ignore-unused-defineables"
+COMMON="-define:ODIN_TEST_FANCY=false -file -vet -strict-style -ignore-unused-defineables -microarch:native"
+COMMON_CHECK="-define:ODIN_TEST_FANCY=false -file -vet -strict-style -ignore-unused-defineables"
+
 
 set -x
 
@@ -73,14 +75,14 @@ else
 	echo "SUCCESSFUL 0/1"
 	exit 1
 fi
-$ODIN check ../test_issue_6484.odin -no-entry-point $COMMON
-if [[ $($ODIN check ../test_issue_6874.odin $COMMON 2>&1 >/dev/null | grep -c "Error:") -eq 1 ]] ; then
+$ODIN check ../test_issue_6484.odin -no-entry-point $COMMON_CHECK
+if [[ $($ODIN check ../test_issue_6874.odin $COMMON_CHECK 2>&1 >/dev/null | grep -c "Error:") -eq 1 ]] ; then
 	echo "SUCCESSFUL 1/1"
 else
 	echo "SUCCESSFUL 0/1"
 	exit 1
 fi
-$ODIN check ../test_issue_6979.odin -no-entry-point $COMMON
+$ODIN check ../test_issue_6979.odin -no-entry-point $COMMON_CHECK
 $ODIN build ../test_issue_7037.odin $COMMON -o:none
 
 if [[ $($ODIN build ../test_issue_7108.odin $COMMON 2>&1 >/dev/null | grep -c "Error:") -eq 2 ]] ; then
diff --git a/vendor/box3d/box3d.odin b/vendor/box3d/box3d.odin
index 75639c63e..25be6ebad 100644
--- a/vendor/box3d/box3d.odin
+++ b/vendor/box3d/box3d.odin
@@ -833,6 +833,14 @@ foreign lib {
 	// Is this body a bullet?
 	Body_IsBullet :: proc(bodyId: BodyId) -> bool ---
 
+	// Allow this body to rotate fast. Useful for axially symmetric bodies, such as vehicle wheels.
+	// Normally rotation speed is clamped to improve CCD. However, this clamping is unnecessary for
+	// bodies that only rotate fast around an axis of symmetry.
+	Body_AllowFastRotation :: proc(bodyId: BodyId, flag: bool) ---
+
+	// Is this body allowed to rotate fast?
+	Body_IsFastRotationAllowed :: proc(bodyId: BodyId) -> bool ---
+
 	// Enable or disable contact recycling for this body. Contact recycling is a performance optimization
 	// that reuses contact manifolds when bodies move slightly. Disabling it can avoid ghost collisions
 	// on characters at the cost of higher per-step work. Existing contacts retain their prior setting;
@@ -895,6 +903,10 @@ foreign lib {
 	 * @defgroup shape Shape
 	 * Functions to create, destroy, and access.
 	 * Shapes bind raw geometry to bodies and hold material properties including friction and restitution.
+	 * You may add multiple shapes to a single body. There are no hard limits on shape count per body.
+	 *
+	 * When you create a shape on a body the center of mass moves. This can lead to the body linear velocity
+	 * changing if the angular velocity is non-zero.
 	 * @{
 	 */
 
@@ -933,8 +945,10 @@ foreign lib {
 	// @return the shape id for accessing the shape
 	CreateHeightFieldShape :: proc(bodyId: BodyId, #by_ptr def: ShapeDef, heightField: ^HeightFieldData) -> ShapeId ---
 
-	// Compound shapes are only allowed on static bodies.
-	CreateCompoundShape :: proc(bodyId: BodyId, #by_ptr def: ShapeDef, compound: ^CompoundData) -> ShapeId ---
+	// Baked compound shapes are only allowed on static bodies.
+	// Note: runtime compounds are achieved by adding multiple shapes to a body.
+	// Runtime compounds can be dynamic and/or kinematic.
+	CreateBakedCompoundShape :: proc(bodyId: BodyId, #by_ptr def: ShapeDef, compound: ^CompoundData) -> ShapeId ---
 
 	// Destroy a shape. You may defer the body mass update which can improve performance if several shapes on a
 	//	body are destroyed at once.
diff --git a/vendor/box3d/box3d_collision.odin b/vendor/box3d/box3d_collision.odin
index e80584f7a..33c3961c9 100644
--- a/vendor/box3d/box3d_collision.odin
+++ b/vendor/box3d/box3d_collision.odin
@@ -265,14 +265,12 @@ foreign lib {
 	// Destroy a compound shape.
 	DestroyCompound :: proc(compound: ^CompoundData) ---
 
-	// If bytes is null then this returns the number of required bytes. This clones all the
-	// data into the bytes buffer. This is expected to run offline or asynchronously.
-	// This mutates the compound to nullify pointers, leaving the compound in an unusable state.
+	// Cast the provided compound data to bytes, setting the internal pointers to null.
+	// Use this before serializing the compound bytes.
 	ConvertCompoundToBytes :: proc(compound: ^CompoundData) -> [^]u8 ---
 
-	// Convert bytes to compound. This does not clone. The bytes must remain in scope while the
-	// compound is used. This is done to improve run-time performance and allow for instancing.
-	// The bytes are mutated to fixup pointers.
+	// Cast the provided bytes to compound data, setting up internal pointers.
+	// Use this after de-serializing the compound bytes.
 	ConvertBytesToCompound :: proc(bytes: [^]u8, byteCount: c.int) -> ^CompoundData ---
 
 	/**@}*/ // compound
@@ -440,15 +438,16 @@ foreign lib {
 	// Collide two hulls.
 	CollideHulls :: proc(manifold: ^LocalManifold, capacity: c.int, #by_ptr hullA: HullData, #by_ptr hullB: HullData, transformBtoA: Transform, cache: ^SATCache) ---
 
-	// Collide a capsule and a triangle.
-	CollideCapsuleAndTriangle :: proc(manifold: ^LocalManifold, capacity: c.int, #by_ptr capsuleA: Capsule, #by_ptr triangleB: [3]Vec3, cache: ^SimplexCache) ---
+	// Collide a triangle and capsule. Normal points from triangle to capsule.
+	CollideTriangleAndCapsule :: proc(manifold: ^LocalManifold, capacity: c.int, #by_ptr triangleA: [3]Vec3, #by_ptr capsuleB: Capsule, cache: ^SimplexCache) ---
 
-	// Collide a hull and a triangle.
-	CollideHullAndTriangle :: proc(manifold: ^LocalManifold, capacity: c.int, #by_ptr hullA: HullData, v1, v2, v3: Vec3,
-	                               triangleFlags: c.int, cache: ^SATCache, enableSpeculative: bool) ---
+	// Collide a triangle and hull. Normal points from triangle to hull.
+	CollideTriangleAndHull :: proc(manifold: ^LocalManifold, capacity: c.int, v1, v2, v3: Vec3, triangleFlags: c.int,
+					#by_ptr hullB: HullData, cache: ^SATCache, enableSpeculative: bool) ---
+
+	// Collide a triangle and sphere. Normal points from triangle to sphere.
+	CollideTriangleAndSphere :: proc(manifold: ^LocalManifold, capacity: c.int, #by_ptr triangleA: [3]Vec3, #by_ptr sphereB: Sphere) ---
 
-	// Collide a sphere and a triangle.
-	CollideSphereAndTriangle :: proc(manifold: ^LocalManifold, capacity: c.int, #by_ptr sphereA: Sphere, #by_ptr triangleB: [3]Vec3) ---
 
 	/**@}*/ // collision
 
@@ -513,16 +512,6 @@ GetHullEdges :: proc "c" (hull: ^HullData) -> Maybe(^HullHalfEdge) {
 	return (^HullHalfEdge)(uintptr(hull) + uintptr(hull.edgeOffset))
 }
 
-// Get read only hull faces.
-@(require_results)
-GetHullFaces :: proc "c" (hull: ^HullData) -> Maybe(^HullFace) {
-	if hull.faceOffset == 0 {
-		return nil
-	}
-
-	return (^HullFace)(uintptr(hull) + uintptr(hull.faceOffset))
-}
-
 // Get read only hull planes.
 @(require_results)
 GetHullPlanes :: proc "c" (hull: ^HullData) -> Maybe(^Plane) {
@@ -533,6 +522,38 @@ GetHullPlanes :: proc "c" (hull: ^HullData) -> Maybe(^Plane) {
 	return (^Plane)(uintptr(hull) + uintptr(hull.planeOffset))
 }
 
+// Get read only hull faces.
+@(require_results)
+GetHullFaces :: proc "c" (hull: ^HullData) -> Maybe(^HullFace) {
+	if hull.faceOffset == 0 {
+		return nil
+	}
+
+	return (^HullFace)(uintptr(hull) + uintptr(hull.faceOffset))
+}
+
+// Get read only SOA vertices. This is an array of vertices with all x values,
+// y values, and z values as separate arrays. The array lengths are padded to
+// a multiple of 4. The padded values are repeats of the first value.
+@(require_results)
+GetHullSoaVertices :: proc "c" (hull: ^HullData) -> Maybe([^]f32) {
+	if hull.soaVertexOffset == 0 {
+		return nil
+	}
+
+	return ([^]f32)(uintptr(hull) + uintptr(hull.soaVertexOffset))
+}
+
+// Get read only SOA unit normal vectors. This is an array of normals with all x values,
+// y values, and z values as separate arrays. The array lengths are padded to
+// a multiple of 4. The padded values are repeats of the first value.
+@(require_results)
+GetHullSoaNormals :: proc "c" (hull: ^HullData) -> Maybe([^]f32) {
+	if hull.soaNormalOffset == 0 {
+		return nil
+	}
+	return ([^]f32)(uintptr(hull) + uintptr(hull.soaNormalOffset))
+}
 
 // Get read only mesh BVH nodes.
 @(require_results)
diff --git a/vendor/box3d/box3d_constants.odin b/vendor/box3d/box3d_constants.odin
index ccb93678a..37edbeaaa 100644
--- a/vendor/box3d/box3d_constants.odin
+++ b/vendor/box3d/box3d_constants.odin
@@ -62,6 +62,10 @@ MIN_CAPSULE_LENGTH :: #force_inline proc "c" () -> f32 {
 	return LINEAR_SLOP()
 }
 
+// Minimum contact point friction weight, lower bound for speculative points. Made small
+// enough to be washed away by weights that hit 1.
+MIN_FRICTION_WEIGHT :: 1e-10
+
 // The distance between shapes where they are considered overlapped. This is needed
 // because GJK may return small positive values for overlapped shapes in degenerate
 // configurations.
@@ -121,11 +125,30 @@ TIME_TO_SLEEP :: 0.5
 // The maximum number of contact points between two touching shapes.
 MAX_MANIFOLD_POINTS :: 4
 
+// The number of iterations for gyroscopic torques.
+GYROSCOPIC_ITERATIONS :: 1
+
+// The maximum number of convex hull vertices. This is fixed for performance reasons.
+MAX_HULL_VERTICES :: 128
+
+// The maximum number of convex hull faces.
+MAX_HULL_FACES :: 128
+
+// The maximum number of convex hull edges. Full edges, not half-edges.
+MAX_HULL_EDGES :: 128
+
+// Relative tolerance used to determine if two edges are parallel.
+PARALLEL_EDGE_TOL :: 0.005
+
 // The maximum number points to use for shape cast proxies (swept point cloud).
-MAX_SHAPE_CAST_POINTS :: 64
+MAX_SHAPE_CAST_POINTS :: MAX_HULL_VERTICES
 
 // These generous limits allow for easy hashing. See b3ShapePairKey.
 SHAPE_POWER      :: 22
 CHILD_POWER      :: 64 - 2 * SHAPE_POWER
 MAX_SHAPES       :: 1 << SHAPE_POWER
-MAX_CHILD_SHAPES :: 1 << CHILD_POWER
\ No newline at end of file
+MAX_CHILD_SHAPES :: 1 << CHILD_POWER
+
+// Increase this if your application needs more accurate restitution. Doing so will
+// slow down the simulation. Must be 1 or more.
+RESTITUTION_ITERATIONS :: 1
\ No newline at end of file
diff --git a/vendor/box3d/box3d_types.odin b/vendor/box3d/box3d_types.odin
index 42b72615f..84b8cb53f 100644
--- a/vendor/box3d/box3d_types.odin
+++ b/vendor/box3d/box3d_types.odin
@@ -479,6 +479,9 @@ SurfaceMaterial :: struct {
 	// carry a b3DebugMaterial preset, see b3MakeDebugColor.
 	// @see b3HexColor
 	customColor: u32,
+
+	// Explicit padding. Must be zero.
+	padding: u32,
 }
 
 
@@ -542,6 +545,7 @@ ShapeDef :: struct {
 	isSensor: bool,
 
 	// Enable sensor events for this shape. This applies to sensors and non-sensors. False by default, even for sensors.
+	// Only convex shapes may act as sensor visitors.
 	enableSensorEvents: bool,
 
 	// Enable contact events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors. False by default.
@@ -1871,8 +1875,7 @@ Capsule :: struct {
  * @{
  */
 
-// A hull vertex. Identified by a half-edge with this
-// vertex as its tail.
+// A hull vertex. Identified by a half-edge with this vertex as its tail.
 HullVertex :: struct {
 	// A half-edge that has this vertex as the origin
 	// Can be used along with edge twins and winding order
@@ -1903,7 +1906,7 @@ HullFace :: struct {
 }
 
 // 64-bit hull version. Useful for validating serialized data.
-HULL_VERSION :: 0x9D4716CE3793900E
+HULL_VERSION :: 0xDA5150191B994C01
 
 // A convex hull.
 // @note This data structure has data hanging off the end and cannot be directly copied.
@@ -1953,11 +1956,17 @@ HullData :: struct {
 	// The face count. Hulls faces are convex polygons.
 	faceCount: c.int,
 
+	// Offset of the face plane array in bytes from the struct address.
+	planeOffset: c.int,
+
 	// Offset of the face array in bytes from the struct address.
 	faceOffset: c.int,
 
-	// Offset of the face plane array in bytes from the struct address.
-	planeOffset: c.int,
+	// Offset of structure of array (SOA) vertices
+	soaVertexOffset: c.int,
+
+	// Offset of structure of array (SOA) unit normal vectors
+	soaNormalOffset: c.int,
 
 	// Explicit padding. Hull identity is a content hash and memcmp over raw bytes,
 	// so there must be no unnamed padding for struct copies to scramble.
@@ -1971,9 +1980,15 @@ BoxHull :: struct {
 	boxVertices:  [8]HullVertex,    //< Box vertices.
 	boxPoints:    [8]Vec3,          //< Box points.
 	boxEdges:     [24]HullHalfEdge, //< Box half-edges.
-	boxFaces:     [6]HullFace,      //< Box faces.
-	padding:      [2]u8,            //< Explicit padding, see b3HullData::padding.
 	boxPlanes:    [6]Plane,         //< Box face planes.
+	boxFaces:     [6]HullFace,      //< Box faces.
+	padding:      [10]u8,           //< Explicit padding, see b3HullData::padding.
+	vx:           [8]f32,           //< vertex x
+	vy:           [8]f32,           //< vertex y
+	vz:           [8]f32,           //< vertex z
+	nx:           [8]f32,           //< normal x, padded to multiple of 4
+	ny:           [8]f32,           //< normal y, padded to multiple of 4
+	nz:           [8]f32,           //< normal z, padded to multiple of 4
 }
 
 /**@}*/ // hull
@@ -1989,7 +2004,7 @@ MeshDef :: struct {
 	// Triangle vertices
 	vertices: [^]Vec3 `fmt:"v,vertexCount"`,
 
-	// Triangle vertex indices. 3 for each triangle.
+	// Triangle vertex indices. 3 for each triangle. CCW winding.
 	indices: [^]i32,
 
 	// Triangle material index. 1 per triangle. Indexes into b3ShapeDef::materials.
@@ -2333,13 +2348,13 @@ CompoundDef :: struct {
 }
 
 // The compound version depends on the tree, mesh, and hull versions.
-COMPOUND_VERSION ::  0x830778DB07086EB4 ~ DYNAMIC_TREE_VERSION ~ MESH_VERSION ~ HULL_VERSION
+COMPOUND_VERSION ::  0xB11DCE70FAD5622B ~ DYNAMIC_TREE_VERSION ~ MESH_VERSION ~ HULL_VERSION
 
 // Meshes used in compounds have limited space for materials. If you have
 // a mesh with many materials, you can use it outside of the compound.
 MAX_COMPOUND_MESH_MATERIALS :: 4
 
-// The runtime data for a baked compound shape. This is a potentially large yet highly optimized
+// The data for a baked compound shape. This is a potentially large yet highly optimized
 // data structure. It can contain thousands of child shapes, yet at runtime it populates
 // into the world as a single shape in the runtime broad-phase.
 // This data structure has data living off the end and must be accessed using offsets.
@@ -2851,7 +2866,9 @@ DebugShape :: struct {
 // Callbacks receive world coordinates. In large world mode the translation is double precision so
 // it stays accurate far from the origin. Shift into your own camera frame inside the callbacks.
 DebugDraw :: struct {
-	// Draws a shape and returns true if drawing should continue
+	// Draws a user shape. The userShape pointer is owned by the application and is known to Box3D as
+	// an opaque pointer returned from b3CreateDebugShapeCallback. When this is called the drawn shape has
+	// passed a culling test against drawingBounds below.
 	DrawShapeFcn: proc "c" (userShape: rawptr, transform: WorldTransform, color: HexColor, ctx: rawptr) -> bool,
 
 	// Draw a line segment.
@@ -2912,7 +2929,7 @@ DebugDraw :: struct {
 	drawContacts: bool,
 
 	// Draw contact anchor A or B
-	drawAnchorA: c.int,
+	drawAnchorA: bool,
 
 	// Option to visualize the graph coloring used for contacts and joints
 	drawGraphColors: bool,
@@ -2926,9 +2943,6 @@ DebugDraw :: struct {
 	// Option to draw contact normal forces
 	drawContactForces: bool,
 
-	// Option to draw contact friction forces
-	drawFrictionForces: bool,
-
 	// Option to draw islands as bounding boxes
 	drawIslands: bool,
 
diff --git a/vendor/box3d/lib/box3d.lib b/vendor/box3d/lib/box3d.lib
index 38b5dad36..42ada6bba 100644
Binary files a/vendor/box3d/lib/box3d.lib and b/vendor/box3d/lib/box3d.lib differ
diff --git a/vendor/box3d/lib/darwin/libbox3d.a b/vendor/box3d/lib/darwin/libbox3d.a
index 712d53de5..491d6a685 100644
--- a/vendor/box3d/lib/darwin/libbox3d.a
+++ b/vendor/box3d/lib/darwin/libbox3d.a
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6b000b0b69028af14d6a481b6bf6ca3b70d2c3a29cd9e73eab8b96e0deffa07d
-size 2524600
+oid sha256:92ad74c3967667704cb7589ae6c64612a66112ea12ce4462b849f7aac4bc689f
+size 2551264
diff --git a/vendor/box3d/lib/linux-amd64/libbox3d.a b/vendor/box3d/lib/linux-amd64/libbox3d.a
index ac6223456..402424fa2 100644
--- a/vendor/box3d/lib/linux-amd64/libbox3d.a
+++ b/vendor/box3d/lib/linux-amd64/libbox3d.a
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:948651aca53740a4a47a8251b68982b839fa62da91689035132be1c273cbd7da
-size 1536158
+oid sha256:d698fbbe655db1d1ec6f52dcc23bfed4a2c981fa88040ba449f9f83609edba88
+size 3137140
diff --git a/vendor/box3d/src/include/box3d/base.h b/vendor/box3d/src/include/box3d/base.h
index 25828b3fa..30cee4604 100644
--- a/vendor/box3d/src/include/box3d/base.h
+++ b/vendor/box3d/src/include/box3d/base.h
@@ -38,7 +38,7 @@
 #ifdef __cplusplus
 	#define B3_API extern "C" BOX3D_EXPORT
 	#define B3_INLINE inline
-
+	#define B3_ALIGN_AS(N) alignas(N)
 #if defined( _MSC_VER )
 	#define B3_FORCE_INLINE __forceinline
 #elif defined( __GNUC__ ) || defined( __clang__ )
@@ -52,6 +52,7 @@
 #else
 	#define B3_API BOX3D_EXPORT
 	#define B3_INLINE static inline
+	#define B3_ALIGN_AS(N) _Alignas(N)
 
 #if defined( _MSC_VER )
 	#define B3_FORCE_INLINE static __forceinline
@@ -67,6 +68,13 @@
 #endif
 // clang-format on
 
+// This is used to validate arguments for functions similar to printf.
+#if defined( __GNUC__ ) || defined( __clang__ )
+#define B3_PRINTF_FORMAT( INDEX1, INDEX2 ) __attribute__( ( format( printf, INDEX1, INDEX2 ) ) )
+#else
+#define B3_PRINTF_FORMAT( INDEX1, INDEX2 )
+#endif
+
 #if defined( BOX3D_VALIDATE ) && !defined( NDEBUG )
 #define B3_ENABLE_VALIDATION 1
 #else
@@ -124,7 +132,7 @@ B3_API void b3SetAssertFcn( b3AssertFcn* assertFcn );
 /// Internal assertion handler. Allows for host intervention.
 B3_API int b3InternalAssert( const char* condition, const char* fileName, int lineNumber );
 /// Assert that a condition is true.
-#define B3_ASSERT( condition )                                                                                                  \
+#define B3_ASSERT( condition )                                                                                                   \
 	( (void)( ( !!( condition ) ) || ( b3InternalAssert( #condition, __FILE__, (int)( __LINE__ ) ), 0 ) ) )
 #else
 #define B3_ASSERT( ... ) ( (void)0 )
diff --git a/vendor/box3d/src/include/box3d/box3d.h b/vendor/box3d/src/include/box3d/box3d.h
index 05b69dd63..d9938107c 100644
--- a/vendor/box3d/src/include/box3d/box3d.h
+++ b/vendor/box3d/src/include/box3d/box3d.h
@@ -524,31 +524,31 @@ B3_API b3WorldTransform b3Body_GetTransform( b3BodyId bodyId );
 
 /// Set the world transform of a body. This acts as a teleport and is fairly expensive.
 /// @note Generally you should create a body with the intended transform.
-/// @see b3BodyDef::position and b3BodyDef::rotation
+/// @see b3BodyDef::position and b3BodyDef::rotation.
 B3_API void b3Body_SetTransform( b3BodyId bodyId, b3Pos position, b3Quat rotation );
 
-/// Get a local point on a body given a world point
+/// Get a local point on a body given a world point.
 B3_API b3Vec3 b3Body_GetLocalPoint( b3BodyId bodyId, b3Pos worldPoint );
 
-/// Get a world point on a body given a local point
+/// Get a world point on a body given a local point.
 B3_API b3Pos b3Body_GetWorldPoint( b3BodyId bodyId, b3Vec3 localPoint );
 
-/// Get a local vector on a body given a world vector
+/// Get a local vector on a body given a world vector.
 B3_API b3Vec3 b3Body_GetLocalVector( b3BodyId bodyId, b3Vec3 worldVector );
 
-/// Get a world vector on a body given a local vector
+/// Get a world vector on a body given a local vector.
 B3_API b3Vec3 b3Body_GetWorldVector( b3BodyId bodyId, b3Vec3 localVector );
 
 /// Get the linear velocity of a body's center of mass. Usually in meters per second.
 B3_API b3Vec3 b3Body_GetLinearVelocity( b3BodyId bodyId );
 
-/// Get the angular velocity of a body in radians per second
+/// Get the angular velocity of a body in radians per second.
 B3_API b3Vec3 b3Body_GetAngularVelocity( b3BodyId bodyId );
 
-/// Set the linear velocity of a body. Usually in meters per second.
+/// Set the linear velocity of a body at the center of mass. Usually in meters per second.
 B3_API void b3Body_SetLinearVelocity( b3BodyId bodyId, b3Vec3 linearVelocity );
 
-/// Set the angular velocity of a body in radians per second
+/// Set the angular velocity of a body in radians per second.
 B3_API void b3Body_SetAngularVelocity( b3BodyId bodyId, b3Vec3 angularVelocity );
 
 /// Set the velocity to reach the given transform after a given time step.
@@ -710,6 +710,14 @@ B3_API void b3Body_SetBullet( b3BodyId bodyId, bool flag );
 /// Is this body a bullet?
 B3_API bool b3Body_IsBullet( b3BodyId bodyId );
 
+/// Allow this body to rotate fast. Useful for axially symmetric bodies, such as vehicle wheels.
+/// Normally rotation speed is clamped to improve CCD. However, this clamping is unnecessary for
+/// bodies that only rotate fast around an axis of symmetry.
+B3_API void b3Body_AllowFastRotation( b3BodyId bodyId, bool flag );
+
+/// Is this body allowed to rotate fast?
+B3_API bool b3Body_IsFastRotationAllowed( b3BodyId bodyId );
+
 /// Enable or disable contact recycling for this body. Contact recycling is a performance optimization
 /// that reuses contact manifolds when bodies move slightly. Disabling it can avoid ghost collisions
 /// on characters at the cost of higher per-step work. Existing contacts retain their prior setting;
@@ -777,6 +785,10 @@ B3_API int b3Body_CollideMover( b3BodyId bodyId, b3BodyPlaneResult* bodyPlanes,
  * @defgroup shape Shape
  * Functions to create, destroy, and access.
  * Shapes bind raw geometry to bodies and hold material properties including friction and restitution.
+ * You may add multiple shapes to a single body. There are no hard limits on shape count per body.
+ * 
+ * When you create a shape on a body the center of mass moves. This can lead to the body linear velocity
+ * changing if the angular velocity is non-zero.
  * @{
  */
 
@@ -816,8 +828,10 @@ B3_API b3ShapeId b3CreateMeshShape( b3BodyId bodyId, const b3ShapeDef* def, cons
 /// @return the shape id for accessing the shape
 B3_API b3ShapeId b3CreateHeightFieldShape( b3BodyId bodyId, const b3ShapeDef* def, const b3HeightFieldData* heightField );
 
-/// Compound shapes are only allowed on static bodies.
-B3_API b3ShapeId b3CreateCompoundShape( b3BodyId bodyId, b3ShapeDef* def, const b3CompoundData* compound );
+/// Baked compound shapes are only allowed on static bodies.
+/// Note: runtime compounds are achieved by adding multiple shapes to a body.
+/// Runtime compounds can be dynamic and/or kinematic.
+B3_API b3ShapeId b3CreateBakedCompoundShape( b3BodyId bodyId, b3ShapeDef* def, const b3CompoundData* compound );
 
 /// Destroy a shape. You may defer the body mass update which can improve performance if several shapes on a
 ///	body are destroyed at once.
diff --git a/vendor/box3d/src/include/box3d/collision.h b/vendor/box3d/src/include/box3d/collision.h
index 1ba0070a6..809afb921 100644
--- a/vendor/box3d/src/include/box3d/collision.h
+++ b/vendor/box3d/src/include/box3d/collision.h
@@ -44,7 +44,8 @@ B3_API uint64_t b3DynamicTree_GetCategoryBits( b3DynamicTree* tree, int proxyId
 B3_API b3TreeStats b3DynamicTree_Query( const b3DynamicTree* tree, b3AABB aabb, uint64_t maskBits, bool requireAllBits,
 										b3TreeQueryCallbackFcn* callback, void* context );
 
-/// Query an AABB for the closest object. The callback function is called for each proxy that might be closest to the supplied point.
+/// Query an AABB for the closest object. The callback function is called for each proxy that might be closest to the supplied
+/// point.
 /// @param tree the dynamic tree to query
 /// @param point the query point
 /// @param maskBits nodes are skipped if the bit-wise AND with the node category bits is zero
@@ -163,6 +164,17 @@ B3_INLINE const b3HullHalfEdge* b3GetHullEdges( const b3HullData* hull )
 	return (const b3HullHalfEdge*)( (intptr_t)hull + hull->edgeOffset );
 }
 
+/// Get read only hull planes.
+B3_INLINE const b3Plane* b3GetHullPlanes( const b3HullData* hull )
+{
+	if ( hull->planeOffset == 0 )
+	{
+		return NULL;
+	}
+
+	return (const b3Plane*)( (intptr_t)hull + hull->planeOffset );
+}
+
 /// Get read only hull faces.
 B3_INLINE const b3HullFace* b3GetHullFaces( const b3HullData* hull )
 {
@@ -174,15 +186,30 @@ B3_INLINE const b3HullFace* b3GetHullFaces( const b3HullData* hull )
 	return (const b3HullFace*)( (intptr_t)hull + hull->faceOffset );
 }
 
-/// Get read only hull planes.
-B3_INLINE const b3Plane* b3GetHullPlanes( const b3HullData* hull )
+/// Get read only SOA vertices. This is an array of vertices with all x values,
+/// y values, and z values as separate arrays. The array lengths are padded to
+/// a multiple of 4. The padded values are repeats of the first value.
+B3_INLINE const float* b3GetHullSoaVertices( const b3HullData* hull )
 {
-	if ( hull->planeOffset == 0 )
+	if ( hull->soaVertexOffset == 0 )
 	{
 		return NULL;
 	}
 
-	return (const b3Plane*)( (intptr_t)hull + hull->planeOffset );
+	return (const float*)( (intptr_t)hull + hull->soaVertexOffset );
+}
+
+/// Get read only SOA unit normal vectors. This is an array of normals with all x values,
+/// y values, and z values as separate arrays. The array lengths are padded to
+/// a multiple of 4. The padded values are repeats of the first value.
+B3_INLINE const float* b3GetHullSoaNormals( const b3HullData* hull )
+{
+	if ( hull->soaNormalOffset == 0 )
+	{
+		return NULL;
+	}
+
+	return (const float*)( (intptr_t)hull + hull->soaNormalOffset );
 }
 
 /// Create a tessellated cylinder as a hull.
@@ -426,14 +453,12 @@ B3_API b3CompoundData* b3CreateCompound( const b3CompoundDef* def );
 /// Destroy a compound shape.
 B3_API void b3DestroyCompound( b3CompoundData* compound );
 
-/// If bytes is null then this returns the number of required bytes. This clones all the
-/// data into the bytes buffer. This is expected to run offline or asynchronously.
-/// This mutates the compound to nullify pointers, leaving the compound in an unusable state.
+/// Cast the provided compound data to bytes, setting the internal pointers to null.
+/// Use this before serializing the compound bytes.
 B3_API uint8_t* b3ConvertCompoundToBytes( b3CompoundData* compound );
 
-/// Convert bytes to compound. This does not clone. The bytes must remain in scope while the
-/// compound is used. This is done to improve run-time performance and allow for instancing.
-/// The bytes are mutated to fixup pointers.
+/// Cast the provided bytes to compound data, setting up internal pointers.
+/// Use this after de-serializing the compound bytes.
 B3_API b3CompoundData* b3ConvertBytesToCompound( uint8_t* bytes, int byteCount );
 
 /**@}*/ // compound
@@ -610,17 +635,17 @@ B3_API void b3CollideHullAndCapsule( b3LocalManifold* manifold, int capacity, co
 B3_API void b3CollideHulls( b3LocalManifold* manifold, int capacity, const b3HullData* hullA, const b3HullData* hullB,
 							b3Transform transformBtoA, b3SATCache* cache );
 
-/// Collide a capsule and a triangle.
-B3_API void b3CollideCapsuleAndTriangle( b3LocalManifold* manifold, int capacity, const b3Capsule* capsuleA,
-										 const b3Vec3* triangleB, b3SimplexCache* cache );
+/// Collide a triangle and capsule. Normal points from triangle to capsule.
+B3_API void b3CollideTriangleAndCapsule( b3LocalManifold* manifold, int capacity, const b3Vec3* triangleA,
+										 const b3Capsule* capsuleB, b3SimplexCache* cache );
 
-/// Collide a hull and a triangle.
-B3_API void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3HullData* hullA, b3Vec3 v1, b3Vec3 v2,
-									  b3Vec3 v3, int triangleFlags, b3SATCache* cache, bool enableSpeculative );
+/// Collide a triangle and hull. Normal points from triangle to hull.
+B3_API void b3CollideTriangleAndHull( b3LocalManifold* manifold, int capacity, b3Vec3 v1, b3Vec3 v2, b3Vec3 v3, int triangleFlags,
+									  const b3HullData* hullB, b3SATCache* cache, bool enableSpeculative );
 
-/// Collide a sphere and a triangle.
-B3_API void b3CollideSphereAndTriangle( b3LocalManifold* manifold, int capacity, const b3Sphere* sphereA,
-										const b3Vec3* triangleB );
+/// Collide a triangle and sphere. Normal points from triangle to sphere.
+B3_API void b3CollideTriangleAndSphere( b3LocalManifold* manifold, int capacity, const b3Vec3* triangleA,
+										const b3Sphere* sphereB );
 
 /**@}*/ // collision
 
diff --git a/vendor/box3d/src/include/box3d/config.h b/vendor/box3d/src/include/box3d/config.h
index 2790fc0b8..1309827c9 100644
--- a/vendor/box3d/src/include/box3d/config.h
+++ b/vendor/box3d/src/include/box3d/config.h
@@ -29,3 +29,7 @@
 // so this suits embedding more than shipping Box3D as its own DLL.
 //#define BOX3D_EXPORT MYENGINE_API
 
+// Enable assertions when NDEBUG is defined
+// #define B3_ENABLE_ASSERT
+
+// #define B3_RESTITUTION_ITERATIONS
diff --git a/vendor/box3d/src/include/box3d/constants.h b/vendor/box3d/src/include/box3d/constants.h
index 87dd56d7e..3ac61067a 100644
--- a/vendor/box3d/src/include/box3d/constants.h
+++ b/vendor/box3d/src/include/box3d/constants.h
@@ -52,8 +52,14 @@ B3_API float b3GetStallThreshold( void );
 // @warning modifying this can have a significant impact on stability
 #define B3_LINEAR_SLOP ( 0.005f * b3GetLengthUnitsPerMeter() )
 
+/// The minimum length of a capsules. Very short capsules should be created as spheres
+/// to avoid numerical problems.
 #define B3_MIN_CAPSULE_LENGTH ( B3_LINEAR_SLOP )
 
+/// Minimum contact point friction weight, lower bound for speculative points. Made small
+/// enough to be washed away by weights that hit 1.
+#define B3_MIN_FRICTION_WEIGHT ( 1e-10f )
+
 /// The distance between shapes where they are considered overlapped. This is needed
 /// because GJK may return small positive values for overlapped shapes in degenerate
 /// configurations.
@@ -100,11 +106,34 @@ B3_API float b3GetStallThreshold( void );
 /// The maximum number of contact points between two touching shapes.
 #define B3_MAX_MANIFOLD_POINTS 4
 
+/// The number of iterations for gyroscopic torques.
+#ifndef B3_GYROSCOPIC_ITERATIONS
+#define B3_GYROSCOPIC_ITERATIONS 1
+#endif
+
+/// The maximum number of convex hull vertices. This is fixed for performance reasons.
+#define B3_MAX_HULL_VERTICES 128
+
+/// The maximum number of convex hull faces.
+#define B3_MAX_HULL_FACES 128
+
+/// The maximum number of convex hull edges. Full edges, not half-edges.
+#define B3_MAX_HULL_EDGES 128
+
+/// Relative tolerance used to determine if two edges are parallel.
+#define B3_PARALLEL_EDGE_TOL 0.005f
+
 /// The maximum number points to use for shape cast proxies (swept point cloud).
-#define B3_MAX_SHAPE_CAST_POINTS 64
+#define B3_MAX_SHAPE_CAST_POINTS B3_MAX_HULL_VERTICES
 
 /// These generous limits allow for easy hashing. See b3ShapePairKey.
 #define B3_SHAPE_POWER 22
 #define B3_CHILD_POWER ( 64 - 2 * B3_SHAPE_POWER )
 #define B3_MAX_SHAPES ( 1 << B3_SHAPE_POWER )
 #define B3_MAX_CHILD_SHAPES ( 1 << B3_CHILD_POWER )
+
+/// Increase this if your application needs more accurate restitution. Doing so will
+/// slow down the simulation. Must be 1 or more.
+#ifndef B3_RESTITUTION_ITERATIONS
+#define B3_RESTITUTION_ITERATIONS 1
+#endif
diff --git a/vendor/box3d/src/include/box3d/id.h b/vendor/box3d/src/include/box3d/id.h
index 447fd34ed..9f05e1287 100644
--- a/vendor/box3d/src/include/box3d/id.h
+++ b/vendor/box3d/src/include/box3d/id.h
@@ -96,13 +96,14 @@ static const b3JointId b3_nullJointId = B3_NULL_ID;
 static const b3ContactId b3_nullContactId = B3_NULL_ID;
 
 /// Macro to determine if any id is null.
-#define B3_IS_NULL( id ) ( id.index1 == 0 )
+#define B3_IS_NULL( id ) ( ( id ).index1 == 0 )
 
 /// Macro to determine if any id is non-null.
-#define B3_IS_NON_NULL( id ) ( id.index1 != 0 )
+#define B3_IS_NON_NULL( id ) ( ( id ).index1 != 0 )
 
 /// Compare two ids for equality. Doesn't work for b3WorldId. Don't mix types.
-#define B3_ID_EQUALS( id1, id2 ) ( id1.index1 == id2.index1 && id1.world0 == id2.world0 && id1.generation == id2.generation )
+#define B3_ID_EQUALS( id1, id2 )                                                                                                 \
+	( ( id1 ).index1 == ( id2 ).index1 && ( id1 ).world0 == ( id2 ).world0 && ( id1 ).generation == ( id2 ).generation )
 
 /// Store a world id into a uint32_t.
 B3_ID_INLINE uint32_t b3StoreWorldId( b3WorldId id )
diff --git a/vendor/box3d/src/include/box3d/types.h b/vendor/box3d/src/include/box3d/types.h
index 40e685357..2f9483a4c 100644
--- a/vendor/box3d/src/include/box3d/types.h
+++ b/vendor/box3d/src/include/box3d/types.h
@@ -419,6 +419,9 @@ typedef struct b3SurfaceMaterial
 	/// carry a b3DebugMaterial preset, see b3MakeDebugColor.
 	/// @see b3HexColor
 	uint32_t customColor;
+
+	/// Explicit padding. Must be zero.
+	uint32_t padding;
 } b3SurfaceMaterial;
 
 /// Use this to initialize your surface material
@@ -490,6 +493,7 @@ typedef struct b3ShapeDef
 	bool isSensor;
 
 	/// Enable sensor events for this shape. This applies to sensors and non-sensors. False by default, even for sensors.
+	/// Only convex shapes may act as sensor visitors.
 	bool enableSensorEvents;
 
 	/// Enable contact events for this shape. Only applies to kinematic and dynamic bodies. Ignored for sensors. False by default.
@@ -1930,8 +1934,7 @@ typedef struct b3Capsule
  * @{
  */
 
-/// A hull vertex. Identified by a half-edge with this
-/// vertex as its tail.
+/// A hull vertex. Identified by a half-edge with this vertex as its tail.
 typedef struct b3HullVertex
 {
 	/// A half-edge that has this vertex as the origin
@@ -1965,7 +1968,7 @@ typedef struct b3HullFace
 } b3HullFace;
 
 /// 64-bit hull version. Useful for validating serialized data.
-#define B3_HULL_VERSION 0x9D4716CE3793900Eull
+#define B3_HULL_VERSION 0xDA5150191B994C01ull
 
 /// A convex hull.
 /// @note This data structure has data hanging off the end and cannot be directly copied.
@@ -2016,11 +2019,17 @@ typedef struct b3HullData
 	/// The face count. Hulls faces are convex polygons.
 	int faceCount;
 
+	/// Offset of the face plane array in bytes from the struct address.
+	int planeOffset;
+
 	/// Offset of the face array in bytes from the struct address.
 	int faceOffset;
 
-	/// Offset of the face plane array in bytes from the struct address.
-	int planeOffset;
+	/// Offset of structure of array (SOA) vertices
+	int soaVertexOffset;
+
+	/// Offset of structure of array (SOA) unit normal vectors
+	int soaNormalOffset;
 
 	/// Explicit padding. Hull identity is a content hash and memcmp over raw bytes,
 	/// so there must be no unnamed padding for struct copies to scramble.
@@ -2035,9 +2044,15 @@ typedef struct b3BoxHull
 	b3HullVertex boxVertices[8]; ///< Box vertices.
 	b3Vec3 boxPoints[8];		 ///< Box points.
 	b3HullHalfEdge boxEdges[24]; ///< Box half-edges.
-	b3HullFace boxFaces[6];		 ///< Box faces.
-	uint8_t padding[2];			 ///< Explicit padding, see b3HullData::padding.
 	b3Plane boxPlanes[6];		 ///< Box face planes.
+	b3HullFace boxFaces[6];		 ///< Box faces.
+	uint8_t padding[10];		 ///< Explicit padding, see b3HullData::padding.
+	float vx[8];				 ///< vertex x
+	float vy[8];				 ///< vertex y
+	float vz[8];				 ///< vertex z
+	float nx[8];				 ///< normal x, padded to multiple of 4
+	float ny[8];				 ///< normal y, padded to multiple of 4
+	float nz[8];				 ///< normal z, padded to multiple of 4
 } b3BoxHull;
 
 /**@}*/ // hull
@@ -2048,13 +2063,13 @@ typedef struct b3BoxHull
  * @{
  */
 
-/// This is used to create a re-usable collision mesh
+/// This is used to create a re-usable collision mesh.
 typedef struct b3MeshDef
 {
 	/// Triangle vertices
 	b3Vec3* vertices;
 
-	/// Triangle vertex indices. 3 for each triangle.
+	/// Triangle vertex indices. 3 for each triangle. CCW winding.
 	int32_t* indices;
 
 	/// Triangle material index. 1 per triangle. Indexes into b3ShapeDef::materials.
@@ -2407,14 +2422,14 @@ typedef struct b3CompoundDef
 	int sphereCount;
 } b3CompoundDef;
 
-/// The compound version depends on the tree, mesh, and hull versions.
-#define B3_COMPOUND_VERSION ( 0x830778DB07086EB4ull ^ B3_DYNAMIC_TREE_VERSION ^ B3_MESH_VERSION ^ B3_HULL_VERSION )
+/// The baked compound version depends on the tree, mesh, and hull versions.
+#define B3_COMPOUND_VERSION ( 0xB11DCE70FAD5622Bull ^ B3_DYNAMIC_TREE_VERSION ^ B3_MESH_VERSION ^ B3_HULL_VERSION )
 
 /// Meshes used in compounds have limited space for materials. If you have
 /// a mesh with many materials, you can use it outside of the compound.
 #define B3_MAX_COMPOUND_MESH_MATERIALS 4
 
-/// The runtime data for a baked compound shape. This is a potentially large yet highly optimized
+/// The data for a baked compound shape. This is a potentially large yet highly optimized
 /// data structure. It can contain thousands of child shapes, yet at runtime it populates
 /// into the world as a single shape in the runtime broad-phase.
 /// This data structure has data living off the end and must be accessed using offsets.
@@ -2530,10 +2545,10 @@ typedef struct b3ChildShape
 	/// Tagged union.
 	union
 	{
-		b3Capsule capsule;	///< Capsule.
+		b3Capsule capsule;		///< Capsule.
 		const b3HullData* hull; ///< Hull.
-		b3Mesh mesh;		///< Mesh.
-		b3Sphere sphere;	///< Sphere.
+		b3Mesh mesh;			///< Mesh.
+		b3Sphere sphere;		///< Sphere.
 	};
 
 	/// Transform of the shape into compound local space.
@@ -2943,12 +2958,12 @@ typedef struct b3DebugShape
 	/// Tagged union.
 	union
 	{
-		const b3Capsule* capsule;		  ///< Capsule shape.
+		const b3Capsule* capsule;			  ///< Capsule shape.
 		const b3CompoundData* compound;		  ///< Compound shape.
 		const b3HeightFieldData* heightField; ///< Height-field shape.
-		const b3HullData* hull;			  ///< Convex hull shape.
-		const b3Mesh* mesh;				  ///< Mesh shape with scale.
-		const b3Sphere* sphere;			  ///< Sphere shape.
+		const b3HullData* hull;				  ///< Convex hull shape.
+		const b3Mesh* mesh;					  ///< Mesh shape with scale.
+		const b3Sphere* sphere;				  ///< Sphere shape.
 	};
 } b3DebugShape;
 
@@ -2957,8 +2972,10 @@ typedef struct b3DebugShape
 /// it stays accurate far from the origin. Shift into your own camera frame inside the callbacks.
 typedef struct b3DebugDraw
 {
-	/// Draws a shape and returns true if drawing should continue
-	bool ( *DrawShapeFcn )( void* userShape, b3WorldTransform transform, b3HexColor color, void* context );
+	/// Draws a user shape. The userShape pointer is owned by the application and is known to Box3D as
+	/// an opaque pointer returned from b3CreateDebugShapeCallback. When this is called the drawn shape has 
+	/// passed a culling test against drawingBounds below.
+	void ( *DrawShapeFcn )( void* userShape, b3WorldTransform transform, b3HexColor color, void* context );
 
 	/// Draw a line segment.
 	void ( *DrawSegmentFcn )( b3Pos p1, b3Pos p2, b3HexColor color, void* context );
@@ -3018,7 +3035,7 @@ typedef struct b3DebugDraw
 	bool drawContacts;
 
 	/// Draw contact anchor A or B
-	int drawAnchorA;
+	bool drawAnchorA;
 
 	/// Option to visualize the graph coloring used for contacts and joints
 	bool drawGraphColors;
@@ -3032,9 +3049,6 @@ typedef struct b3DebugDraw
 	/// Option to draw contact normal forces
 	bool drawContactForces;
 
-	/// Option to draw contact friction forces
-	bool drawFrictionForces;
-
 	/// Option to draw islands as bounding boxes
 	bool drawIslands;
 
diff --git a/vendor/box3d/src/src/CMakeLists.txt b/vendor/box3d/src/src/CMakeLists.txt
index 0460f85ba..3f43e7da1 100644
--- a/vendor/box3d/src/src/CMakeLists.txt
+++ b/vendor/box3d/src/src/CMakeLists.txt
@@ -33,6 +33,7 @@ set(BOX3D_SOURCE_FILES
 	dynamic_tree.c
 	height_field.c
 	hull.c
+	hull.h
 	id_pool.c
 	id_pool.h
 	island.c
@@ -154,7 +155,8 @@ if (BOX3D_PROFILE)
 endif()
 
 if(BOX3D_VALIDATE)
-	message(STATUS "Box3D validation ON")	
+	# Only effective when NDEBUG is undefined, see base.h
+	message(STATUS "Box3D validation ON (debug builds)")
 	target_compile_definitions(box3d PRIVATE BOX3D_VALIDATE)
 endif()
 
@@ -169,8 +171,11 @@ if (BOX3D_DOUBLE_PRECISION)
 	target_compile_definitions(box3d PUBLIC BOX3D_DOUBLE_PRECISION)
 endif()
 
+# Enable asserts in release with debug info
+target_compile_definitions(box3d PUBLIC "$<$<CONFIG:RELWITHDEBINFO>:B3_ENABLE_ASSERT>")
+
 if (MSVC)
-	message(STATUS "Box3D on MSVC")	
+	message(STATUS "Box3D on MSVC")
 	if (BUILD_SHARED_LIBS)
 		# this is needed by DLL users to import Box3D symbols
 		target_compile_definitions(box3d INTERFACE BOX3D_DLL)
@@ -179,9 +184,6 @@ if (MSVC)
 	# Visual Studio won't load the natvis unless it is in the project
 	target_sources(box3d PRIVATE box3d.natvis)
 
-	# Enable asserts in release with debug info
-	target_compile_definitions(box3d PUBLIC "$<$<CONFIG:RELWITHDEBINFO>:B3_ENABLE_ASSERT>")
-
 	# Warnings Wall is problematic in mixed C/C++, so using W4
 	target_compile_options(box3d PRIVATE /W4)
 	# target_compile_options(box3d PRIVATE /wd4820 /wd5045 /wd4061 /wd4711 /wd4514 /wd4365 /wd5219 /wd5039)
diff --git a/vendor/box3d/src/src/block_allocator.c b/vendor/box3d/src/src/block_allocator.c
index 4c1f1544e..ebc6d7942 100644
--- a/vendor/box3d/src/src/block_allocator.c
+++ b/vendor/box3d/src/src/block_allocator.c
@@ -9,6 +9,10 @@ b3BlockAllocator b3CreateBlockAllocator( int elementSize, int initialCount )
 {
 	B3_ASSERT( elementSize >= (int)sizeof( void* ) );
 
+	// The free list stores a pointer inside each element, so the stride must keep every element aligned.
+	// Blocks come from b3Alloc, so a stride that is a multiple of B3_ALIGNMENT aligns all elements.
+	elementSize = ( ( elementSize - 1 ) | ( B3_ALIGNMENT - 1 ) ) + 1;
+
 	b3BlockAllocator allocator = { 0 };
 
 	b3Array_Create( allocator.blocks );
@@ -81,6 +85,7 @@ void b3FreeElement( b3BlockAllocator* allocator, void* element )
 	B3_ASSERT( allocator != NULL );
 	B3_ASSERT( element != NULL );
 	B3_ASSERT( allocator->allocationCount > 0 );
+	B3_ASSERT( ( (uintptr_t)element & ( B3_ALIGNMENT - 1 ) ) == 0 );
 
 	allocator->allocationCount -= 1;
 
diff --git a/vendor/box3d/src/src/block_allocator.h b/vendor/box3d/src/src/block_allocator.h
index e9922d012..1c62ed8b4 100644
--- a/vendor/box3d/src/src/block_allocator.h
+++ b/vendor/box3d/src/src/block_allocator.h
@@ -26,7 +26,7 @@ typedef struct b3BlockAllocator
 	int allocationCount;
 } b3BlockAllocator;
 
-// Element must be large enough to hold a pointer
+// Element must be large enough to hold a pointer. The element size is rounded up to B3_ALIGNMENT.
 b3BlockAllocator b3CreateBlockAllocator( int elementSize, int initialCount );
 void b3DestroyBlockAllocator( b3BlockAllocator* allocator );
 
diff --git a/vendor/box3d/src/src/body.c b/vendor/box3d/src/src/body.c
index b78642c6c..bce16dea0 100644
--- a/vendor/box3d/src/src/body.c
+++ b/vendor/box3d/src/src/body.c
@@ -253,8 +253,6 @@ b3BodyId b3CreateBody( b3WorldId worldId, const b3BodyDef* def )
 		bodyState->angularVelocity = def->angularVelocity;
 		bodyState->deltaRotation = b3Quat_identity;
 		bodyState->flags = bodySim->flags;
-
-		bodySim->maxAngularVelocity = b3Length( def->angularVelocity ) + 5.0f;
 	}
 
 	if ( bodyId == world->bodies.count )
@@ -2305,6 +2303,37 @@ bool b3Body_IsBullet( b3BodyId bodyId )
 	return ( body->flags & b3_isBullet ) != 0;
 }
 
+void b3Body_AllowFastRotation(b3BodyId bodyId, bool flag)
+{
+	b3World* world = b3GetUnlockedWorld( bodyId.world0 );
+	if ( world == NULL )
+	{
+		return;
+	}
+
+	B3_REC( world, BodyAllowFastRotation, bodyId, flag );
+
+	uint32_t newFlag = flag ? b3_allowFastRotation : 0;
+
+	b3Body* body = b3GetBodyFullId( world, bodyId );
+	if ( ( body->flags & b3_allowFastRotation ) == newFlag )
+	{
+		return;
+	}
+
+	body->flags &= ~b3_allowFastRotation;
+	body->flags |= newFlag;
+
+	b3SyncBodyFlags( world, body );
+}
+
+bool b3Body_IsFastRotationAllowed(b3BodyId bodyId)
+{
+	b3World* world = b3GetWorld( bodyId.world0 );
+	b3Body* body = b3GetBodyFullId( world, bodyId );
+	return ( body->flags & b3_allowFastRotation ) != 0;
+}
+
 void b3Body_EnableContactRecycling( b3BodyId bodyId, bool flag )
 {
 	b3World* world = b3GetUnlockedWorld( bodyId.world0 );
diff --git a/vendor/box3d/src/src/body.h b/vendor/box3d/src/src/body.h
index 5eebf67ab..ae90105da 100644
--- a/vendor/box3d/src/src/body.h
+++ b/vendor/box3d/src/src/body.h
@@ -208,7 +208,6 @@ typedef struct b3BodySim
 
 	float minExtent;
 	b3Vec3 maxExtent;
-	float maxAngularVelocity;
 	float linearDamping;
 	float angularDamping;
 	float gravityScale;
diff --git a/vendor/box3d/src/src/compound.c b/vendor/box3d/src/src/compound.c
index 29da3c662..1df1f1e82 100644
--- a/vendor/box3d/src/src/compound.c
+++ b/vendor/box3d/src/src/compound.c
@@ -3,7 +3,7 @@
 
 #include "compound.h"
 
-#include "hull_map.h"
+#include "hull.h"
 #include "math_internal.h"
 #include "shape.h"
 
@@ -226,13 +226,19 @@ static bool b3CompareMeshes( const b3MeshData* mesh1, const b3MeshData* mesh2 )
 #define FREE_FN b3Free
 #include "verstable.h"
 
+_Static_assert( sizeof( b3SurfaceMaterial ) == 40, "review padding" );
+
 static inline uint64_t b3HashMaterial( const b3SurfaceMaterial* material )
 {
+	B3_ASSERT( material->padding == 0 );
+
 	return vt_wyhash( material, sizeof( b3SurfaceMaterial ) );
 }
 
 static bool b3CompareMaterials( const b3SurfaceMaterial* mat1, const b3SurfaceMaterial* mat2 )
 {
+	B3_ASSERT( mat1->padding == 0 && mat2->padding == 0);
+
 	if ( mat1 == mat2 )
 	{
 		return true;
@@ -276,7 +282,7 @@ b3CompoundData* b3CreateCompound( const b3CompoundDef* def )
 	int sphereCount = def->sphereCount;
 	b3CompoundSphere* sphereInstances = b3AllocZeroed( sphereCount * sizeof( b3CompoundSphere ) );
 
-	// Determine material capacity
+	// Determine material capacity.
 	int materialCapacity = convexCount;
 	for ( int i = 0; i < def->meshCount; ++i )
 	{
@@ -296,10 +302,10 @@ b3CompoundData* b3CreateCompound( const b3CompoundDef* def )
 		const b3CompoundCapsuleDef* capsuleDef = def->capsules + i;
 		capsuleInstances[i].capsule = capsuleDef->capsule;
 
-		// Look for an existing material
+		// Look for an existing material.
 		b3MaterialMap_itr materialItr = b3MaterialMap_get_or_insert( &materialMap, &capsuleDef->material, materialCount );
 
-		// Get the shared material index
+		// Get the shared material index.
 		int materialIndex = materialItr.data->val;
 		capsuleInstances[i].materialIndex = materialIndex;
 
@@ -333,10 +339,10 @@ b3CompoundData* b3CreateCompound( const b3CompoundDef* def )
 			b3DynamicTree_CreateProxy( &tree, aabb, ~0ull, childIndex );
 			childIndex += 1;
 
-			// Look for an existing material
+			// Look for an existing material.
 			b3MaterialMap_itr materialItr = b3MaterialMap_get_or_insert( &materialMap, &hullDef->material, materialCount );
 
-			// Get the shared material index
+			// Get the shared material index.
 			int materialIndex = materialItr.data->val;
 			hullInstances[i].materialIndex = materialIndex;
 
@@ -395,11 +401,11 @@ b3CompoundData* b3CreateCompound( const b3CompoundDef* def )
 
 			for ( int j = 0; j < meshDef->materialCount; ++j )
 			{
-				// Look for an existing material
+				// Look for an existing material.
 				b3MaterialMap_itr materialItr =
 					b3MaterialMap_get_or_insert( &materialMap, &meshDef->materials[j], materialCount );
 
-				// Get the shared material index
+				// Get the shared material index.
 				int materialIndex = materialItr.data->val;
 				meshInstances[i].materialIndices[j] = materialIndex;
 
@@ -411,17 +417,17 @@ b3CompoundData* b3CreateCompound( const b3CompoundDef* def )
 				}
 			}
 
-			// Look for an existing matching mesh
+			// Look for an existing matching mesh.
 			b3MeshMap_itr itr = b3MeshMap_get_or_insert( &meshMap, meshData, sharedMeshCount );
 
-			// Get the shared mesh index
+			// Get the shared mesh index.
 			int sharedMeshIndex = itr.data->val;
 
-			// Create mesh instance
+			// Create mesh instance.
 			meshInstances[i].transform = def->meshes[i].transform;
 			meshInstances[i].scale = def->meshes[i].scale;
 
-			// The offset isn't known yet, so store the index of the shared mesh
+			// The offset isn't known yet, so store the index of the shared mesh.
 			meshInstances[i].meshOffset = sharedMeshIndex;
 
 			// Is this a new mesh?
@@ -443,10 +449,10 @@ b3CompoundData* b3CreateCompound( const b3CompoundDef* def )
 		const b3CompoundSphereDef* sphereDef = def->spheres + i;
 		sphereInstances[i].sphere = sphereDef->sphere;
 
-		// Look for an existing material
+		// Look for an existing material.
 		b3MaterialMap_itr materialItr = b3MaterialMap_get_or_insert( &materialMap, &sphereDef->material, materialCount );
 
-		// Get the shared material index
+		// Get the shared material index.
 		int materialIndex = materialItr.data->val;
 		sphereInstances[i].materialIndex = materialIndex;
 
@@ -467,58 +473,55 @@ b3CompoundData* b3CreateCompound( const b3CompoundDef* def )
 
 	b3DynamicTree_Rebuild( &tree, true );
 
-	int byteCount = sizeof( b3CompoundData );
-
-	// Tree nodes - todo 64 byte alignment
-	int nodeOffset = byteCount;
-	byteCount += tree.nodeCapacity * sizeof( b3TreeNode );
-
-	int materialOffset = byteCount;
-	byteCount += materialCount * sizeof( b3SurfaceMaterial );
-
-	int capsuleOffset = byteCount;
-	byteCount += def->capsuleCount * sizeof( b3CompoundCapsule );
+	// Tree nodes
+	size_t byteCount = b3AlignUp8( sizeof( b3CompoundData ) );
+	int nodeOffset = (int)byteCount;
+	byteCount += b3AlignUp8( tree.nodeCapacity * sizeof( b3TreeNode ) );
+	int materialOffset = (int)byteCount;
+	byteCount += b3AlignUp8( materialCount * sizeof( b3SurfaceMaterial ) );
+	int capsuleOffset = (int)byteCount;
+	byteCount += b3AlignUp8( def->capsuleCount * sizeof( b3CompoundCapsule ) );
 
 	// Hull data layout has another level of indirection to allow for tight data packing
 	// 1. hull instance array : hull count array of b3HullInstance with individual hull transforms and offsets
 	// 2. heterogeneous array of shared hull data : each shared hull can have a different byte count, so direct indexing is not
 	// possible
-	int hullArrayOffset = byteCount;
+	int hullArrayOffset = (int)byteCount;
 
 	// Array of hull instances
-	byteCount += hullCount * sizeof( b3HullInstance );
+	byteCount += b3AlignUp8( hullCount * sizeof( b3HullInstance ) );
 
 	// Packed shared hull blobs
 	for ( int i = 0; i < sharedHullCount; ++i )
 	{
-		sharedHulls[i].hullOffset = byteCount;
-		byteCount += sharedHulls[i].hull->byteCount;
+		sharedHulls[i].hullOffset = (int)byteCount;
+		byteCount += b3AlignUp8( sharedHulls[i].hull->byteCount );
 	}
 
 	// Mesh data layout has another level of indirection to allow for tight data packing
 	// 1. mesh instance array : mesh count array of b3MeshInstance with individual mesh transform, scale, and offset
 	// 2. heterogeneous array of shared mesh data : each shared mesh can have a different byte count, so direct indexing is not
 	// possible
-	int meshArrayOffset = byteCount;
+	int meshArrayOffset = (int)byteCount;
 
 	// Array of mesh instances
-	byteCount += meshCount * sizeof( b3MeshInstance );
+	byteCount += b3AlignUp8( meshCount * sizeof( b3MeshInstance ) );
 
 	// Packed shared mesh blobs
 	for ( int i = 0; i < sharedMeshCount; ++i )
 	{
-		sharedMeshes[i].meshOffset = byteCount;
-		byteCount += sharedMeshes[i].meshData->byteCount;
+		sharedMeshes[i].meshOffset = (int)byteCount;
+		byteCount += b3AlignUp8( sharedMeshes[i].meshData->byteCount );
 	}
 
-	int sphereOffset = byteCount;
-	byteCount += def->sphereCount * sizeof( b3CompoundSphere );
+	int sphereOffset = (int)byteCount;
+	byteCount += b3AlignUp8( def->sphereCount * sizeof( b3CompoundSphere ) );
 
 	b3CompoundData* compound = b3Alloc( byteCount );
 	memset( compound, 0, byteCount );
 
 	compound->version = B3_COMPOUND_VERSION;
-	compound->byteCount = byteCount;
+	compound->byteCount = (int)byteCount;
 	compound->nodeOffset = nodeOffset;
 	memcpy( &compound->tree, &tree, sizeof( b3DynamicTree ) );
 
diff --git a/vendor/box3d/src/src/contact.c b/vendor/box3d/src/src/contact.c
index 92e38b018..1506bdbe5 100644
--- a/vendor/box3d/src/src/contact.c
+++ b/vendor/box3d/src/src/contact.c
@@ -745,6 +745,16 @@ bool b3UpdateContact( b3World* world, int workerIndex, b3Contact* contact, b3Sha
 
 		childShapeA.type = child.type;
 
+		// Handle child material for non-meshes.
+		if ( child.type != b3_meshShape )
+		{
+			B3_ASSERT( 0 <= child.materialIndices[0] && child.materialIndices[0] < shapeA->materialCount );
+			const b3SurfaceMaterial* parentMaterials = b3GetShapeMaterials( shapeA );
+			childShapeA.material = parentMaterials[child.materialIndices[0]];
+			childShapeA.materials = NULL;
+			childShapeA.materialCount = 1;
+		}
+
 		if ( child.type == b3_capsuleShape )
 		{
 			childShapeA.capsule = child.capsule;
diff --git a/vendor/box3d/src/src/contact_solver.c b/vendor/box3d/src/src/contact_solver.c
index 501f85876..48de40973 100644
--- a/vendor/box3d/src/src/contact_solver.c
+++ b/vendor/box3d/src/src/contact_solver.c
@@ -10,14 +10,13 @@
 #include "math_internal.h"
 #include "physics_world.h"
 #include "platform.h"
+#include "simd.h"
 #include "solver_set.h"
 
 #if B3_ENABLE_VALIDATION
 #include "shape.h"
 #endif
 
-#define FIXED_ANCHORS 1
-
 // contact separation for sub-stepping
 // s = s0 + dot(cB + rB - cA - rA, normal)
 // normal is held constant
@@ -38,6 +37,9 @@ void b3PrepareContacts_Mesh( b3SolverBlock block, b3StepContext* context )
 
 	float warmStartScale = world->enableWarmStarting ? 1.0f : 0.0f;
 
+	// Used for friction center weighting.
+	float invTau = 1.0f / B3_SPECULATIVE_DISTANCE;
+
 	// Need to use spans in order to find the associated b2Contact, which is per color
 	b3ContactPrepareSpan* spans = context->contactPrepareSpans;
 	b3ManifoldConstraint* manifoldBase = context->manifoldConstraints;
@@ -77,7 +79,7 @@ void b3PrepareContacts_Mesh( b3SolverBlock block, b3StepContext* context )
 			int localIndex = index - colorStart;
 			B3_ASSERT( 0 <= localIndex && localIndex < spans[colorIndex].count );
 			int contactId = specs[localIndex].contactId;
-			b3Contact* contact = b3Array_Get( world->contacts, contactId  );
+			b3Contact* contact = b3Array_Get( world->contacts, contactId );
 			B3_ASSERT( contact->contactId == contactId );
 
 			int indexA = contact->bodySimIndexA;
@@ -86,13 +88,13 @@ void b3PrepareContacts_Mesh( b3SolverBlock block, b3StepContext* context )
 #if B3_ENABLE_VALIDATION
 			if ( indexA != B3_NULL_INDEX )
 			{
-				b3Body* bodyA = b3Array_Get( world->bodies, contact->edges[0].bodyId  );
+				b3Body* bodyA = b3Array_Get( world->bodies, contact->edges[0].bodyId );
 				B3_ASSERT( indexA == bodyA->localIndex );
 			}
 
 			if ( indexB != B3_NULL_INDEX )
 			{
-				b3Body* bodyB = b3Array_Get( world->bodies, contact->edges[1].bodyId  );
+				b3Body* bodyB = b3Array_Get( world->bodies, contact->edges[1].bodyId );
 				B3_ASSERT( indexB == bodyB->localIndex );
 			}
 #endif
@@ -184,6 +186,7 @@ void b3PrepareContacts_Mesh( b3SolverBlock block, b3StepContext* context )
 
 				b3Vec3 centerA = b3Vec3_zero;
 				b3Vec3 centerB = b3Vec3_zero;
+				float totalFrictionWeight = 0.0f;
 
 				for ( int pointIndex = 0; pointIndex < pointCount; ++pointIndex )
 				{
@@ -193,7 +196,9 @@ void b3PrepareContacts_Mesh( b3SolverBlock block, b3StepContext* context )
 					b3ManifoldPoint* mp = manifold->points + pointIndex;
 					cp->rA = mp->anchorA;
 					cp->rB = mp->anchorB;
-					cp->baseSeparation = mp->separation - b3Dot( b3Sub( cp->rB, cp->rA ), normal );
+
+					float s = mp->separation;
+					cp->baseSeparation = s - b3Dot( b3Sub( cp->rB, cp->rA ), normal );
 					cp->normalImpulse = warmStartScale * mp->normalImpulse;
 					cp->totalNormalImpulse = 0.0f;
 
@@ -210,15 +215,22 @@ void b3PrepareContacts_Mesh( b3SolverBlock block, b3StepContext* context )
 					b3Vec3 vrB = b3Add( vB, b3Cross( wB, rB ) );
 					cp->relativeVelocity = b3Dot( normal, b3Sub( vrB, vrA ) );
 
-					centerA = b3Add( centerA, rA );
-					centerB = b3Add( centerB, rB );
+					// C0 friction center decay. Needed to prevent spinning top drift (GyroscopicPrecession sample).
+					// Contacts with separation greater than twice the speculative distance only matter for CCD and
+					// should not contribute to the friction center. They are not important for jitter reduction. Closer
+					// points may begin to touch on and off, so the friction center needs to move smoothly.
+					// Epsilon to avoid a branch below (or divide by zero). Small enough to get washed out normally.
+					float weight = b3ClampFloat( 2.0f - s * invTau, B3_MIN_FRICTION_WEIGHT, 1.0f );
+					centerA = b3MulAdd( centerA, weight, rA );
+					centerB = b3MulAdd( centerB, weight, rB );
+					totalFrictionWeight += weight;
 				}
 
-				float invCount = 1.0f / pointCount;
-				centerA = b3MulSV( invCount, centerA );
-				centerB = b3MulSV( invCount, centerB );
-				constraint->originA = centerA;
-				constraint->originB = centerB;
+				float invWeight = 1.0f / totalFrictionWeight;
+				centerA = b3MulSV( invWeight, centerA );
+				centerB = b3MulSV( invWeight, centerB );
+				constraint->centerA = centerA;
+				constraint->centerB = centerB;
 
 				for ( int pointIndex = 0; pointIndex < pointCount; ++pointIndex )
 				{
@@ -265,7 +277,7 @@ void b3WarmStartContacts_Mesh( b3SolverBlock block, b3StepContext* context )
 {
 	b3World* world = context->world;
 	b3GraphColor* color = world->constraintGraph.colors + block.colorIndex;
-	b3SolverSet* awakeSet = b3Array_Get( world->solverSets, b3_awakeSet  );
+	b3SolverSet* awakeSet = b3Array_Get( world->solverSets, b3_awakeSet );
 	b3BodyState* states = awakeSet->bodyStates.data;
 	b3ContactConstraint* constraints = color->contactConstraints;
 
@@ -319,8 +331,8 @@ void b3WarmStartContacts_Mesh( b3SolverBlock block, b3StepContext* context )
 
 			// Central friction
 			{
-				b3Vec3 rA = constraint->originA;
-				b3Vec3 rB = constraint->originB;
+				b3Vec3 rA = constraint->centerA;
+				b3Vec3 rB = constraint->centerB;
 				b3Vec3 impulse = b3MulSV( constraint->frictionImpulse.x, constraint->tangent1 );
 				impulse = b3Add( impulse, b3MulSV( constraint->frictionImpulse.y, constraint->tangent2 ) );
 
@@ -515,8 +527,8 @@ void b3SolveContacts_Mesh( b3SolverBlock block, b3StepContext* context, bool use
 				b3Vec3 tangent2 = constraint->tangent2;
 
 				// Fixed anchor points for applying impulses
-				b3Vec3 rA = constraint->originA;
-				b3Vec3 rB = constraint->originB;
+				b3Vec3 rA = constraint->centerA;
+				b3Vec3 rB = constraint->centerB;
 
 				// Relative tangent velocity at contact
 				b3Vec3 vrA = b3Add( vA, b3Cross( wA, rA ) );
@@ -756,8 +768,8 @@ void b3StoreImpulses_Mesh( b3SolverBlock block, b3StepContext* context, int work
 					mp->totalNormalImpulse = cp->totalNormalImpulse;
 					mp->normalVelocity = cp->relativeVelocity;
 
-					if ( checkHitEvents && flagged == false &&
-						 mp->normalVelocity < negHitThreshold && mp->totalNormalImpulse > 0.0f )
+					if ( checkHitEvents && flagged == false && mp->normalVelocity < negHitThreshold &&
+						 mp->totalNormalImpulse > 0.0f )
 					{
 						b3SetBit( hitEventBitSet, contact->contactId );
 						hasHitEvents = true;
@@ -774,30 +786,6 @@ void b3StoreImpulses_Mesh( b3SolverBlock block, b3StepContext* context, int work
 	taskContext->hasHitEvents = hasHitEvents;
 }
 
-#if defined( B3_SIMD_NEON )
-
-#include <arm_neon.h>
-
-// wide float holds 4 numbers
-typedef float32x4_t b3FloatW;
-
-#elif defined( B3_SIMD_SSE2 )
-
-#include <emmintrin.h>
-
-// wide float holds 4 numbers
-typedef __m128 b3FloatW;
-
-#else
-
-// scalar math
-typedef struct b3FloatW
-{
-	float x, y, z, w;
-} b3FloatW;
-
-#endif
-
 // Wide vec2
 typedef struct b3Vec2W
 {
@@ -829,372 +817,6 @@ typedef struct b3SymMatrix3W
 	b3FloatW cxx, cxy, cxz, cyy, cyz, czz;
 } b3SymMatrix3W;
 
-#if defined( B3_SIMD_NEON )
-
-static inline b3FloatW b3ZeroW( void )
-{
-	return vdupq_n_f32( 0.0f );
-}
-
-static inline b3FloatW b3SplatW( float scalar )
-{
-	return vdupq_n_f32( scalar );
-}
-
-static inline b3FloatW b3NegW( b3FloatW a )
-{
-	return vnegq_f32( a );
-}
-
-static inline b3FloatW b3SetW( float a, float b, float c, float d )
-{
-	float32_t array[4] = { a, b, c, d };
-	return vld1q_f32( array );
-}
-
-static inline b3FloatW b3AddW( b3FloatW a, b3FloatW b )
-{
-	return vaddq_f32( a, b );
-}
-
-static inline b3FloatW b3SubW( b3FloatW a, b3FloatW b )
-{
-	return vsubq_f32( a, b );
-}
-
-static inline b3FloatW b3MulW( b3FloatW a, b3FloatW b )
-{
-	return vmulq_f32( a, b );
-}
-
-static inline b3FloatW b3DivW( b3FloatW a, b3FloatW b )
-{
-	return vdivq_f32( a, b );
-}
-
-static inline b3FloatW b3SqrtW( b3FloatW a )
-{
-	return vsqrtq_f32( a );
-}
-
-// Cannot use real FMA because it doesn't match the non-SIMD path
-static inline b3FloatW b3MulAddW( b3FloatW a, b3FloatW b, b3FloatW c )
-{
-	return vaddq_f32( a, vmulq_f32( b, c ) );
-}
-
-// static inline b3FloatW b3MulSubW( b3FloatW a, b3FloatW b, b3FloatW c )
-//{
-//	return vsubq_f32( a, vmulq_f32( b, c ) );
-// }
-
-static inline b3FloatW b3MinW( b3FloatW a, b3FloatW b )
-{
-	return vminq_f32( a, b );
-}
-
-static inline b3FloatW b3MaxW( b3FloatW a, b3FloatW b )
-{
-	return vmaxq_f32( a, b );
-}
-
-// clamp a to [-b, b]
-static inline b3FloatW b3SymClampW( b3FloatW a, b3FloatW b )
-{
-	b3FloatW nb = b3NegW( b );
-	b3FloatW c = b3MaxW( nb, a );
-	return b3MinW( c, b );
-}
-
-static inline b3FloatW b3OrW( b3FloatW a, b3FloatW b )
-{
-	return vreinterpretq_f32_u32( vorrq_u32( vreinterpretq_u32_f32( a ), vreinterpretq_u32_f32( b ) ) );
-}
-
-static inline b3FloatW b3GreaterThanW( b3FloatW a, b3FloatW b )
-{
-	return vreinterpretq_f32_u32( vcgtq_f32( a, b ) );
-}
-
-static inline b3FloatW b3EqualsW( b3FloatW a, b3FloatW b )
-{
-	return vreinterpretq_f32_u32( vceqq_f32( a, b ) );
-}
-
-static inline bool b3AllZeroW( b3FloatW a )
-{
-	// Create a zero vector for comparison
-	b3FloatW zero = vdupq_n_f32( 0.0f );
-
-	// Compare the input vector with zero
-	uint32x4_t cmp_result = vceqq_f32( a, zero );
-
-// Check if all comparison results are non-zero using vminvq
-#ifdef __ARM_FEATURE_SVE
-	// ARM v8.2+ has horizontal minimum instruction
-	return vminvq_u32( cmp_result ) != 0;
-#else
-	// For older ARM architectures, we need to manually check all lanes
-	return vgetq_lane_u32( cmp_result, 0 ) != 0 && vgetq_lane_u32( cmp_result, 1 ) != 0 && vgetq_lane_u32( cmp_result, 2 ) != 0 &&
-		   vgetq_lane_u32( cmp_result, 3 ) != 0;
-#endif
-}
-
-// component-wise returns mask ? b : a
-static inline b3FloatW b3BlendW( b3FloatW a, b3FloatW b, b3FloatW mask )
-{
-	uint32x4_t mask32 = vreinterpretq_u32_f32( mask );
-	return vbslq_f32( mask32, b, a );
-}
-
-#elif defined( B3_SIMD_SSE2 )
-
-static inline b3FloatW b3ZeroW( void )
-{
-	return _mm_setzero_ps();
-}
-
-static inline b3FloatW b3SplatW( float scalar )
-{
-	return _mm_set1_ps( scalar );
-}
-
-static inline b3FloatW b3NegW( b3FloatW a )
-{
-	// Create a mask with the sign bit set for each element
-	__m128 mask = _mm_set1_ps( -0.0f );
-
-	// XOR the input with the mask to negate each element
-	return _mm_xor_ps( a, mask );
-}
-
-static inline b3FloatW b3SetW( float a, float b, float c, float d )
-{
-	return _mm_setr_ps( a, b, c, d );
-}
-
-static inline b3FloatW b3AddW( b3FloatW a, b3FloatW b )
-{
-	return _mm_add_ps( a, b );
-}
-
-static inline b3FloatW b3SubW( b3FloatW a, b3FloatW b )
-{
-	return _mm_sub_ps( a, b );
-}
-
-static inline b3FloatW b3MulW( b3FloatW a, b3FloatW b )
-{
-	return _mm_mul_ps( a, b );
-}
-
-static inline b3FloatW b3DivW( b3FloatW a, b3FloatW b )
-{
-	return _mm_div_ps( a, b );
-}
-
-static inline b3FloatW b3SqrtW( b3FloatW a )
-{
-	return _mm_sqrt_ps( a );
-}
-
-static inline b3FloatW b3MulAddW( b3FloatW a, b3FloatW b, b3FloatW c )
-{
-	return _mm_add_ps( a, _mm_mul_ps( b, c ) );
-}
-
-// static inline b3FloatW b3MulSubW( b3FloatW a, b3FloatW b, b3FloatW c )
-//{
-//	return _mm_sub_ps( a, _mm_mul_ps( b, c ) );
-// }
-
-static inline b3FloatW b3MinW( b3FloatW a, b3FloatW b )
-{
-	return _mm_min_ps( a, b );
-}
-
-static inline b3FloatW b3MaxW( b3FloatW a, b3FloatW b )
-{
-	return _mm_max_ps( a, b );
-}
-
-// clamp a to [-b, b]
-static inline b3FloatW b3SymClampW( b3FloatW a, b3FloatW b )
-{
-	b3FloatW nb = b3NegW( b );
-	b3FloatW c = b3MaxW( nb, a );
-	return b3MinW( c, b );
-}
-
-static inline b3FloatW b3OrW( b3FloatW a, b3FloatW b )
-{
-	return _mm_or_ps( a, b );
-}
-
-static inline b3FloatW b3GreaterThanW( b3FloatW a, b3FloatW b )
-{
-	return _mm_cmpgt_ps( a, b );
-}
-
-static inline b3FloatW b3EqualsW( b3FloatW a, b3FloatW b )
-{
-	return _mm_cmpeq_ps( a, b );
-}
-
-static inline bool b3AllZeroW( b3FloatW a )
-{
-	// Compare each element with zero
-	b3FloatW zero = _mm_setzero_ps();
-	b3FloatW cmp = _mm_cmpeq_ps( a, zero );
-
-	// Create a mask from the comparison results
-	int mask = _mm_movemask_ps( cmp );
-
-	// If all elements are zero, the mask will be 0xF (1111 in binary)
-	return mask == 0xF;
-}
-
-// component-wise returns mask ? b : a
-static inline b3FloatW b3BlendW( b3FloatW a, b3FloatW b, b3FloatW mask )
-{
-	return _mm_or_ps( _mm_and_ps( mask, b ), _mm_andnot_ps( mask, a ) );
-}
-
-#else
-
-static inline b3FloatW b3ZeroW( void )
-{
-	return (b3FloatW){ 0.0f, 0.0f, 0.0f, 0.0f };
-}
-
-static inline b3FloatW b3SplatW( float scalar )
-{
-	return (b3FloatW){ scalar, scalar, scalar, scalar };
-}
-
-static inline b3FloatW b3NegW( b3FloatW a )
-{
-	return (b3FloatW){ -a.x, -a.y, -a.z, -a.w };
-}
-
-static inline b3FloatW b3AddW( b3FloatW a, b3FloatW b )
-{
-	return (b3FloatW){ a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w };
-}
-
-static inline b3FloatW b3SubW( b3FloatW a, b3FloatW b )
-{
-	return (b3FloatW){ a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w };
-}
-
-static inline b3FloatW b3MulW( b3FloatW a, b3FloatW b )
-{
-	return (b3FloatW){ a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w };
-}
-
-static inline b3FloatW b3DivW( b3FloatW a, b3FloatW b )
-{
-	return (b3FloatW){ a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w };
-}
-
-static inline b3FloatW b3SqrtW( b3FloatW a )
-{
-	return (b3FloatW){ sqrtf( a.x ), sqrtf( a.y ), sqrtf( a.z ), sqrtf( a.w ) };
-}
-
-static inline b3FloatW b3MulAddW( b3FloatW a, b3FloatW b, b3FloatW c )
-{
-	return (b3FloatW){ a.x + b.x * c.x, a.y + b.y * c.y, a.z + b.z * c.z, a.w + b.w * c.w };
-}
-
-// static inline b3FloatW b3MulSubW( b3FloatW a, b3FloatW b, b3FloatW c )
-//{
-//	return { a.x - b.x * c.x, a.y - b.y * c.y, a.z - b.z * c.z, a.w - b.w * c.w };
-// }
-
-// static inline b3FloatW b3MinW( b3FloatW a, b3FloatW b )
-//{
-//	b3FloatW r;
-//	r.x = a.x <= b.x ? a.x : b.x;
-//	r.y = a.y <= b.y ? a.y : b.y;
-//	r.z = a.z <= b.z ? a.z : b.z;
-//	r.w = a.w <= b.w ? a.w : b.w;
-//	return r;
-// }
-
-static inline b3FloatW b3MaxW( b3FloatW a, b3FloatW b )
-{
-	b3FloatW r;
-	r.x = a.x >= b.x ? a.x : b.x;
-	r.y = a.y >= b.y ? a.y : b.y;
-	r.z = a.z >= b.z ? a.z : b.z;
-	r.w = a.w >= b.w ? a.w : b.w;
-	return r;
-}
-
-// clamp a to [-b, b]
-static inline b3FloatW b3SymClampW( b3FloatW a, b3FloatW b )
-{
-	b3FloatW r;
-	r.x = a.x <= b.x ? a.x : b.x;
-	r.y = a.y <= b.y ? a.y : b.y;
-	r.z = a.z <= b.z ? a.z : b.z;
-	r.w = a.w <= b.w ? a.w : b.w;
-	r.x = r.x <= -b.x ? -b.x : r.x;
-	r.y = r.y <= -b.y ? -b.y : r.y;
-	r.z = r.z <= -b.z ? -b.z : r.z;
-	r.w = r.w <= -b.w ? -b.w : r.w;
-	return r;
-}
-
-static inline b3FloatW b3OrW( b3FloatW a, b3FloatW b )
-{
-	b3FloatW r;
-	r.x = a.x != 0.0f || b.x != 0.0f ? 1.0f : 0.0f;
-	r.y = a.y != 0.0f || b.y != 0.0f ? 1.0f : 0.0f;
-	r.z = a.z != 0.0f || b.z != 0.0f ? 1.0f : 0.0f;
-	r.w = a.w != 0.0f || b.w != 0.0f ? 1.0f : 0.0f;
-	return r;
-}
-
-static inline b3FloatW b3GreaterThanW( b3FloatW a, b3FloatW b )
-{
-	b3FloatW r;
-	r.x = a.x > b.x ? 1.0f : 0.0f;
-	r.y = a.y > b.y ? 1.0f : 0.0f;
-	r.z = a.z > b.z ? 1.0f : 0.0f;
-	r.w = a.w > b.w ? 1.0f : 0.0f;
-	return r;
-}
-
-static inline b3FloatW b3EqualsW( b3FloatW a, b3FloatW b )
-{
-	b3FloatW r;
-	r.x = a.x == b.x ? 1.0f : 0.0f;
-	r.y = a.y == b.y ? 1.0f : 0.0f;
-	r.z = a.z == b.z ? 1.0f : 0.0f;
-	r.w = a.w == b.w ? 1.0f : 0.0f;
-	return r;
-}
-
-static inline bool b3AllZeroW( b3FloatW a )
-{
-	return a.x == 0.0f && a.y == 0.0f && a.z == 0.0f && a.w == 0.0f;
-}
-
-// component-wise returns mask ? b : a
-static inline b3FloatW b3BlendW( b3FloatW a, b3FloatW b, b3FloatW mask )
-{
-	b3FloatW r;
-	r.x = mask.x != 0.0f ? b.x : a.x;
-	r.y = mask.y != 0.0f ? b.y : a.y;
-	r.z = mask.z != 0.0f ? b.z : a.z;
-	r.w = mask.w != 0.0f ? b.w : a.w;
-	return r;
-}
-
-#endif
-
 // s * a
 static inline b3Vec3W b3MulSVW( b3FloatW s, b3Vec3W a )
 {
@@ -1342,6 +964,8 @@ typedef struct b3ContactConstraintWide
 	int indexA[B3_SIMD_WIDTH];
 	int indexB[B3_SIMD_WIDTH];
 
+	int pointCounts[B3_SIMD_WIDTH];
+
 	b3FloatW invMassA, invMassB;
 	b3SymMatrix3W invIA, invIB;
 	b3Vec3W normal;
@@ -1350,7 +974,8 @@ typedef struct b3ContactConstraintWide
 	b3Vec3W tangent1;
 	b3Vec3W tangent2;
 
-	b3Vec3W originA, originB;
+	// Friction centers
+	b3Vec3W centerA, centerB;
 	b3FloatW twistMass;
 	b3FloatW twistImpulse;
 	b3SymMatrix2W tangentMass;
@@ -1629,6 +1254,7 @@ void b3PrepareContacts_Convex( b3SolverBlock block, b3StepContext* context )
 	b3Softness staticSoftness = context->staticSoftness;
 
 	float warmStartScale = world->enableWarmStarting ? 1.0f : 0.0f;
+	float invTau = 1.0f / B3_SPECULATIVE_DISTANCE;
 
 	int wideIndex = block.startIndex;
 	int endWideIndex = block.startIndex + block.count;
@@ -1664,7 +1290,7 @@ void b3PrepareContacts_Convex( b3SolverBlock block, b3StepContext* context )
 				}
 
 				int contactId = contactIds[contactIndex];
-				b3Contact* contact = b3Array_Get( world->contacts, contactId  );
+				b3Contact* contact = b3Array_Get( world->contacts, contactId );
 				B3_ASSERT( contact->manifoldCount == 1 );
 				b3Manifold* manifold = contact->manifolds + 0;
 
@@ -1779,8 +1405,11 @@ void b3PrepareContacts_Convex( b3SolverBlock block, b3StepContext* context )
 				( (float*)&constraint->impulseScale )[lane] = soft.impulseScale;
 
 				int pointCount = manifold->pointCount;
-				b3Vec3 originA = b3Vec3_zero;
-				b3Vec3 originB = b3Vec3_zero;
+				constraint->pointCounts[lane] = pointCount;
+
+				b3Vec3 centerA = b3Vec3_zero;
+				b3Vec3 centerB = b3Vec3_zero;
+				float totalFrictionWeight = 0.0f;
 
 				for ( int pointIndex = 0; pointIndex < pointCount; ++pointIndex )
 				{
@@ -1789,8 +1418,14 @@ void b3PrepareContacts_Convex( b3SolverBlock block, b3StepContext* context )
 
 					b3Vec3 rA = mp->anchorA;
 					b3Vec3 rB = mp->anchorB;
-					originA = b3Add( originA, rA );
-					originB = b3Add( originB, rB );
+					float s = mp->separation;
+
+					// C0 friction center decay. Needed to prevent spinning top drift (GyroscopicPrecession sample).
+					// See details in b3PrepareContacts_Mesh. This code should stay in sync.
+					float weight = b3ClampFloat( 2.0f - s * invTau, B3_MIN_FRICTION_WEIGHT, 1.0f );
+					centerA = b3MulAdd( centerA, weight, rA );
+					centerB = b3MulAdd( centerB, weight, rB );
+					totalFrictionWeight += weight;
 
 					( (float*)&cp->anchorAs.X )[lane] = rA.x;
 					( (float*)&cp->anchorAs.Y )[lane] = rA.y;
@@ -1800,7 +1435,7 @@ void b3PrepareContacts_Convex( b3SolverBlock block, b3StepContext* context )
 					( (float*)&cp->anchorBs.Y )[lane] = rB.y;
 					( (float*)&cp->anchorBs.Z )[lane] = rB.z;
 
-					float baseSeparation = mp->separation - b3Dot( b3Sub( rB, rA ), normal );
+					float baseSeparation = s - b3Dot( b3Sub( rB, rA ), normal );
 					( (float*)&cp->baseSeparations )[lane] = baseSeparation;
 
 					( (float*)&cp->normalImpulses )[lane] = warmStartScale * mp->normalImpulse;
@@ -1817,29 +1452,29 @@ void b3PrepareContacts_Convex( b3SolverBlock block, b3StepContext* context )
 					( (float*)&cp->relativeVelocities )[lane] = b3Dot( normal, b3Sub( vrB, vrA ) );
 				}
 
-				float invCount = 1.0f / pointCount;
-				originA = b3MulSV( invCount, originA );
-				originB = b3MulSV( invCount, originB );
+				float invWeight = 1.0f / totalFrictionWeight;
+				centerA = b3MulSV( invWeight, centerA );
+				centerB = b3MulSV( invWeight, centerB );
 
-				( (float*)&constraint->originA.X )[lane] = originA.x;
-				( (float*)&constraint->originA.Y )[lane] = originA.y;
-				( (float*)&constraint->originA.Z )[lane] = originA.z;
-				( (float*)&constraint->originB.X )[lane] = originB.x;
-				( (float*)&constraint->originB.Y )[lane] = originB.y;
-				( (float*)&constraint->originB.Z )[lane] = originB.z;
+				( (float*)&constraint->centerA.X )[lane] = centerA.x;
+				( (float*)&constraint->centerA.Y )[lane] = centerA.y;
+				( (float*)&constraint->centerA.Z )[lane] = centerA.z;
+				( (float*)&constraint->centerB.X )[lane] = centerB.x;
+				( (float*)&constraint->centerB.Y )[lane] = centerB.y;
+				( (float*)&constraint->centerB.Z )[lane] = centerB.z;
 
 				for ( int pointIndex = 0; pointIndex < pointCount; ++pointIndex )
 				{
 					const b3ManifoldPoint* mp = manifold->points + pointIndex;
 					b3ContactConstraintPointWide* cp = constraint->points + pointIndex;
-					( (float*)&cp->leverArms )[lane] = b3Distance( mp->anchorA, originA );
+					( (float*)&cp->leverArms )[lane] = b3Distance( mp->anchorA, centerA );
 				}
 
-				b3Vec3 rtA1 = b3Cross( originA, tangent1 );
-				b3Vec3 rtA2 = b3Cross( originA, tangent2 );
+				b3Vec3 rtA1 = b3Cross( centerA, tangent1 );
+				b3Vec3 rtA2 = b3Cross( centerA, tangent2 );
 
-				b3Vec3 rtB1 = b3Cross( originB, tangent1 );
-				b3Vec3 rtB2 = b3Cross( originB, tangent2 );
+				b3Vec3 rtB1 = b3Cross( centerB, tangent1 );
+				b3Vec3 rtB2 = b3Cross( centerB, tangent2 );
 
 				{
 					b3Matrix2 k;
@@ -1919,8 +1554,14 @@ void b3WarmStartContacts_Convex( b3SolverBlock block, b3StepContext* context )
 		b3BodyStateW bA = b3GatherBodies( states, c->indexA );
 		b3BodyStateW bB = b3GatherBodies( states, c->indexB );
 
+		_Static_assert( B3_SIMD_WIDTH == 4, "width" );
+		int pointCount1 = b3MaxInt( c->pointCounts[0], c->pointCounts[1] );
+		int pointCount2 = b3MaxInt( c->pointCounts[2], c->pointCounts[3] );
+		int pointCount = b3MaxInt( pointCount1, pointCount2 );
+		B3_VALIDATE( 0 < pointCount && pointCount <= B3_MAX_MANIFOLD_POINTS );
+
 		// Normal impulses
-		for ( int j = 0; j < B3_MAX_MANIFOLD_POINTS; ++j )
+		for ( int j = 0; j < pointCount; ++j )
 		{
 			b3ContactConstraintPointWide* cp = c->points + j;
 
@@ -1940,8 +1581,8 @@ void b3WarmStartContacts_Convex( b3SolverBlock block, b3StepContext* context )
 
 		// Central friction
 		{
-			b3Vec3W rA = c->originA;
-			b3Vec3W rB = c->originB;
+			b3Vec3W rA = c->centerA;
+			b3Vec3W rB = c->centerB;
 			b3Vec3W impulse = b3MulSVW( c->frictionImpulse.x, c->tangent1 );
 			impulse = b3MulAddSVW( impulse, c->frictionImpulse.y, c->tangent2 );
 
@@ -1987,6 +1628,12 @@ void b3SolveContacts_Convex( b3SolverBlock block, b3StepContext* context, bool u
 	{
 		b3ContactConstraintWide* c = constraints + wideIndex;
 
+		_Static_assert( B3_SIMD_WIDTH == 4, "width" );
+		int pointCount1 = b3MaxInt( c->pointCounts[0], c->pointCounts[1] );
+		int pointCount2 = b3MaxInt( c->pointCounts[2], c->pointCounts[3] );
+		int pointCount = b3MaxInt( pointCount1, pointCount2 );
+		B3_VALIDATE( 0 < pointCount && pointCount <= B3_MAX_MANIFOLD_POINTS );
+
 		b3BodyStateW bA = b3GatherBodies( states, c->indexA );
 		b3BodyStateW bB = b3GatherBodies( states, c->indexB );
 
@@ -2009,8 +1656,7 @@ void b3SolveContacts_Convex( b3SolverBlock block, b3StepContext* context, bool u
 		b3FloatW totalNormalImpulse = b3ZeroW();
 		b3FloatW totalTwistLimit = b3ZeroW();
 
-		// todo_erin use the max point count of the four manifolds
-		for ( int pointIndex = 0; pointIndex < B3_MAX_MANIFOLD_POINTS; ++pointIndex )
+		for ( int pointIndex = 0; pointIndex < pointCount; ++pointIndex )
 		{
 			b3ContactConstraintPointWide* cp = c->points + pointIndex;
 
@@ -2120,8 +1766,8 @@ void b3SolveContacts_Convex( b3SolverBlock block, b3StepContext* context, bool u
 				b3Vec3W tangent2 = c->tangent2;
 
 				// Fixed anchor points for applying impulses
-				b3Vec3W rA = c->originA;
-				b3Vec3W rB = c->originB;
+				b3Vec3W rA = c->centerA;
+				b3Vec3W rB = c->centerB;
 
 				// Relative tangent velocity at contact
 				b3Vec3W vrA = b3AddVW( bA.v, b3CrossW( bA.w, rA ) );
@@ -2197,6 +1843,12 @@ void b3ApplyRestitution_Convex( b3SolverBlock block, b3StepContext* context )
 			continue;
 		}
 
+		_Static_assert( B3_SIMD_WIDTH == 4, "width" );
+		int pointCount1 = b3MaxInt( c->pointCounts[0], c->pointCounts[1] );
+		int pointCount2 = b3MaxInt( c->pointCounts[2], c->pointCounts[3] );
+		int pointCount = b3MaxInt( pointCount1, pointCount2 );
+		B3_VALIDATE( 0 < pointCount && pointCount <= B3_MAX_MANIFOLD_POINTS );
+
 		// Single gather for all manifolds
 		b3BodyStateW bA = b3GatherBodies( states, c->indexA );
 		b3BodyStateW bB = b3GatherBodies( states, c->indexB );
@@ -2205,7 +1857,7 @@ void b3ApplyRestitution_Convex( b3SolverBlock block, b3StepContext* context )
 		// by the calculations below.
 		b3FloatW restitutionMask = b3EqualsW( c->restitution, zero );
 
-		for ( int pointIndex = 0; pointIndex < B3_MAX_MANIFOLD_POINTS; ++pointIndex )
+		for ( int pointIndex = 0; pointIndex < pointCount; ++pointIndex )
 		{
 			b3ContactConstraintPointWide* cp = c->points + pointIndex;
 
@@ -2372,7 +2024,7 @@ void b3PrepareContacts_Overflow( b3StepContext* context )
 	b3GraphColor* color = graph->colors + B3_OVERFLOW_INDEX;
 
 	uint16_t count = (uint16_t)color->contacts.count;
-	if (count == 0)
+	if ( count == 0 )
 	{
 		return;
 	}
diff --git a/vendor/box3d/src/src/contact_solver.h b/vendor/box3d/src/src/contact_solver.h
index fab17ee53..d85f2331a 100644
--- a/vendor/box3d/src/src/contact_solver.h
+++ b/vendor/box3d/src/src/contact_solver.h
@@ -19,13 +19,13 @@ typedef struct b3ManifoldConstraintPoint
 
 typedef struct b3ManifoldConstraint
 {
-	// todo use pointer buffer
 	b3ManifoldConstraintPoint points[4];
 	int pointCount;
 	b3Vec3 normal;
 	b3Vec3 tangent1;
 	b3Vec3 tangent2;
-	b3Vec3 originA, originB;
+	// Friction centers
+	b3Vec3 centerA, centerB;
 	float twistMass;
 	float twistImpulse;
 	b3Matrix2 tangentMass;
diff --git a/vendor/box3d/src/src/convex_manifold.c b/vendor/box3d/src/src/convex_manifold.c
index 2422567c4..d3b998ae5 100644
--- a/vendor/box3d/src/src/convex_manifold.c
+++ b/vendor/box3d/src/src/convex_manifold.c
@@ -1,9 +1,10 @@
-// SPDX-FileCopyrightText: 2025 Erin Catto
+// SPDX-FileCopyrightText: 2026 Erin Catto
 // SPDX-License-Identifier: MIT
 
 #include "algorithm.h"
 #include "manifold.h"
 #include "shape.h"
+#include "simd.h"
 
 #include "box3d/base.h"
 #include "box3d/collision.h"
@@ -12,31 +13,6 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-static inline bool b3IsMinkowskiFaceIsolated( b3Vec3 a, b3Vec3 b, b3Vec3 n )
-{
-	// An isolated edge (e.g. like in a capsule) defines a circle through the
-	// origin on the Gauss map. So testing for overlap between this circle and
-	// the arc AB simplifies to a simple plane test.
-	float an = b3Dot( a, n );
-	float bn = b3Dot( b, n );
-
-	return an * bn <= 0.0f;
-}
-
-// bxa = cross(b, a) and dxc = cross(d, c)
-// but in practice we use the edge vector between the faces for robustness
-static inline bool b3IsMinkowskiFace( b3Vec3 a, b3Vec3 b, b3Vec3 bxa, b3Vec3 c, b3Vec3 d, b3Vec3 dxc )
-{
-	// Two edges build a face on the Minkowski sum if the associated arcs ab and cd intersect on the Gauss map.
-	// The associated arcs are defined by the adjacent face normals of each edge.
-	float cba = b3Dot( c, bxa );
-	float dba = b3Dot( d, bxa );
-	float adc = b3Dot( a, dxc );
-	float bdc = b3Dot( b, dxc );
-
-	return cba * dba < 0.0f && adc * bdc < 0.0f && cba * bdc > 0.0f;
-}
-
 static int b3ClipSegment( b3ClipVertex segment[2], b3Plane plane )
 {
 	int vertexCount = 0;
@@ -106,8 +82,8 @@ static int b3ClipSegmentToHullFace( b3ClipVertex segment[2], const b3HullData* h
 	return 2;
 }
 
-static b3FaceQuery b3QueryFaceDirectionHullAndCapsule( const b3HullData* hull, const b3Capsule* capsule,
-													   b3Transform capsuleTransform )
+static b3SeparatingAxis b3QueryFaceDirectionHullAndCapsule( const b3HullData* hull, const b3Capsule* capsule,
+															b3Transform capsuleTransform )
 {
 	int maxFaceIndex = -1;
 	int maxVertexIndex = -1;
@@ -134,62 +110,32 @@ static b3FaceQuery b3QueryFaceDirectionHullAndCapsule( const b3HullData* hull, c
 		}
 	}
 
-	return (b3FaceQuery){
+	return (b3SeparatingAxis){
+		.normal = planes[maxFaceIndex].normal,
 		.separation = maxFaceSeparation,
-		.faceIndex = (uint8_t)maxFaceIndex,
-		.vertexIndex = (uint8_t)maxVertexIndex,
+		.indexA = (uint8_t)maxFaceIndex,
+		.indexB = (uint8_t)maxVertexIndex,
 	};
 }
 
-static b3FaceQuery b3QueryFaceDirections( const b3HullData* hullA, const b3HullData* hullB, b3Transform relativeTransform )
-{
-	// We perform all computations in local space of the second hull
-	b3Transform transform = b3InvertTransform( relativeTransform );
-	const b3Plane* planesA = b3GetHullPlanes( hullA );
-	const b3Vec3* pointsB = b3GetHullPoints( hullB );
-
-	int maxFaceIndex = -1;
-	int maxVertexIndex = -1;
-	float maxFaceSeparation = -FLT_MAX;
-
-	for ( int faceIndex = 0; faceIndex < hullA->faceCount; ++faceIndex )
-	{
-		b3Plane plane = b3TransformPlane( transform, planesA[faceIndex] );
-
-		int vertexIndex = b3FindHullSupportVertex( hullB, b3Neg( plane.normal ) );
-		b3Vec3 support = pointsB[vertexIndex];
-		float separation = b3PlaneSeparation( plane, support );
-		if ( separation > maxFaceSeparation )
-		{
-			maxFaceIndex = faceIndex;
-			maxVertexIndex = vertexIndex;
-			maxFaceSeparation = separation;
-		}
-	}
-
-	return (b3FaceQuery){
-		.separation = maxFaceSeparation,
-		.faceIndex = (uint8_t)maxFaceIndex,
-		.vertexIndex = (uint8_t)maxVertexIndex,
-	};
-}
-
-static b3EdgeQuery b3QueryEdgeDirectionHullAndCapsule( const b3HullData* hull, const b3Capsule* capsule,
-													   b3Transform capsuleTransform )
+static b3SeparatingAxis b3QueryEdgeDirectionHullAndCapsule( const b3HullData* hull, const b3Capsule* capsule,
+															b3Transform capsuleTransform )
 {
 	// Find axis of minimum penetration
+	b3Vec3 maxNormal = b3Vec3_zero;
 	float maxSeparation = -FLT_MAX;
-	int maxIndex1 = -1;
-	int maxIndex2 = -1;
+	int maxIndexA = B3_NULL_INDEX;
+	int maxIndexB = B3_NULL_INDEX;
 
 	// We perform all computations in local space of the hull
-	b3Vec3 p1 = b3TransformPoint( capsuleTransform, capsule->center1 );
-	b3Vec3 q1 = b3TransformPoint( capsuleTransform, capsule->center2 );
-	b3Vec3 e1 = b3Sub( q1, p1 );
+	b3Vec3 pA = b3TransformPoint( capsuleTransform, capsule->center1 );
+	b3Vec3 qA = b3TransformPoint( capsuleTransform, capsule->center2 );
+	b3Vec3 eA = b3Sub( qA, pA );
 
 	const b3HullHalfEdge* edges = b3GetHullEdges( hull );
 	const b3Vec3* points = b3GetHullPoints( hull );
 	const b3Plane* planes = b3GetHullPlanes( hull );
+	float squaredTolerance = B3_PARALLEL_EDGE_TOL * B3_PARALLEL_EDGE_TOL;
 
 	for ( int index = 0; index < hull->edgeCount; index += 2 )
 	{
@@ -197,111 +143,60 @@ static b3EdgeQuery b3QueryEdgeDirectionHullAndCapsule( const b3HullData* hull, c
 		const b3HullHalfEdge* twin = edges + index + 1;
 		B3_ASSERT( edge->twin == index + 1 && twin->twin == index );
 
-		b3Vec3 p2 = points[edge->origin];
-		b3Vec3 q2 = points[twin->origin];
-		b3Vec3 e2 = b3Sub( q2, p2 );
+		b3Vec3 qB = points[twin->origin];
+		b3Vec3 uB = planes[edge->face].normal;
+		b3Vec3 vB = planes[twin->face].normal;
 
-		b3Vec3 u2 = planes[edge->face].normal;
-		b3Vec3 v2 = planes[twin->face].normal;
+		// An isolated edge (e.g. like in a capsule) defines a circle through the
+		// origin on the Gauss map. So testing for overlap between this circle and
+		// the arc AB simplifies to a plane test.
+		float cba = b3Dot( uB, eA );
+		float dba = b3Dot( vB, eA );
 
-		if ( b3IsMinkowskiFaceIsolated( u2, v2, e1 ) )
+		if ( cba * dba < 0.0f )
 		{
-			// We can pass any point on the edge and choose
-			// the edge centers for better numerical precision.
-			b3Vec3 c1 = b3MulSV( 0.5f, b3Add( q1, p1 ) );
-			b3Vec3 c2 = hull->center;
-			float separation = b3EdgeEdgeSeparation( q1, e1, c1, q2, e2, c2 );
+			// Avoid nearly parallel edges that may lead to invalid separation values at the noise floor.
+			if ( b3MaxFloat( cba * cba, dba * dba ) < squaredTolerance * b3LengthSquared( eA ) )
+			{
+				continue;
+			}
+
+			// The intersection of the arcs on the Gauss map is the edge pair axis. Cast the
+			// arc of hull B (from uB to vB) against the plane containing the arc of hull A:
+			// dot(uB + t * (vB - uB), eA) == 0
+			// then
+			// t = cba / (cba - dba)
+			//
+			// The signs of cba and dba differ (Minkowski test), so the division is safe.
+			//
+			// The axis generated points from B to A by construction since it lands between
+			// two face normals on B. This removes the need to orient the separation axis
+			// using the hull centers.
+			//
+			// The axis is perpendicular to both edges so I can use qA and qB as arbitrary
+			// points on edgeA and edgeB to measure the separation.
+
+			float t = cba / ( cba - dba );
+			b3Vec3 axis = b3Lerp( uB, vB, t );
+			B3_VALIDATE( b3LengthSquared( axis ) > 1000.0f * FLT_MIN );
+			axis = b3Normalize( axis );
+			float separation = b3Dot( axis, b3Sub( qA, qB ) );
+
 			if ( separation > maxSeparation )
 			{
 				// Note: We don't exit early if we find a separating axis here since we want to
 				// find the best one for caching and account for the convex radius later.
+				maxNormal = axis;
 				maxSeparation = separation;
-				maxIndex1 = 0;
-				maxIndex2 = index;
+				maxIndexA = 0;
+				maxIndexB = index;
 			}
 		}
 	}
 
 	// Save result
-	return (b3EdgeQuery){
-		.separation = maxSeparation,
-		.indexA = (uint8_t)maxIndex1,
-		.indexB = (uint8_t)maxIndex2,
-	};
-}
-
-static b3EdgeQuery b3QueryEdgeDirections( const b3HullData* hullA, const b3HullData* hullB, b3Transform transformBtoA )
-{
-	// Find axis of minimum penetration
-	float maxSeparation = -FLT_MAX;
-	int maxIndexA = B3_NULL_INDEX;
-	int maxIndexB = B3_NULL_INDEX;
-
-	const b3HullHalfEdge* edgesA = b3GetHullEdges( hullA );
-	const b3Vec3* pointsA = b3GetHullPoints( hullA );
-	const b3Plane* planesA = b3GetHullPlanes( hullA );
-	const b3HullHalfEdge* edgesB = b3GetHullEdges( hullB );
-	const b3Vec3* pointsB = b3GetHullPoints( hullB );
-	const b3Plane* planesB = b3GetHullPlanes( hullB );
-
-	// Work in frame A
-	b3Matrix3 matrix = b3MakeMatrixFromQuat( transformBtoA.q );
-
-	// Arranged to minimize transform operations
-	for ( int indexB = 0; indexB < hullB->edgeCount; indexB += 2 )
-	{
-		const b3HullHalfEdge* edgeB = edgesB + indexB;
-		const b3HullHalfEdge* twinB = edgesB + indexB + 1;
-		B3_ASSERT( edgeB->twin == indexB + 1 && twinB->twin == indexB );
-
-		b3Vec3 qB = pointsB[twinB->origin];
-		b3Vec3 eB = b3MulMV( matrix, b3Sub( qB, pointsB[edgeB->origin] ) );
-		qB = b3Add( b3MulMV( matrix, qB ), transformBtoA.p );
-
-		b3Vec3 uB = b3MulMV( matrix, planesB[edgeB->face].normal );
-		b3Vec3 vB = b3MulMV( matrix, planesB[twinB->face].normal );
-
-		for ( int indexA = 0; indexA < hullA->edgeCount; indexA += 2 )
-		{
-			const b3HullHalfEdge* edgeA = edgesA + indexA;
-			const b3HullHalfEdge* twinA = edgesA + indexA + 1;
-			B3_ASSERT( edgeA->twin == indexA + 1 && twinA->twin == indexA );
-
-			b3Vec3 qA = pointsA[twinA->origin];
-			b3Vec3 eA = b3Sub( qA, pointsA[edgeA->origin] );
-			b3Vec3 uA = planesA[edgeA->face].normal;
-			b3Vec3 vA = planesA[twinA->face].normal;
-
-			bool isMinkowski;
-			{
-				// Two edges build a face on the Minkowski sum if the associated arcs AB and CD intersect on the Gauss map.
-				// The associated arcs are defined by the adjacent face normals of each edge.
-				float cba = b3Dot( uB, eA );
-				float dba = b3Dot( vB, eA );
-				float adc = -b3Dot( uA, eB );
-				float bdc = -b3Dot( vA, eB );
-
-				isMinkowski = cba * dba < 0.0f && adc * bdc < 0.0f && cba * bdc > 0.0f;
-			}
-
-			if ( isMinkowski )
-			{
-				b3Vec3 centerA = hullA->center;
-				b3Vec3 centerB = b3TransformPoint( transformBtoA, hullB->center );
-				float separation = b3EdgeEdgeSeparation( qA, eA, centerA, qB, eB, centerB );
-
-				if ( separation > maxSeparation )
-				{
-					// Continues to find the maximum separating axis
-					maxSeparation = separation;
-					maxIndexA = indexA;
-					maxIndexB = indexB;
-				}
-			}
-		}
-	}
-
-	return (b3EdgeQuery){
+	return (b3SeparatingAxis){
+		.normal = maxNormal,
 		.separation = maxSeparation,
 		.indexA = maxIndexA,
 		.indexB = maxIndexB,
@@ -810,13 +705,13 @@ void b3CollideCapsules( b3LocalManifold* manifold, int capacity, const b3Capsule
 }
 
 static bool b3BuildHullFaceAndCapsuleContact( b3LocalManifold* manifold, const b3HullData* hullA, const b3Capsule* capsuleB,
-											  b3Transform transformBtoA, b3FaceQuery query )
+											  b3Transform transformBtoA, b3SeparatingAxis query )
 {
 	// Work in shapeA coordinates
 	const b3Plane* planes = b3GetHullPlanes( hullA );
 
 	// Clip the capsule edge against the side planes of the reference face
-	int refFace = query.faceIndex;
+	int refFace = query.indexA;
 	b3Plane refPlane = planes[refFace];
 
 	b3ClipVertex segmentB[2];
@@ -863,21 +758,8 @@ static bool b3BuildHullFaceAndCapsuleContact( b3LocalManifold* manifold, const b
 	return false;
 }
 
-static inline float b3DeepestPointSeparation( const b3LocalManifold* manifold )
-{
-	// Deepest point
-	float minSeparation = FLT_MAX;
-	int pointCount = manifold->pointCount;
-	for ( int i = 0; i < pointCount; ++i )
-	{
-		minSeparation = b3MinFloat( minSeparation, manifold->points[i].separation );
-	}
-
-	return minSeparation;
-}
-
 static bool b3BuildHullAndCapsuleEdgeContact( b3LocalManifold* manifold, int capacity, const b3HullData* hullA,
-											  const b3Capsule* capsuleB, b3Transform transformBtoA, b3EdgeQuery query )
+											  const b3Capsule* capsuleB, b3Transform transformBtoA, b3SeparatingAxis query )
 {
 	if ( capacity < 1 )
 	{
@@ -895,19 +777,11 @@ static bool b3BuildHullAndCapsuleEdgeContact( b3LocalManifold* manifold, int cap
 
 	const b3HullHalfEdge* edge2 = edges + query.indexB;
 	const b3HullHalfEdge* twin2 = edges + edge2->twin;
-	b3Vec3 ch = hullA->center;
 	b3Vec3 ph = points[edge2->origin];
 	b3Vec3 qh = points[twin2->origin];
 	b3Vec3 eh = b3Sub( qh, ph );
 
-	b3Vec3 normal = b3Cross( ec, eh );
-	normal = b3Normalize( normal );
-
-	// Normal should point outward from hull
-	if ( b3Dot( normal, b3Sub( ph, ch ) ) < 0.0f )
-	{
-		normal = b3Neg( normal );
-	}
+	b3Vec3 normal = query.normal;
 
 	b3SegmentDistanceResult result = b3LineDistance( ph, eh, pc, ec );
 
@@ -918,7 +792,6 @@ static bool b3BuildHullAndCapsuleEdgeContact( b3LocalManifold* manifold, int cap
 	}
 
 	b3Vec3 point = b3MulSV( 0.5f, b3Add( b3MulSub( result.point1, capsuleB->radius, normal ), result.point2 ) );
-
 	float separation = b3Dot( normal, b3Sub( result.point2, result.point1 ) );
 	B3_VALIDATE( b3AbsFloat( separation - query.separation ) < B3_LINEAR_SLOP );
 
@@ -1031,14 +904,14 @@ void b3CollideHullAndCapsule( b3LocalManifold* manifold, int capacity, const b3H
 
 	// Deep penetration
 
-	b3FaceQuery faceQuery = b3QueryFaceDirectionHullAndCapsule( hullA, capsuleB, transformBtoA );
+	b3SeparatingAxis faceQuery = b3QueryFaceDirectionHullAndCapsule( hullA, capsuleB, transformBtoA );
 	if ( faceQuery.separation > capsuleB->radius )
 	{
 		// We found a separating axis
 		return;
 	}
 
-	b3EdgeQuery edgeQuery = b3QueryEdgeDirectionHullAndCapsule( hullA, capsuleB, transformBtoA );
+	b3SeparatingAxis edgeQuery = b3QueryEdgeDirectionHullAndCapsule( hullA, capsuleB, transformBtoA );
 	if ( edgeQuery.separation > capsuleB->radius )
 	{
 		// We found a separating axis
@@ -1048,21 +921,24 @@ void b3CollideHullAndCapsule( b3LocalManifold* manifold, int capacity, const b3H
 	// Create face contact
 	float faceSeparation = faceQuery.separation - capsuleB->radius;
 	b3BuildHullFaceAndCapsuleContact( manifold, hullA, capsuleB, transformBtoA, faceQuery );
-	if ( manifold->pointCount > 1 )
+	B3_VALIDATE( manifold->pointCount == 0 || manifold->pointCount == 2 );
+	if ( manifold->pointCount == 2 )
 	{
-		// If ( Out.PointCount <= 1 ) -> Compare with unclipped separation
-		// If ( Out.PointCount > 1 ) -> Be aggressive and compare with clipped separation
-		// Face contact can be empty if it does not realize the axis of minimum penetration
-		faceSeparation = b3DeepestPointSeparation( manifold );
+		// This becomes the clipped separation.
+		faceSeparation = b3MinFloat( manifold->points[0].separation, manifold->points[1].separation );
+	}
+
+	// Is there a valid edge-edge axis?
+	if ( edgeQuery.indexA == B3_NULL_INDEX )
+	{
+		return;
 	}
-	B3_VALIDATE( faceSeparation <= 0.0f );
 
 	// Face contact can be empty if it does not realize the axis of minimum penetration.
 	// Create edge contact if face contact fails or edge contact is significantly better!
-	const float kRelEdgeTolerance = 0.90f;
-	const float kAbsTolerance = 0.5f * B3_LINEAR_SLOP;
+	float linearSlop = B3_LINEAR_SLOP;
 	float edgeSeparation = edgeQuery.separation - capsuleB->radius;
-	if ( manifold->pointCount == 0 || edgeSeparation > kRelEdgeTolerance * faceSeparation + kAbsTolerance )
+	if ( manifold->pointCount == 0 || edgeSeparation > faceSeparation + linearSlop )
 	{
 		// Edge contact
 		b3BuildHullAndCapsuleEdgeContact( manifold, capacity, hullA, capsuleB, transformBtoA, edgeQuery );
@@ -1108,20 +984,24 @@ static int b3BuildPolygon( b3ClipVertex* out, b3Transform transform, const b3Hul
 }
 
 static bool b3BuildFaceAContact( b3LocalManifold* manifold, int capacity, const b3HullData* hullA, const b3HullData* hullB,
-								 b3Transform transformBtoA, b3FaceQuery query, b3SATCache* cache )
+								 b3Transform transformBtoA, b3SeparatingAxis query, b3SATCache* cache )
 {
+	B3_VALIDATE( query.type == b3_faceAxisA );
+	B3_VALIDATE( 0 <= query.indexA && query.indexA < hullA->faceCount );
+	B3_VALIDATE( 0 <= query.indexB && query.indexB < hullB->vertexCount );
+
 	const b3HullFace* facesA = b3GetHullFaces( hullA );
 	const b3HullHalfEdge* edgesA = b3GetHullEdges( hullA );
 	const b3Plane* planesA = b3GetHullPlanes( hullA );
 	const b3Vec3* pointsA = b3GetHullPoints( hullA );
 
 	// Reference face
-	int refFace = query.faceIndex;
+	int refFace = query.indexA;
 	b3Plane refPlane = planesA[refFace];
 
 	// Find incident face
 	b3Vec3 refNormalInB = b3InvRotateVector( transformBtoA.q, refPlane.normal );
-	int incFace = b3FindIncidentFace( hullB, refNormalInB, query.vertexIndex );
+	int incFace = b3FindIncidentFace( hullB, refNormalInB, query.indexB );
 
 	// Build clip polygon from incident face in frame A
 	b3ClipVertex buffer1[B3_MAX_CLIP_POINTS], buffer2[B3_MAX_CLIP_POINTS];
@@ -1198,19 +1078,30 @@ static bool b3BuildFaceAContact( b3LocalManifold* manifold, int capacity, const
 	// Save cache
 	cache->separation = minSeparation;
 	cache->type = (uint8_t)b3_faceAxisA;
-	cache->indexA = (uint8_t)query.faceIndex;
-	cache->indexB = (uint8_t)query.vertexIndex;
+	cache->indexA = (uint8_t)query.indexA;
+	cache->indexB = (uint8_t)query.indexB;
 
 	return true;
 }
 
 static bool b3BuildFaceBContact( b3LocalManifold* manifold, int capacity, const b3HullData* hullA, const b3HullData* hullB,
-								 b3Transform transformBtoA, b3FaceQuery query, b3SATCache* cache )
+								 b3Transform transformBtoA, b3SeparatingAxis query, b3SATCache* cache )
 {
+	B3_VALIDATE( query.type == b3_faceAxisB );
+
 	b3Transform transformAtoB = b3InvertTransform( transformBtoA );
-	bool touching = b3BuildFaceAContact( manifold, capacity, hullB, hullA, transformAtoB, query, cache );
+	b3SeparatingAxis flippedQuery = {
+		.normal = b3Neg( query.normal ),
+		.separation = query.separation,
+		.indexA = query.indexB,
+		.indexB = query.indexA,
+		.type = b3_faceAxisA,
+	};
+
+	bool touching = b3BuildFaceAContact( manifold, capacity, hullB, hullA, transformAtoB, flippedQuery, cache );
 	if ( touching == false )
 	{
+		*cache = (b3SATCache){ 0 };
 		return false;
 	}
 
@@ -1219,9 +1110,6 @@ static bool b3BuildFaceBContact( b3LocalManifold* manifold, int capacity, const
 
 	// Transform and flip normal so it points from A to B, even though the B has the reference face.
 	manifold->normal = b3Neg( b3MulMV( matrix, manifold->normal ) );
-	cache->type = (uint8_t)b3_faceAxisB;
-	cache->indexA = (uint8_t)query.vertexIndex;
-	cache->indexB = (uint8_t)query.faceIndex;
 
 	// Transform points from frame B to frame A.
 	// Also flip the pairs to ensure correct matches.
@@ -1232,12 +1120,20 @@ static bool b3BuildFaceBContact( b3LocalManifold* manifold, int capacity, const
 		pt->pair = b3FlipPair( pt->pair );
 	}
 
+	cache->type = (uint8_t)b3_faceAxisB;
+	cache->indexA = (uint8_t)query.indexA;
+	cache->indexB = (uint8_t)query.indexB;
+
 	return true;
 }
 
-static bool b3BuildEdgeContact( b3LocalManifold* manifold, const b3HullData* hullA, const b3HullData* hullB, b3Transform transformBtoA,
-								b3EdgeQuery query, b3SATCache* cache )
+static bool b3BuildEdgeContact( b3LocalManifold* manifold, const b3HullData* hullA, const b3HullData* hullB,
+								b3Transform transformBtoA, b3SeparatingAxis query, b3SATCache* cache )
 {
+	B3_VALIDATE( query.type == b3_edgePairAxis );
+	B3_VALIDATE( 0 <= query.indexA && query.indexA < hullA->edgeCount );
+	B3_VALIDATE( 0 <= query.indexB && query.indexB < hullB->edgeCount );
+
 	// Work in shapeA coordinates
 	const b3HullHalfEdge* edgesA = b3GetHullEdges( hullA );
 	const b3Vec3* pointsA = b3GetHullPoints( hullA );
@@ -1249,7 +1145,6 @@ static bool b3BuildEdgeContact( b3LocalManifold* manifold, const b3HullData* hul
 
 	const b3HullHalfEdge* edgeA = edgesA + query.indexA;
 	const b3HullHalfEdge* twinA = edgesA + edgeA->twin;
-	b3Vec3 centerA = hullA->center;
 	b3Vec3 pA = pointsA[edgeA->origin];
 	b3Vec3 qA = pointsA[twinA->origin];
 	b3Vec3 eA = b3Sub( qA, pA );
@@ -1260,14 +1155,7 @@ static bool b3BuildEdgeContact( b3LocalManifold* manifold, const b3HullData* hul
 	b3Vec3 qB = b3TransformPoint( transformBtoA, pointsB[twinB->origin] );
 	b3Vec3 eB = b3Sub( qB, pB );
 
-	b3Vec3 normal = b3Cross( eA, eB );
-	normal = b3Normalize( normal );
-
-	if ( b3Dot( normal, b3Sub( pA, centerA ) ) < 0.0f )
-	{
-		normal = b3Neg( normal );
-	}
-
+	b3Vec3 normal = query.normal;
 	b3SegmentDistanceResult result = b3LineDistance( pA, eA, pB, eB );
 
 	if ( b3IsWithinSegments( &result ) == false )
@@ -1278,10 +1166,6 @@ static bool b3BuildEdgeContact( b3LocalManifold* manifold, const b3HullData* hul
 
 	// This can slide off the end from caching
 	float separation = b3Dot( normal, b3Sub( result.point2, result.point1 ) );
-
-	// todo I suspect this could trip if the cache becomes invalid
-	// B3_VALIDATE( b3AbsFloat( separation - query.separation ) < B3_LINEAR_SLOP );
-
 	b3Vec3 point = b3MulSV( 0.5f, b3Add( result.point1, result.point2 ) );
 
 	// Result in frame A
@@ -1302,8 +1186,1101 @@ static bool b3BuildEdgeContact( b3LocalManifold* manifold, const b3HullData* hul
 	return true;
 }
 
-void b3CollideHulls( b3LocalManifold* manifold, int capacity, const b3HullData* hullA, const b3HullData* hullB, b3Transform transformBtoA,
-					 b3SATCache* cache )
+// Transform a SoA point/normal stream (already split into X/Y/Z) by out = -(R*v (+t)).
+// The inputs come straight from the hull's stored SoA arrays, so there's no transpose here.
+// IsPoint is a template arg so the translation add is only emitted for points.
+static inline void b3NegativeTransformFromSoA( b3Matrix3* R, b3Vec3 p, const float* inX, const float* inY, const float* inZ,
+											   int n, float* outX, float* outY, float* outZ, bool isPoint )
+{
+	B3_VALIDATE( ( (uintptr_t)outX & 0xF ) == 0 );
+	B3_VALIDATE( ( (uintptr_t)outY & 0xF ) == 0 );
+	B3_VALIDATE( ( (uintptr_t)outZ & 0xF ) == 0 );
+
+	// row-column
+	b3FloatW r00 = b3SplatW( R->cx.x );
+	b3FloatW r01 = b3SplatW( R->cy.x );
+	b3FloatW r02 = b3SplatW( R->cz.x );
+	b3FloatW r10 = b3SplatW( R->cx.y );
+	b3FloatW r11 = b3SplatW( R->cy.y );
+	b3FloatW r12 = b3SplatW( R->cz.y );
+	b3FloatW r20 = b3SplatW( R->cx.z );
+	b3FloatW r21 = b3SplatW( R->cy.z );
+	b3FloatW r22 = b3SplatW( R->cz.z );
+
+	b3FloatW tx = b3ZeroW();
+	b3FloatW ty = b3ZeroW();
+	b3FloatW tz = b3ZeroW();
+
+	if ( isPoint )
+	{
+		tx = b3SplatW( p.x );
+		ty = b3SplatW( p.y );
+		tz = b3SplatW( p.z );
+	}
+
+	for ( int i = 0; i < n; i += 4 )
+	{
+		b3FloatW x = b3LoadW( inX + i );
+		b3FloatW y = b3LoadW( inY + i );
+		b3FloatW z = b3LoadW( inZ + i );
+
+		// Rotate four vectors at a time
+		b3FloatW ox = b3Dot3W( r00, r01, r02, x, y, z );
+		b3FloatW oy = b3Dot3W( r10, r11, r12, x, y, z );
+		b3FloatW oz = b3Dot3W( r20, r21, r22, x, y, z );
+
+		if ( isPoint )
+		{
+			ox = b3AddW( ox, tx );
+			oy = b3AddW( oy, ty );
+			oz = b3AddW( oz, tz );
+		}
+
+		b3StoreW( outX + i, b3NegW( ox ) );
+		b3StoreW( outY + i, b3NegW( oy ) );
+		b3StoreW( outZ + i, b3NegW( oz ) );
+	}
+}
+
+_Static_assert( B3_MAX_HULL_VERTICES == 128, "must be 128" );
+
+#define B3_HULL_BIT_COUNT 7
+
+// SIMD support point calculation using a SoA vertex array padded with repeats of the first vertex
+// to a multiple of 4.
+//
+// This minimizes (bias - dot), where the caller is expected to provide a bias that makes this always positive.
+// It can be direction dependent. The bias should be just big enough to ensure the value if positive because
+// an excessive bias causes a precision loss in the support calculation.
+//
+// The vertex index is embedded in the low B3_HULL_BIT_COUNT mantissa bits of the value. By minimizing a value that
+// is always positive, the minimum carries the smallest index so that padded SoA values will never win. This is
+// purpose of using the bias instead of maximizing the dot directly.
+//
+// The support is then recomputed exactly as dot(normal, vertex), without the embedded index.
+// todo consider using this for GJK
+static inline void b3GetSupportWide( b3Vec3 normal, const float* vx, const float* vy, const float* vz, int n, float bias,
+									 float* support, int* vertexIndex )
+{
+	const b3FloatW nx = b3SplatW( normal.x );
+	const b3FloatW ny = b3SplatW( normal.y );
+	const b3FloatW nz = b3SplatW( normal.z );
+	const b3FloatW biasV = b3SplatW( bias );
+
+	// Start the minimum at a large value.
+	b3FloatW minValue = b3SplatW( B3_HUGE );
+
+	// Tail lanes hold vertex 0 with index bits >= vertexCount, so they never become the min value.
+	for ( int i = 0; i < n; i += 4 )
+	{
+		b3FloatW x = b3LoadW( vx + i );
+		b3FloatW y = b3LoadW( vy + i );
+		b3FloatW z = b3LoadW( vz + i );
+		b3FloatW d = b3AddW( b3MulW( nz, z ), b3AddW( b3MulW( ny, y ), b3MulW( nx, x ) ) );
+
+		// This is always positive.
+		b3FloatW value = b3SubW( biasV, d );
+		b3FloatW augmentedValue = b3EmbedIndexW( value, i, B3_HULL_BIT_COUNT );
+		minValue = b3MinW( minValue, augmentedValue );
+	}
+
+	// One horizontal min, the winning lane's value and index bits ride through.
+	int vi = b3MinIndexW( minValue, B3_HULL_BIT_COUNT );
+
+	// Exact support for the chosen vertex.
+	*vertexIndex = vi;
+
+	// Dot product
+	*support = normal.x * vx[vi] + normal.y * vy[vi] + normal.z * vz[vi];
+}
+
+#define NE ( B3_MAX_HULL_EDGES + 4 )
+#define NF ( B3_MAX_HULL_FACES + 4 )
+#define NV ( B3_MAX_HULL_VERTICES + 4 )
+
+// SIMD separating axis test based on an implementation developed by Cairn Overturf.
+// See his article: https://cairno.substack.com/p/improvements-to-the-separating-axis
+b3AxisQuery b3ComputeSeparatingAxis( const b3HullData* hullA, const b3HullData* hullB, b3Transform xfB, bool earlyReturn )
+{
+	b3Matrix3 R = b3MakeMatrixFromQuat( xfB.q );
+	b3Matrix3 invR = b3Transpose( R );
+
+	float speculativeDistance = B3_SPECULATIVE_DISTANCE;
+
+	b3AxisQuery res = {
+		.faceA =
+			{
+				.normal = b3Vec3_zero,
+				.separation = -INFINITY,
+				.indexA = B3_NULL_INDEX,
+				.indexB = B3_NULL_INDEX,
+				.type = b3_faceAxisA,
+			},
+		.faceB =
+			{
+				.normal = b3Vec3_zero,
+				.separation = -INFINITY,
+				.indexA = B3_NULL_INDEX,
+				.indexB = B3_NULL_INDEX,
+				.type = b3_faceAxisB,
+			},
+		.edge =
+			{
+				.normal = b3Vec3_zero,
+				.separation = -INFINITY,
+				.indexA = B3_NULL_INDEX,
+				.indexB = B3_NULL_INDEX,
+				.type = b3_edgePairAxis,
+			},
+		.separatedFeature = b3_invalidAxis,
+	};
+
+	int faceCountA = hullA->faceCount;
+	const b3Plane* planesA = b3GetHullPlanes( hullA );
+
+	int soaVertexCountB = ( hullB->vertexCount + 3 ) & ~3;
+	const float* vxB = b3GetHullSoaVertices( hullB );
+	const float* vyB = vxB + soaVertexCountB;
+	const float* vzB = vyB + soaVertexCountB;
+
+	b3Vec3 cB = b3AABB_Center( hullB->aabb );
+	b3Vec3 hB = b3AABB_Extents( hullB->aabb );
+
+	// Test A's face planes against B's vertices.
+	for ( int i = 0; i < faceCountA; ++i )
+	{
+		b3Plane plane = planesA[i];
+		b3Vec3 direction = b3Neg( b3MulMV( invR, plane.normal ) );
+		float planeSeparation = b3Dot( plane.normal, xfB.p ) - plane.offset;
+		float biasB = b3Dot( direction, cB ) + 1.0625f * b3Dot( b3Abs( direction ), hB );
+		float support;
+		int vertexIndex;
+		b3GetSupportWide( direction, vxB, vyB, vzB, soaVertexCountB, biasB, &support, &vertexIndex );
+		float separation = planeSeparation - support;
+		if ( separation > res.faceA.separation )
+		{
+			res.faceA.normal = plane.normal;
+			res.faceA.separation = separation;
+			res.faceA.indexA = i;
+			res.faceA.indexB = vertexIndex;
+			if ( separation > speculativeDistance && earlyReturn )
+			{
+				res.separatedFeature = b3_faceAxisA;
+				return res;
+			}
+		}
+	}
+
+	int faceCountB = hullB->faceCount;
+	const b3Plane* planesB = b3GetHullPlanes( hullB );
+
+	int soaVertexCountA = ( hullA->vertexCount + 3 ) & ~3;
+	const float* vxA = b3GetHullSoaVertices( hullA );
+	const float* vyA = vxA + soaVertexCountA;
+	const float* vzA = vyA + soaVertexCountA;
+
+	b3Vec3 cA = b3AABB_Center( hullA->aabb );
+	b3Vec3 hA = b3AABB_Extents( hullA->aabb );
+
+	// Test B's face planes against A's vertices.
+	for ( int i = 0; i < faceCountB; ++i )
+	{
+		b3Plane plane = planesB[i];
+		b3Vec3 direction = b3Neg( b3MulMV( R, plane.normal ) );
+		float planeSeparation = b3Dot( direction, xfB.p ) - plane.offset;
+		float biasA = b3Dot( direction, cA ) + 1.0625f * b3Dot( b3Abs( direction ), hA );
+		float support;
+		int vertexIndex;
+		b3GetSupportWide( direction, vxA, vyA, vzA, soaVertexCountA, biasA, &support, &vertexIndex );
+		float separation = planeSeparation - support;
+		if ( separation > res.faceB.separation )
+		{
+			res.faceB.normal = direction;
+			res.faceB.separation = separation;
+			res.faceB.indexA = vertexIndex;
+			res.faceB.indexB = i;
+			// This points from A to B and is in frame A
+			if ( separation > speculativeDistance && earlyReturn )
+			{
+				res.separatedFeature = b3_faceAxisB;
+				return res;
+			}
+		}
+	}
+
+	// Transform B into A's space once, into SoA arrays. Extra space so
+	// tail can be set to zero in all cases.
+	_Static_assert( ( B3_MAX_HULL_EDGES & 3 ) == 0, "must be multiple of 4" );
+	_Static_assert( ( B3_MAX_HULL_FACES & 3 ) == 0, "must be multiple of 4" );
+	_Static_assert( ( B3_MAX_HULL_VERTICES & 3 ) == 0, "must be multiple of 4" );
+
+	// The alignments below are not necessary, but they don't hurt.
+
+	// B face normals in A space, negated.
+	_Alignas( 16 ) float bFNx[NF];
+	_Alignas( 16 ) float bFNy[NF];
+	_Alignas( 16 ) float bFNz[NF];
+
+	// B vertices in A space, negated.
+	_Alignas( 16 ) float bWx[NV];
+	_Alignas( 16 ) float bWy[NV];
+	_Alignas( 16 ) float bWz[NV];
+
+	int soaFaceCountB = ( faceCountB + 3 ) & ~3;
+	const float* nxB = b3GetHullSoaNormals( hullB );
+	const float* nyB = nxB + soaFaceCountB;
+	const float* nzB = nyB + soaFaceCountB;
+
+	b3NegativeTransformFromSoA( &R, xfB.p, nxB, nyB, nzB, soaFaceCountB, bFNx, bFNy, bFNz, false );
+	b3NegativeTransformFromSoA( &R, xfB.p, vxB, vyB, vzB, soaVertexCountB, bWx, bWy, bWz, true );
+
+	// Per B edge data. C and D are the two face normals, v0 a vertex, DC the edge vector.
+	_Alignas( 16 ) float bCx[NE];
+	_Alignas( 16 ) float bCy[NE];
+	_Alignas( 16 ) float bCz[NE];
+	_Alignas( 16 ) float bDx[NE];
+	_Alignas( 16 ) float bDy[NE];
+	_Alignas( 16 ) float bDz[NE];
+	_Alignas( 16 ) float bV0x[NE];
+	_Alignas( 16 ) float bV0y[NE];
+	_Alignas( 16 ) float bV0z[NE];
+	_Alignas( 16 ) float bDCx[NE];
+	_Alignas( 16 ) float bDCy[NE];
+	_Alignas( 16 ) float bDCz[NE];
+
+	int halfEdgeCountB = hullB->edgeCount;
+	const b3HullHalfEdge* halfEdgesB = b3GetHullEdges( hullB );
+	int nb = 0;
+	for ( int i = 0; i < halfEdgeCountB; i += 2 )
+	{
+		const b3HullHalfEdge* edge = halfEdgesB + i;
+		const b3HullHalfEdge* twin = edge + 1;
+		int f0 = edge->face;
+		int f1 = twin->face;
+		int v0 = edge->origin;
+		int v1 = twin->origin;
+
+		bCx[nb] = bFNx[f0];
+		bCy[nb] = bFNy[f0];
+		bCz[nb] = bFNz[f0];
+		bDx[nb] = bFNx[f1];
+		bDy[nb] = bFNy[f1];
+		bDz[nb] = bFNz[f1];
+		bV0x[nb] = bWx[v0];
+		bV0y[nb] = bWy[v0];
+		bV0z[nb] = bWz[v0];
+		bDCx[nb] = bWx[v1] - bWx[v0];
+		bDCy[nb] = bWy[v1] - bWy[v0];
+		bDCz[nb] = bWz[v1] - bWz[v0];
+		nb += 1;
+	}
+
+	// Per A edge data, already in A's space so just gathered. n0 and n1 are the two face
+	// normals, d the edge vector av1-av0, v0 the first vertex. Tol is the
+	// parallel edge tolerance, scaled by the edge length.
+	_Alignas( 16 ) float aN0x[NE];
+	_Alignas( 16 ) float aN0y[NE];
+	_Alignas( 16 ) float aN0z[NE];
+	_Alignas( 16 ) float aN1x[NE];
+	_Alignas( 16 ) float aN1y[NE];
+	_Alignas( 16 ) float aN1z[NE];
+	// dir = av1 - av0
+	_Alignas( 16 ) float aDx[NE];
+	_Alignas( 16 ) float aDy[NE];
+	_Alignas( 16 ) float aDz[NE];
+	_Alignas( 16 ) float aV0x[NE];
+	_Alignas( 16 ) float aV0y[NE];
+	_Alignas( 16 ) float aV0z[NE];
+	_Alignas( 16 ) float aTol[NE];
+
+	int halfEdgeCountA = hullA->edgeCount;
+	const b3HullHalfEdge* halfEdgesA = b3GetHullEdges( hullA );
+	int na = 0;
+
+	float squaredTol = B3_PARALLEL_EDGE_TOL * B3_PARALLEL_EDGE_TOL;
+	for ( int i = 0; i < halfEdgeCountA; i += 2 )
+	{
+		const b3HullHalfEdge* edge = halfEdgesA + i;
+		const b3HullHalfEdge* twin = edge + 1;
+
+		b3Vec3 A = planesA[edge->face].normal;
+		b3Vec3 B = planesA[twin->face].normal;
+		aN0x[na] = A.x;
+		aN0y[na] = A.y;
+		aN0z[na] = A.z;
+		aN1x[na] = B.x;
+		aN1y[na] = B.y;
+		aN1z[na] = B.z;
+
+		int v0 = edge->origin;
+		int v1 = twin->origin;
+
+		aDx[na] = vxA[v1] - vxA[v0];
+		aDy[na] = vyA[v1] - vyA[v0];
+		aDz[na] = vzA[v1] - vzA[v0];
+		aV0x[na] = vxA[v0];
+		aV0y[na] = vyA[v0];
+		aV0z[na] = vzA[v0];
+
+		aTol[na] = squaredTol * ( aDx[na] * aDx[na] + aDy[na] * aDy[na] + aDz[na] * aDz[na] );
+		na += 1;
+	}
+
+	// Zero the tail lanes.
+	b3FloatW zero = b3ZeroW();
+	b3StoreW( aN0x + na, zero );
+	b3StoreW( aN0y + na, zero );
+	b3StoreW( aN0z + na, zero );
+	b3StoreW( aN1x + na, zero );
+	b3StoreW( aN1y + na, zero );
+	b3StoreW( aN1z + na, zero );
+	b3StoreW( aDx + na, zero );
+	b3StoreW( aDy + na, zero );
+	b3StoreW( aDz + na, zero );
+	b3StoreW( aV0x + na, zero );
+	b3StoreW( aV0y + na, zero );
+	b3StoreW( aV0z + na, zero );
+	b3StoreW( aTol + na, zero );
+
+	int edgeCountB = halfEdgeCountB / 2;
+
+#if defined( B3_SIMD_NONE )
+
+	// The SIMD emulated version of this code is very slow. This is a purely scalar version
+	// for platforms that don't have SIMD capability. It is much faster than SIMD emulation.
+	// WARNING: this math needs to match the SIMD version for cross platform determinism.
+
+	const float EPS = -0.0001f;
+
+	for ( int j = 0; j < edgeCountB; ++j )
+	{
+		float Cx = bCx[j];
+		float Cy = bCy[j];
+		float Cz = bCz[j];
+		float Dx = bDx[j];
+		float Dy = bDy[j];
+		float Dz = bDz[j];
+		float DCx = bDCx[j];
+		float DCy = bDCy[j];
+		float DCz = bDCz[j];
+		float bv0x = bV0x[j];
+		float bv0y = bV0y[j];
+		float bv0z = bV0z[j];
+
+		for ( int i = 0; i < na; ++i )
+		{
+			// CBA = C.dir, DBA = D.dir, where dir = B_x_A
+			float CBA = Cx * aDx[i] + ( Cy * aDy[i] + Cz * aDz[i] );
+			float DBA = Dx * aDx[i] + ( Dy * aDy[i] + Dz * aDz[i] );
+			if ( CBA * DBA >= EPS )
+			{
+				continue;
+			}
+
+			// ADC = n0.DC, BDC = n1.DC, where DC = D_x_C
+			float ADC = aN0x[i] * DCx + ( aN0y[i] * DCy + aN0z[i] * DCz );
+			float BDC = aN1x[i] * DCx + ( aN1y[i] * DCy + aN1z[i] * DCz );
+			if ( ADC * BDC >= EPS || CBA * BDC >= EPS )
+			{
+				continue;
+			}
+
+			// Reject near parallel edges
+			float maxCD = b3MaxFloat( CBA * CBA, DBA * DBA );
+			if ( maxCD <= aTol[i] )
+			{
+				continue;
+			}
+
+			// t = -CBA / (DBA - CBA)
+			float t = -CBA / ( DBA - CBA );
+
+			// normal = lerp(t, C, D) = C + (D-C)*t
+			float nx = Cx + t * ( Dx - Cx );
+			float ny = Cy + t * ( Dy - Cy );
+			float nz = Cz + t * ( Dz - Cz );
+			float len2 = nx * nx + ( ny * ny + nz * nz );
+			float inv = 1.0f / sqrtf( len2 );
+			nx *= inv;
+			ny *= inv;
+			nz *= inv;
+
+			// separation = -dot(normal, av0 + bv0)
+			float sx = aV0x[i] + bv0x;
+			float sy = aV0y[i] + bv0y;
+			float sz = aV0z[i] + bv0z;
+
+			float separation = -( sx * nx + ( sy * ny + sz * nz ) );
+			if ( separation > res.edge.separation )
+			{
+				res.edge.normal = (b3Vec3){ nx, ny, nz };
+				res.edge.separation = separation;
+
+				// Half edge index
+				res.edge.indexA = 2 * i;
+				res.edge.indexB = 2 * j;
+
+				if ( separation > speculativeDistance && earlyReturn )
+				{
+					res.separatedFeature = b3_edgePairAxis;
+					return res;
+				}
+			}
+		}
+	}
+
+#else
+
+	// Edge phase, one B edge against four A edges at a time, no transforms in the loop.
+	const b3FloatW EPS = b3SplatW( -0.0001f );
+	const b3FloatW INF = b3SplatW( INFINITY );
+
+	for ( int j = 0; j < edgeCountB; ++j )
+	{
+		const b3FloatW Cx = b3SplatW( bCx[j] );
+		const b3FloatW Cy = b3SplatW( bCy[j] );
+		const b3FloatW Cz = b3SplatW( bCz[j] );
+		const b3FloatW Dx = b3SplatW( bDx[j] );
+		const b3FloatW Dy = b3SplatW( bDy[j] );
+		const b3FloatW Dz = b3SplatW( bDz[j] );
+		const b3FloatW DCx = b3SplatW( bDCx[j] );
+		const b3FloatW DCy = b3SplatW( bDCy[j] );
+		const b3FloatW DCz = b3SplatW( bDCz[j] );
+		const b3FloatW bv0x = b3SplatW( bV0x[j] );
+		const b3FloatW bv0y = b3SplatW( bV0y[j] );
+		const b3FloatW bv0z = b3SplatW( bV0z[j] );
+
+		for ( int i = 0; i < na; i += 4 )
+		{
+			b3FloatW n0x = b3LoadW( aN0x + i );
+			b3FloatW n0y = b3LoadW( aN0y + i );
+			b3FloatW n0z = b3LoadW( aN0z + i );
+			b3FloatW n1x = b3LoadW( aN1x + i );
+			b3FloatW n1y = b3LoadW( aN1y + i );
+			b3FloatW n1z = b3LoadW( aN1z + i );
+			b3FloatW dx = b3LoadW( aDx + i );
+			b3FloatW dy = b3LoadW( aDy + i );
+			b3FloatW dz = b3LoadW( aDz + i );
+			b3FloatW v0x = b3LoadW( aV0x + i );
+			b3FloatW v0y = b3LoadW( aV0y + i );
+			b3FloatW v0z = b3LoadW( aV0z + i );
+			b3FloatW tol = b3LoadW( aTol + i );
+
+			// CBA = C.dir, DBA = D.dir, where dir = B_x_A
+			b3FloatW CBA = b3Dot3W( Cx, Cy, Cz, dx, dy, dz );
+			b3FloatW DBA = b3Dot3W( Dx, Dy, Dz, dx, dy, dz );
+			// ADC = n0.DC, BDC = n1.DC, where DC = D_x_C
+			b3FloatW ADC = b3Dot3W( n0x, n0y, n0z, DCx, DCy, DCz );
+			b3FloatW BDC = b3Dot3W( n1x, n1y, n1z, DCx, DCy, DCz );
+
+			// Gauss map arc crossing test, CBA*DBA<eps and ADC*BDC<eps and CBA*BDC<eps
+			b3FloatW m1 = b3LessThanW( b3MulW( CBA, DBA ), EPS );
+			b3FloatW m2 = b3LessThanW( b3MulW( ADC, BDC ), EPS );
+			b3FloatW m3 = b3LessThanW( b3MulW( CBA, BDC ), EPS );
+
+			// Reject near parallel edges. The arc lerp is ill conditioned when both of B's normals are nearly
+			// perpendicular to edge A, a scale invariant sine threshold relative to the edge length.
+			b3FloatW maxCD = b3MaxW( b3MulW( CBA, CBA ), b3MulW( DBA, DBA ) );
+			b3FloatW notParallel = b3GreaterThanW( maxCD, tol );
+			b3FloatW mask = b3AndW( b3AndW( m1, m2 ), b3AndW( m3, notParallel ) );
+
+			// Most A-edges fail the Gauss test, so skip the divide, sqrt and support work when no
+			// lane passed.
+			if ( b3AnyTrueW( mask ) == false )
+			{
+				continue;
+			}
+
+			// t = -CBA / (DBA - CBA)
+			b3FloatW t = b3DivW( b3SubW( zero, CBA ), b3SubW( DBA, CBA ) );
+
+			// normal = lerp(t, C, D) = C + (D-C)*t
+			b3FloatW nx = b3MulAddW( Cx, t, b3SubW( Dx, Cx ) );
+			b3FloatW ny = b3MulAddW( Cy, t, b3SubW( Dy, Cy ) );
+			b3FloatW nz = b3MulAddW( Cz, t, b3SubW( Dz, Cz ) );
+
+			// normalize
+			b3FloatW len2 = b3Dot3W( nx, ny, nz, nx, ny, nz );
+			b3FloatW inv = b3DivW( b3SplatW( 1.0f ), b3SqrtW( len2 ) );
+			nx = b3MulW( nx, inv );
+			ny = b3MulW( ny, inv );
+			nz = b3MulW( nz, inv );
+
+			// support = dot(normal, av0 + bv0)
+			b3FloatW sx = b3AddW( v0x, bv0x );
+			b3FloatW sy = b3AddW( v0y, bv0y );
+			b3FloatW sz = b3AddW( v0z, bv0z );
+			b3FloatW support = b3Dot3W( sx, sy, sz, nx, ny, nz );
+
+			// Lanes that fail the Gauss test can never win.
+			support = b3BlendW( INF, support, mask );
+			b3FloatW separation = b3SubW( zero, support );
+
+			// Test all 4 supports against the running best at once. If none beats it, skip the
+			// store and scalar reduction. res->support only turns negative just before returning,
+			// so this never skips a lane that would trigger the early out.
+			b3FloatW improves = b3GreaterThanW( separation, b3SplatW( res.edge.separation ) );
+			if ( b3AnyTrueW( improves ) == false )
+			{
+				continue;
+			}
+
+			_Alignas( 16 ) float sA[4];
+			_Alignas( 16 ) float nxA[4];
+			_Alignas( 16 ) float nyA[4];
+			_Alignas( 16 ) float nzA[4];
+			b3StoreW( sA, separation );
+			b3StoreW( nxA, nx );
+			b3StoreW( nyA, ny );
+			b3StoreW( nzA, nz );
+
+			// Reduce in lane order so ties keep the first edge and the early out takes the first
+			// improving support below zero. Padded tail lanes carry +INF support, so they never
+			// update or index a->edges out of range.
+			for ( int lane = 0; lane < 4; lane++ )
+			{
+				int ei = i + lane;
+				float s = sA[lane];
+				if ( s > res.edge.separation )
+				{
+					res.edge.normal = (b3Vec3){ nxA[lane], nyA[lane], nzA[lane] };
+					res.edge.separation = s;
+
+					// Half edge index
+					res.edge.indexA = 2 * ei;
+					res.edge.indexB = 2 * j;
+
+					if ( s > speculativeDistance && earlyReturn )
+					{
+						res.separatedFeature = b3_edgePairAxis;
+						return res;
+					}
+				}
+			}
+		}
+	}
+#endif
+
+	return res;
+}
+
+#undef NE
+#undef NF
+#undef NV
+
+#define B3_SIMD_COLLIDE_HULLS 1
+
+#if B3_SIMD_COLLIDE_HULLS == 1
+
+void b3CollideHulls( b3LocalManifold* manifold, int capacity, const b3HullData* hullA, const b3HullData* hullB,
+					 b3Transform transformBtoA, b3SATCache* cache )
+{
+	manifold->pointCount = 0;
+
+	if ( capacity < 4 )
+	{
+		return;
+	}
+
+	// Work in shapeA coordinates
+	float speculativeDistance = B3_SPECULATIVE_DISTANCE;
+
+	float linearSlop = B3_LINEAR_SLOP;
+	const b3HullHalfEdge* edgesA = b3GetHullEdges( hullA );
+	const b3Plane* planesA = b3GetHullPlanes( hullA );
+	const b3Vec3* pointsA = b3GetHullPoints( hullA );
+
+	const b3HullHalfEdge* edgesB = b3GetHullEdges( hullB );
+	const b3Plane* planesB = b3GetHullPlanes( hullB );
+	const b3Vec3* pointsB = b3GetHullPoints( hullB );
+
+	cache->hit = 0;
+
+	// Attempt to use the cache to speed up collision
+	switch ( cache->type )
+	{
+		case b3_invalidAxis:
+			break;
+
+		case b3_faceAxisA:
+		{
+			B3_ASSERT( cache->indexA < hullA->faceCount );
+
+			// Check for separation using cached face
+			b3Plane plane = planesA[cache->indexA];
+			b3Vec3 searchDirectionInB = b3Neg( b3InvRotateVector( transformBtoA.q, plane.normal ) );
+
+			// todo use b3GetSupportWide
+			int vertexIndex = b3FindHullSupportVertex( hullB, searchDirectionInB );
+			b3Vec3 support = b3TransformPoint( transformBtoA, pointsB[vertexIndex] );
+			float separation = b3PlaneSeparation( plane, support );
+
+			if ( separation >= speculativeDistance )
+			{
+				// Cache hit, shapes are separated
+				cache->hit = 1;
+				return;
+			}
+
+			// Attempt face contact using cached feature
+			b3SeparatingAxis faceQuery;
+			faceQuery.normal = plane.normal;
+			faceQuery.separation = 0.0f;
+			faceQuery.indexA = cache->indexA;
+			faceQuery.indexB = vertexIndex;
+			faceQuery.type = b3_faceAxisA;
+
+			b3SATCache localCache = { 0 };
+			bool touching = b3BuildFaceAContact( manifold, capacity, hullA, hullB, transformBtoA, faceQuery, &localCache );
+			if ( touching == true && b3AbsFloat( cache->separation - localCache.separation ) < linearSlop )
+			{
+				// Cache hit, contact points generated
+				cache->hit = 1;
+				return;
+			}
+		}
+		break;
+
+		case b3_faceAxisB:
+		{
+			B3_ASSERT( cache->indexB < hullB->faceCount );
+
+			// Check for separation using cached face
+			b3Plane plane = planesB[cache->indexB];
+			b3Vec3 searchDirectionInA = b3Neg( b3RotateVector( transformBtoA.q, plane.normal ) );
+
+			// todo use b3GetSupportWide
+			int vertexIndex = b3FindHullSupportVertex( hullA, searchDirectionInA );
+			b3Vec3 support = b3InvTransformPoint( transformBtoA, pointsA[vertexIndex] );
+			float separation = b3PlaneSeparation( plane, support );
+
+			if ( separation >= speculativeDistance )
+			{
+				// Cache hit, shapes are separated
+				cache->hit = 1;
+				return;
+			}
+
+			// Attempt face contact using cached feature
+			b3SeparatingAxis faceQuery;
+			faceQuery.normal = b3Neg( plane.normal );
+			faceQuery.separation = 0.0f;
+			faceQuery.indexA = vertexIndex;
+			faceQuery.indexB = cache->indexB;
+			faceQuery.type = b3_faceAxisB;
+
+			b3SATCache localCache = { 0 };
+			bool touching = b3BuildFaceBContact( manifold, capacity, hullA, hullB, transformBtoA, faceQuery, &localCache );
+			if ( touching == true && b3AbsFloat( cache->separation - localCache.separation ) < linearSlop )
+			{
+				// Cache hit, contact points generated
+				cache->hit = 1;
+				return;
+			}
+		}
+		break;
+
+		case b3_edgePairAxis:
+		{
+			int indexA = cache->indexA;
+			const b3HullHalfEdge* edge1 = edgesA + indexA;
+			const b3HullHalfEdge* twin1 = edgesA + indexA + 1;
+			B3_ASSERT( edge1->twin == indexA + 1 && twin1->twin == indexA );
+
+			b3Vec3 pA = pointsA[edge1->origin];
+			b3Vec3 qA = pointsA[twin1->origin];
+			b3Vec3 eA = b3Sub( qA, pA );
+
+			b3Vec3 uA = planesA[edge1->face].normal;
+			b3Vec3 vA = planesA[twin1->face].normal;
+
+			int indexB = cache->indexB;
+			const b3HullHalfEdge* edge2 = edgesB + indexB;
+			const b3HullHalfEdge* twin2 = edgesB + indexB + 1;
+			B3_ASSERT( edge2->twin == indexB + 1 && twin2->twin == indexB );
+
+			b3Vec3 pB = b3TransformPoint( transformBtoA, pointsB[edge2->origin] );
+			b3Vec3 qB = b3TransformPoint( transformBtoA, pointsB[twin2->origin] );
+			b3Vec3 eB = b3Sub( qB, pB );
+
+			b3Vec3 uB = b3RotateVector( transformBtoA.q, planesB[edge2->face].normal );
+			b3Vec3 vB = b3RotateVector( transformBtoA.q, planesB[twin2->face].normal );
+
+			// flipping the signs of u2 and v2
+			// cross(v2, u2) == cross(-v2, -u2)
+			// so we still use -e2
+			// but we can also use e1 = cross(u1, v1) and e2 = cross(u2, v2)
+			float cba = b3Dot( uB, eA );
+			float dba = b3Dot( vB, eA );
+			float adc = -b3Dot( uA, eB );
+			float bdc = -b3Dot( vA, eB );
+
+			if ( cba * dba < 0.0f && adc * bdc < 0.0f && cba * bdc > 0.0f )
+			{
+				// Avoid nearly parallel edges that may lead to invalid separation values at the noise floor.
+				float squaredTolerance = B3_PARALLEL_EDGE_TOL * B3_PARALLEL_EDGE_TOL;
+				if ( b3MaxFloat( cba * cba, dba * dba ) >= squaredTolerance * b3LengthSquared( eA ) )
+				{
+					// Transform reference center of the first hull into local space of the second hull
+					float t = cba / ( cba - dba );
+					b3Vec3 axis = b3Lerp( uB, vB, t );
+					B3_VALIDATE( b3LengthSquared( axis ) > 1000.0f * FLT_MIN );
+					axis = b3Normalize( axis );
+					float separation = b3Dot( axis, b3Sub( qA, qB ) );
+
+					if ( separation > speculativeDistance )
+					{
+						// Cache hit, shapes are separated
+						cache->hit = 1;
+						return;
+					}
+
+					// Try to rebuild contact from last features
+					b3SeparatingAxis edgeQuery = { 0 };
+					edgeQuery.normal = b3Neg( axis );
+					edgeQuery.separation = 0.0f;
+					edgeQuery.indexA = cache->indexA;
+					edgeQuery.indexB = cache->indexB;
+					edgeQuery.type = b3_edgePairAxis;
+
+					b3SATCache localCache = { 0 };
+					bool touching = b3BuildEdgeContact( manifold, hullA, hullB, transformBtoA, edgeQuery, &localCache );
+
+					// This separation tolerance may have a big impact on performance in some benchmarks.
+					if ( touching && b3AbsFloat( cache->separation - localCache.separation ) < linearSlop )
+					{
+						// Cache hit, contact point generated
+						cache->hit = 1;
+						return;
+					}
+				}
+			}
+		}
+		break;
+
+			// This case is for testing
+		case b3_manualFaceAxisA:
+		{
+			b3AxisQuery axisQuery = b3ComputeSeparatingAxis( hullA, hullB, transformBtoA, false );
+			b3SeparatingAxis faceQuery = axisQuery.faceA;
+			b3BuildFaceAContact( manifold, capacity, hullA, hullB, transformBtoA, faceQuery, cache );
+			return;
+		}
+
+			// This case is for testing
+		case b3_manualFaceAxisB:
+		{
+			b3AxisQuery axisQuery = b3ComputeSeparatingAxis( hullA, hullB, transformBtoA, false );
+			b3SeparatingAxis faceQuery = axisQuery.faceB;
+			b3BuildFaceBContact( manifold, capacity, hullA, hullB, transformBtoA, faceQuery, cache );
+			return;
+		}
+
+			// This case is for testing
+		case b3_manualEdgePairAxis:
+		{
+			b3AxisQuery axisQuery = b3ComputeSeparatingAxis( hullA, hullB, transformBtoA, false );
+			b3SeparatingAxis edgeQuery = axisQuery.edge;
+			if ( edgeQuery.indexA != B3_NULL_INDEX )
+			{
+				b3BuildEdgeContact( manifold, hullA, hullB, transformBtoA, edgeQuery, cache );
+			}
+			return;
+		}
+
+		default:
+			B3_ASSERT( false );
+			break;
+	}
+
+	manifold->pointCount = 0;
+	*cache = (b3SATCache){ 0 };
+
+	b3AxisQuery axisQuery = b3ComputeSeparatingAxis( hullA, hullB, transformBtoA, true );
+
+	if ( axisQuery.separatedFeature != b3_invalidAxis )
+	{
+		// We found a separating axis
+		cache->type = axisQuery.separatedFeature;
+
+		if ( axisQuery.separatedFeature == b3_faceAxisA )
+		{
+			B3_VALIDATE( axisQuery.faceA.separation > speculativeDistance );
+			cache->separation = axisQuery.faceA.separation;
+			cache->indexA = (uint8_t)axisQuery.faceA.indexA;
+			cache->indexB = (uint8_t)axisQuery.faceA.indexB;
+		}
+		else if ( axisQuery.separatedFeature == b3_faceAxisB )
+		{
+			B3_VALIDATE( axisQuery.faceB.separation > speculativeDistance );
+			cache->separation = axisQuery.faceB.separation;
+			cache->indexA = (uint8_t)axisQuery.faceB.indexA;
+			cache->indexB = (uint8_t)axisQuery.faceB.indexB;
+		}
+		else
+		{
+			B3_ASSERT( axisQuery.separatedFeature == b3_edgePairAxis );
+			B3_VALIDATE( axisQuery.edge.separation > speculativeDistance );
+			cache->separation = axisQuery.edge.separation;
+			cache->indexA = (uint8_t)axisQuery.edge.indexA;
+			cache->indexB = (uint8_t)axisQuery.edge.indexB;
+		}
+		return;
+	}
+
+	B3_VALIDATE( axisQuery.faceA.separation <= speculativeDistance || axisQuery.faceB.separation <= speculativeDistance ||
+				 axisQuery.edge.separation <= speculativeDistance );
+
+	if ( axisQuery.faceA.separation > axisQuery.faceB.separation )
+	{
+		b3SeparatingAxis faceQuery = axisQuery.faceA;
+		B3_VALIDATE( 0 <= faceQuery.indexA && faceQuery.indexA < hullA->faceCount );
+		B3_VALIDATE( 0 <= faceQuery.indexB && faceQuery.indexB < hullB->vertexCount );
+
+		// Face contact A
+		b3BuildFaceAContact( manifold, capacity, hullA, hullB, transformBtoA, faceQuery, cache );
+
+		B3_VALIDATE( cache->indexA < hullA->faceCount );
+		B3_VALIDATE( cache->indexB < hullB->vertexCount );
+	}
+	else
+	{
+		b3SeparatingAxis faceQuery = axisQuery.faceB;
+		B3_VALIDATE( 0 <= faceQuery.indexA && faceQuery.indexA < hullA->vertexCount );
+		B3_VALIDATE( 0 <= faceQuery.indexB && faceQuery.indexB < hullB->faceCount );
+
+		// Face contact B
+		b3BuildFaceBContact( manifold, capacity, hullA, hullB, transformBtoA, faceQuery, cache );
+
+		B3_VALIDATE( cache->indexA < hullA->vertexCount );
+		B3_VALIDATE( cache->indexB < hullB->faceCount );
+	}
+
+	b3SeparatingAxis edgeQuery = axisQuery.edge;
+
+	if ( edgeQuery.indexA == B3_NULL_INDEX )
+	{
+		// There are no valid edge pairs (all edges parallel)
+		return;
+	}
+
+	float clipSeparation = cache->separation;
+	float edgeTol = linearSlop;
+
+	// Face contact can be empty if it does not realize the axis of minimum penetration.
+	// Create edge contact if face contact fails or edge contact is significantly better!
+	if ( manifold->pointCount == 0 || edgeQuery.separation > clipSeparation + edgeTol )
+	{
+		B3_ASSERT( 0 <= edgeQuery.indexA && edgeQuery.indexA < hullA->edgeCount );
+		B3_ASSERT( 0 <= edgeQuery.indexB && edgeQuery.indexB < hullB->edgeCount );
+
+		// Edge contact
+		b3LocalManifold edgeManifold = { 0 };
+		b3LocalManifoldPoint edgePoint = { 0 };
+		edgeManifold.points = &edgePoint;
+
+		b3SATCache edgeCache = { 0 };
+		b3BuildEdgeContact( &edgeManifold, hullA, hullB, transformBtoA, edgeQuery, &edgeCache );
+
+		// It is possible with speculation to have vertex-vertex collision that is missed by SAT,
+		// so edge contact yields no points. In that case perhaps the face contact has some points.
+		if ( edgeManifold.pointCount == 1 )
+		{
+			// Copy edge manifold out, being careful to preserve manifold point buffer.
+			b3LocalManifoldPoint* points = manifold->points;
+			*manifold = edgeManifold;
+			manifold->points = points;
+			manifold->points[0] = edgePoint;
+			*cache = edgeCache;
+		}
+	}
+}
+
+#else
+
+// todo this code has gone stale, will be deleted soon
+
+typedef struct b3FaceQuery
+{
+	float separation;
+	int faceIndex;
+	int vertexIndex;
+} b3FaceQuery;
+
+typedef struct b3EdgeQuery
+{
+	b3Vec3 normal;
+	float separation;
+	int indexA;
+	int indexB;
+} b3EdgeQuery;
+
+// Old non-SIMD version. Keeping this for testing and comparisons
+
+static b3FaceQuery b3QueryFaceDirections( const b3HullData* hullA, const b3HullData* hullB, b3Transform relativeTransform )
+{
+	// We perform all computations in local space of the second hull
+	b3Transform transform = b3InvertTransform( relativeTransform );
+	const b3Plane* planesA = b3GetHullPlanes( hullA );
+	const b3Vec3* pointsB = b3GetHullPoints( hullB );
+
+	int maxFaceIndex = -1;
+	int maxVertexIndex = -1;
+	float maxFaceSeparation = -FLT_MAX;
+	float speculativeDistance = B3_SPECULATIVE_DISTANCE;
+
+	for ( int faceIndex = 0; faceIndex < hullA->faceCount; ++faceIndex )
+	{
+		b3Plane plane = b3TransformPlane( transform, planesA[faceIndex] );
+		int vertexIndex = b3FindHullSupportVertex( hullB, b3Neg( plane.normal ) );
+		b3Vec3 support = pointsB[vertexIndex];
+
+		float separation = b3PlaneSeparation( plane, support );
+		if ( separation > maxFaceSeparation )
+		{
+			maxFaceIndex = faceIndex;
+			maxVertexIndex = vertexIndex;
+			maxFaceSeparation = separation;
+
+			if ( separation >= speculativeDistance )
+			{
+				return (b3FaceQuery){
+					.separation = maxFaceSeparation,
+					.faceIndex = (uint8_t)maxFaceIndex,
+					.vertexIndex = (uint8_t)maxVertexIndex,
+				};
+			}
+		}
+	}
+
+	return (b3FaceQuery){
+		.separation = maxFaceSeparation,
+		.faceIndex = (uint8_t)maxFaceIndex,
+		.vertexIndex = (uint8_t)maxVertexIndex,
+	};
+}
+
+static b3EdgeQuery b3QueryEdgeDirections( const b3HullData* hullA, const b3HullData* hullB, b3Transform transformBtoA )
+{
+	// Find axis of minimum penetration
+	b3Vec3 maxNormal = b3Vec3_zero;
+	float maxSeparation = -FLT_MAX;
+	int maxIndexA = B3_NULL_INDEX;
+	int maxIndexB = B3_NULL_INDEX;
+
+	const b3HullHalfEdge* edgesA = b3GetHullEdges( hullA );
+	const b3Vec3* pointsA = b3GetHullPoints( hullA );
+	const b3Plane* planesA = b3GetHullPlanes( hullA );
+	const b3HullHalfEdge* edgesB = b3GetHullEdges( hullB );
+	const b3Vec3* pointsB = b3GetHullPoints( hullB );
+	const b3Plane* planesB = b3GetHullPlanes( hullB );
+
+	// Work in frame A
+	b3Matrix3 matrix = b3MakeMatrixFromQuat( transformBtoA.q );
+	float speculativeDistance = B3_SPECULATIVE_DISTANCE;
+	float squaredTolerance = B3_PARALLEL_EDGE_TOL * B3_PARALLEL_EDGE_TOL;
+
+	// Arranged to minimize transform operations
+	for ( int indexB = 0; indexB < hullB->edgeCount; indexB += 2 )
+	{
+		const b3HullHalfEdge* edgeB = edgesB + indexB;
+		const b3HullHalfEdge* twinB = edgesB + indexB + 1;
+		B3_ASSERT( edgeB->twin == indexB + 1 && twinB->twin == indexB );
+
+		b3Vec3 qB = pointsB[twinB->origin];
+		b3Vec3 eB = b3MulMV( matrix, b3Sub( qB, pointsB[edgeB->origin] ) );
+		qB = b3Add( b3MulMV( matrix, qB ), transformBtoA.p );
+
+		b3Vec3 uB = b3MulMV( matrix, planesB[edgeB->face].normal );
+		b3Vec3 vB = b3MulMV( matrix, planesB[twinB->face].normal );
+
+		for ( int indexA = 0; indexA < hullA->edgeCount; indexA += 2 )
+		{
+			const b3HullHalfEdge* edgeA = edgesA + indexA;
+			const b3HullHalfEdge* twinA = edgesA + indexA + 1;
+			B3_ASSERT( edgeA->twin == indexA + 1 && twinA->twin == indexA );
+
+			b3Vec3 qA = pointsA[twinA->origin];
+			b3Vec3 eA = b3Sub( qA, pointsA[edgeA->origin] );
+			b3Vec3 uA = planesA[edgeA->face].normal;
+			b3Vec3 vA = planesA[twinA->face].normal;
+
+			// See "Collision Detection of Convex Polyhedra Based on Duality Transformation"
+			// Two edges build a face on the Minkowski sum if the associated arcs AB and CD intersect on the Gauss map.
+			// The associated arcs are defined by the adjacent face normals of each edge.
+
+			// These are signed volumes with an edge optimization to avoid cross products
+			// eA parallel to cross(vA, uA)
+			// eB parallel to cross(vB, uB)
+			// Since only signs are tested, length doesn't matter.
+
+			float cba = b3Dot( uB, eA );
+			float dba = b3Dot( vB, eA );
+			float adc = -b3Dot( uA, eB );
+			float bdc = -b3Dot( vA, eB );
+
+			if ( cba * dba < 0.0f && adc * bdc < 0.0f && cba * bdc > 0.0f )
+			{
+				// Avoid nearly parallel edges that may lead to invalid separation values at the noise floor.
+				if ( b3MaxFloat( cba * cba, dba * dba ) < squaredTolerance * b3LengthSquared( eA ) )
+				{
+					continue;
+				}
+
+				// The intersection of the arcs on the Gauss map is the edge pair axis. Cast the
+				// arc of hull B (from uB to vB) against the plane containing the arc of hull A:
+				// dot(uB + t * (vB - uB), eA) == 0
+				// then
+				// t = cba / (cba - dba)
+				//
+				// The signs of cba and dba differ (Minkowski test), so the division is safe.
+				//
+				// The axis generated points from B to A by construction since it lands between
+				// two face normals on B. This removes the need to orient the separation axis
+				// using the hull centers.
+				//
+				// The axis is perpendicular to both edges so I can use qA and qB as arbitrary
+				// points on edgeA and edgeB to measure the separation.
+				float t = cba / ( cba - dba );
+				b3Vec3 axis = b3Lerp( uB, vB, t );
+				B3_VALIDATE( b3LengthSquared( axis ) > 1000.0f * FLT_MIN );
+				axis = b3Normalize( axis );
+				float separation = b3Dot( axis, b3Sub( qA, qB ) );
+
+				if ( separation > maxSeparation )
+				{
+					// Continues to find the maximum separating axis
+					// Flip normal so it points from A to B
+					maxNormal = b3Neg( axis );
+					maxSeparation = separation;
+					maxIndexA = indexA;
+					maxIndexB = indexB;
+
+					if ( separation >= speculativeDistance )
+					{
+						// Cache hit, shapes are separated
+						return (b3EdgeQuery){
+							.normal = maxNormal,
+							.separation = maxSeparation,
+							.indexA = maxIndexA,
+							.indexB = maxIndexB,
+						};
+					}
+				}
+			}
+		}
+	}
+
+	return (b3EdgeQuery){
+		.normal = maxNormal,
+		.separation = maxSeparation,
+		.indexA = maxIndexA,
+		.indexB = maxIndexB,
+	};
+}
+
+void b3CollideHulls( b3LocalManifold* manifold, int capacity, const b3HullData* hullA, const b3HullData* hullB,
+					 b3Transform transformBtoA, b3SATCache* cache )
 {
 	manifold->pointCount = 0;
 
@@ -1405,55 +2382,64 @@ void b3CollideHulls( b3LocalManifold* manifold, int capacity, const b3HullData*
 
 		case b3_edgePairAxis:
 		{
-			int index1 = cache->indexA;
-			const b3HullHalfEdge* edge1 = edgesA + index1;
-			const b3HullHalfEdge* twin1 = edgesA + index1 + 1;
-			B3_ASSERT( edge1->twin == index1 + 1 && twin1->twin == index1 );
+			int indexA = cache->indexA;
+			const b3HullHalfEdge* edge1 = edgesA + indexA;
+			const b3HullHalfEdge* twin1 = edgesA + indexA + 1;
+			B3_ASSERT( edge1->twin == indexA + 1 && twin1->twin == indexA );
 
-			b3Vec3 p1 = pointsA[edge1->origin];
-			b3Vec3 q1 = pointsA[twin1->origin];
-			b3Vec3 e1 = b3Sub( q1, p1 );
+			b3Vec3 pA = pointsA[edge1->origin];
+			b3Vec3 qA = pointsA[twin1->origin];
+			b3Vec3 eA = b3Sub( qA, pA );
 
-			b3Vec3 u1 = planesA[edge1->face].normal;
-			b3Vec3 v1 = planesA[twin1->face].normal;
+			b3Vec3 uA = planesA[edge1->face].normal;
+			b3Vec3 vA = planesA[twin1->face].normal;
 
-			int index2 = cache->indexB;
-			const b3HullHalfEdge* edge2 = edgesB + index2;
-			const b3HullHalfEdge* twin2 = edgesB + index2 + 1;
-			B3_ASSERT( edge2->twin == index2 + 1 && twin2->twin == index2 );
+			int indexB = cache->indexB;
+			const b3HullHalfEdge* edge2 = edgesB + indexB;
+			const b3HullHalfEdge* twin2 = edgesB + indexB + 1;
+			B3_ASSERT( edge2->twin == indexB + 1 && twin2->twin == indexB );
 
-			b3Vec3 p2 = b3TransformPoint( transformBtoA, pointsB[edge2->origin] );
-			b3Vec3 q2 = b3TransformPoint( transformBtoA, pointsB[twin2->origin] );
-			b3Vec3 e2 = b3Sub( q2, p2 );
+			b3Vec3 pB = b3TransformPoint( transformBtoA, pointsB[edge2->origin] );
+			b3Vec3 qB = b3TransformPoint( transformBtoA, pointsB[twin2->origin] );
+			b3Vec3 eB = b3Sub( qB, pB );
 
-			b3Vec3 u2 = b3RotateVector( transformBtoA.q, planesB[edge2->face].normal );
-			b3Vec3 v2 = b3RotateVector( transformBtoA.q, planesB[twin2->face].normal );
+			b3Vec3 uB = b3RotateVector( transformBtoA.q, planesB[edge2->face].normal );
+			b3Vec3 vB = b3RotateVector( transformBtoA.q, planesB[twin2->face].normal );
 
 			// flipping the signs of u2 and v2
 			// cross(v2, u2) == cross(-v2, -u2)
 			// so we still use -e2
 			// but we can also use e1 = cross(u1, v1) and e2 = cross(u2, v2)
-			bool isMinkowski = b3IsMinkowskiFace( u1, v1, e1, b3Neg( u2 ), b3Neg( v2 ), e2 );
-			if ( isMinkowski == true )
+			float cba = b3Dot( uB, eA );
+			float dba = b3Dot( vB, eA );
+			float adc = -b3Dot( uA, eB );
+			float bdc = -b3Dot( vA, eB );
+
+			if ( cba * dba < 0.0f && adc * bdc < 0.0f && cba * bdc > 0.0f )
 			{
-				// Transform reference center of the first hull into local space of the second hull
-				b3Vec3 c1 = hullA->center;
-				b3Vec3 c2 = b3TransformPoint( transformBtoA, hullB->center );
-
-				float separation = b3EdgeEdgeSeparation( p1, e1, c1, p2, e2, c2 );
-				if ( separation > speculativeDistance )
+				// Avoid nearly parallel edges that may lead to invalid separation values at the noise floor.
+				float squaredTolerance = B3_PARALLEL_EDGE_TOL * B3_PARALLEL_EDGE_TOL;
+				if ( b3MaxFloat( cba * cba, dba * dba ) >= squaredTolerance * b3LengthSquared( eA ) )
 				{
-					// Cache hit, shapes are separated
-					return;
-				}
+					// Transform reference center of the first hull into local space of the second hull
+					float t = cba / ( cba - dba );
+					b3Vec3 axis = b3Lerp( uB, vB, t );
+					B3_VALIDATE( b3LengthSquared( axis ) > 1000.0f * FLT_MIN );
+					axis = b3Normalize( axis );
+					float separation = b3Dot( axis, b3Sub( qA, qB ) );
+
+					if ( separation > speculativeDistance )
+					{
+						// Cache hit, shapes are separated
+						return;
+					}
 
-				// if ( cache->separation <= speculativeDistance )
-				{
 					// Try to rebuild contact from last features
-					b3EdgeQuery edgeQuery;
+					b3EdgeQuery edgeQuery = { 0 };
+					edgeQuery.normal = b3Neg( axis );
+					edgeQuery.separation = 0.0f;
 					edgeQuery.indexA = cache->indexA;
 					edgeQuery.indexB = cache->indexB;
-					edgeQuery.separation = 0.0f;
 
 					b3SATCache localCache = { 0 };
 					bool touching = b3BuildEdgeContact( manifold, hullA, hullB, transformBtoA, edgeQuery, &localCache );
@@ -1598,3 +2584,5 @@ void b3CollideHulls( b3LocalManifold* manifold, int capacity, const b3HullData*
 		}
 	}
 }
+
+#endif
diff --git a/vendor/box3d/src/src/core.h b/vendor/box3d/src/src/core.h
index 3aaf196b1..005e2d6ac 100644
--- a/vendor/box3d/src/src/core.h
+++ b/vendor/box3d/src/src/core.h
@@ -57,7 +57,12 @@
 		#define B3_SIMD_WIDTH 4
 		//#pragma message("B3_SIMD_SSE2")
 	#elif defined( B3_CPU_ARM )
+	// ARMv7 Neon doesn't have divide or sqrt so cannot be used.
+	#if defined( __aarch64__ ) || defined( _M_ARM64 )
 		#define B3_SIMD_NEON
+	#else
+		#define B3_SIMD_NONE
+	#endif
 		#define B3_SIMD_WIDTH 4
 		//#pragma message("B3_SIMD_NEON")
 	#elif defined( B3_CPU_WASM )
@@ -132,6 +137,7 @@ void* b3AllocZeroed( size_t size );
 void b3Free( void* mem, size_t size );
 void* b3GrowAlloc( void* oldMem, int oldSize, int newSize );
 
+B3_PRINTF_FORMAT( 1, 2 )
 void b3Log( const char* format, ... );
 
 // Geometry content hashes reserve zero to mean unhashed
diff --git a/vendor/box3d/src/src/height_field.c b/vendor/box3d/src/src/height_field.c
index 1b0307fe9..69c2474e9 100644
--- a/vendor/box3d/src/src/height_field.c
+++ b/vendor/box3d/src/src/height_field.c
@@ -749,7 +749,7 @@ b3CastOutput b3ShapeCastHeightField( const b3HeightFieldData* heightField, const
 	// nextFractionX / nextFractionZ advance in units of the clamped sweep
 	// [minFraction, maxFraction], but bestFraction is a fraction of the full input
 	// translation. Precompute the affine map from clamped space to input space so
-	// the loop termination test compares like with like — otherwise it can exit
+	// the loop termination test compares like with like. Otherwise it can exit
 	// early and miss a closer hit in a later cell.
 	float gridFractionScale = input->maxFraction * ( maxFraction - minFraction );
 	float gridFractionOffset = input->maxFraction * minFraction;
@@ -1382,7 +1382,7 @@ b3HeightFieldData* b3CreateGrid( int rowCount, int columnCount, b3Vec3 scale, bo
 }
 
 b3HeightFieldData* b3CreateWave( int rowCount, int columnCount, b3Vec3 scale, float rowFrequency, float columnFrequency,
-							 bool makeHoles )
+								 bool makeHoles )
 {
 	int heightCount = rowCount * columnCount;
 	float* heights = (float*)b3Alloc( heightCount * sizeof( float ) );
@@ -1390,14 +1390,18 @@ b3HeightFieldData* b3CreateWave( int rowCount, int columnCount, b3Vec3 scale, fl
 	float omegaZ = 2.0f * B3_PI * rowFrequency;
 	float omegaX = 2.0f * B3_PI * columnFrequency;
 
+	b3CosSin cs = { 0 };
+
 	for ( int i = 0; i < rowCount; ++i )
 	{
-		float rowHeight = sinf( omegaZ * i );
+		cs = b3ComputeCosSin( omegaZ * i );
+		float rowHeight = cs.sine;
 
 		for ( int j = 0; j < columnCount; ++j )
 		{
 			int k = i * columnCount + j;
-			float columnHeight = sinf( omegaX * j );
+			cs = b3ComputeCosSin( omegaX * j );
+			float columnHeight = cs.sine;
 			heights[k] = rowHeight * columnHeight;
 		}
 	}
diff --git a/vendor/box3d/src/src/hull.c b/vendor/box3d/src/src/hull.c
index 75bace9f9..ea3ed7532 100644
--- a/vendor/box3d/src/src/hull.c
+++ b/vendor/box3d/src/src/hull.c
@@ -4,7 +4,7 @@
 // Dirk Gregorius contributed portions of this code
 
 #include "algorithm.h"
-#include "hull_map.h"
+#include "hull.h"
 #include "math_internal.h"
 #include "shape.h"
 
@@ -26,8 +26,8 @@
 #define B3_MARK_VISIBLE 0
 #define B3_MARK_DELETE 1
 
-// Final hull is index-encoded with uint8_t, so vertex/edge/face counts are capped at UINT8_MAX.
-#define B3_HULL_LIMIT UINT8_MAX
+// Final hull is index-encoded with uint8_t, so vertex/edge/face counts are capped at 256.
+#define B3_HULL_MAX_COUNT ( UINT8_MAX + 1 )
 
 typedef struct b3QHListNode
 {
@@ -120,12 +120,16 @@ typedef struct b3HullBuilder
 	b3QHHalfEdge* edgeBase;
 	int edgeCapacity;
 	int edgeCount;
-	b3QHHalfEdge* edgeFreeHead; // LIFO free list; overlays edge->next
+
+	// LIFO free list. Built with edge->next.
+	b3QHHalfEdge* edgeFreeHead;
 
 	b3QHFace* faceBase;
 	int faceCapacity;
 	int faceCount;
-	b3QHFace* faceFreeHead; // LIFO free list; overlays face->link.next
+
+	// LIFO free list. Built with face->link.next.
+	b3QHFace* faceFreeHead;
 
 	// Reusable scratch buffers.
 	b3QHHalfEdge** horizon;
@@ -145,7 +149,6 @@ typedef struct b3HullBuilder
 	int horizonStackCapacity;
 
 	// Final counts of the constructed hull (vertexList / faceList / half-edges around faces).
-	// Populated by CleanHull; zero until then.
 	int finalVertexCount;
 	int finalHalfEdgeCount;
 	int finalFaceCount;
@@ -300,17 +303,18 @@ static b3QHFace* b3HullBuilder_NewFace( b3HullBuilder* b, b3QHVertex* v1, b3QHVe
 	return face;
 }
 
-// Remove face from faceList if still linked, clear its edge pointer, then push onto faceFreeHead.
-// Uses face->link.next as the free-list next pointer (link.prev stays NULL, so b3QHList_Contains
-// returns false on a free slot, as required by the retire-guard in ResolveFaces).
+// Remove face and add to free list.
 static void b3HullBuilder_RetireFace( b3HullBuilder* b, b3QHFace* face )
 {
+	// Sometimes a cone face gets merged and never added to the list.
 	if ( b3QHList_Contains( &face->link ) )
 	{
 		b3QHList_Remove( &face->link );
 	}
+
 	face->edge = NULL;
-	// link.prev is already NULL after Remove (or was never set). link.next holds free-list ptr.
+	// link.prev is already NULL after Remove (or was never set).
+	B3_VALIDATE( face->link.prev == NULL );
 	face->link.next = (b3QHListNode*)b->faceFreeHead;
 	b->faceFreeHead = face;
 }
@@ -1232,7 +1236,7 @@ static void b3HullBuilder_ResolveVertices( b3HullBuilder* b )
 static void b3HullBuilder_ResolveFaces( b3HullBuilder* b )
 {
 	// Splice deleted faces out of the face list. Faces already retired by AbsorbFaces are no
-	// longer on faceList, so we guard with b3QHList_Contains before removing.
+	// longer on faceList, so guard with b3QHList_Contains before removing.
 	b3QHListNode* node = b->faceList.link.next;
 	while ( node != &b->faceList.link )
 	{
@@ -1242,7 +1246,21 @@ static void b3HullBuilder_ResolveFaces( b3HullBuilder* b )
 		if ( face->mark == B3_MARK_DELETE && b3QHList_Contains( &face->link ) )
 		{
 			B3_ASSERT( B3_LIST_EMPTY( &face->conflictListHead.link ) );
-			b3QHList_Remove( &face->link );
+
+			// Each half-edge is owned by exactly one face, so ring walks over the
+			// dead region retire every interior edge exactly once. Merge deleted
+			// faces are already off the face list.
+			b3QHHalfEdge* start = face->edge;
+			b3QHHalfEdge* edge = start;
+			do
+			{
+				b3QHHalfEdge* next = edge->next;
+				b3HullBuilder_RetireEdge( b, edge );
+				edge = next;
+			}
+			while ( edge != start );
+
+			b3HullBuilder_RetireFace( b, face );
 		}
 	}
 
@@ -1421,12 +1439,13 @@ static bool b3HullBuilder_Construct( b3HullBuilder* b, const b3Vec3* points, int
 	}
 
 	b3HullBuilder_ComputeTolerance( b, pointCount, shiftedPoints );
-	if ( !b3HullBuilder_BuildInitialHull( b, pointCount, shiftedPoints ) )
+	bool haveInitialHull = b3HullBuilder_BuildInitialHull( b, pointCount, shiftedPoints );
+	if ( haveInitialHull == false )
 	{
 		return false;
 	}
 
-	int budget = b3ClampInt( maxVertexCount - 4, 0, B3_HULL_LIMIT - 4 );
+	int budget = b3ClampInt( maxVertexCount - 4, 0, B3_HULL_MAX_COUNT - 4 );
 
 	b3QHVertex* vertex = b3HullBuilder_NextConflictVertex( b );
 	while ( vertex && budget > 0 )
@@ -1447,8 +1466,10 @@ static bool b3HullBuilder_Construct( b3HullBuilder* b, const b3Vec3* points, int
 
 typedef struct b3HullWorkSizes
 {
-	int N; // pointCount
-	int M; // clamped maxVertexCount, in [4, B3_HULL_LIMIT]
+	// Input point count
+	int N;
+	// Output point limit
+	int M;
 	int vertexCapacity;
 	int edgeCapacity;
 	int faceCapacity;
@@ -1478,39 +1499,19 @@ static b3HullWorkSizes b3ComputeHullWorkSizes( int pointCount, int clampedMaxCou
 	s.vertexCapacity = pointCount + 4;
 
 	// Edges and faces use free-list recycling; capacity is proportional to live hull size.
-	// edgeCapacity: peak is ~twice live edges plus cone edges; floor 48.
-	s.edgeCapacity = 24 * s.M - 48;
-	if ( s.edgeCapacity < 48 )
-	{
-		s.edgeCapacity = 48;
-	}
+	// edgeCapacity: peak is ~twice live edges plus cone edges. Minimum 48.
+	s.edgeCapacity = b3MaxInt( 48, 24 * s.M - 48 );
 
-	// faceCapacity: peak intermediate state live faces (<=2*M-4) plus full cone (<=3*M-6); floor 16.
-	s.faceCapacity = 5 * s.M - 10;
-	if ( s.faceCapacity < 16 )
-	{
-		s.faceCapacity = 16;
-	}
+	// faceCapacity: peak intermediate state live faces (<=2*M-4) plus full cone (<=3*M-6). Minimum 16.
+	s.faceCapacity = b3MaxInt( 16, 5 * s.M - 10 );
 
-	// Horizon/cone bounded by current half-edge count; mergedFaces by face count.
-	s.horizonCapacity = 3 * s.M - 6;
-	if ( s.horizonCapacity < 6 )
-	{
-		s.horizonCapacity = 6;
-	}
+	// Horizon/cone bounded by current half-edge count. Merged faces by face count.
+	s.horizonCapacity = b3MaxInt( 6, 3 * s.M - 6 );
 	s.coneCapacity = s.horizonCapacity;
-	s.mergedFacesCapacity = 2 * s.M - 4;
-	if ( s.mergedFacesCapacity < 4 )
-	{
-		s.mergedFacesCapacity = 4;
-	}
+	s.mergedFacesCapacity = b3MaxInt( 4, 2 * s.M - 4 );
 
 	// Horizon DFS depth is bounded by the number of live faces (Euler: <=2*M-4).
-	s.horizonStackCapacity = 2 * s.M - 4;
-	if ( s.horizonStackCapacity < 4 )
-	{
-		s.horizonStackCapacity = 4;
-	}
+	s.horizonStackCapacity = b3MaxInt( 4, 2 * s.M - 4 );
 
 	size_t offset = 0;
 
@@ -1607,6 +1608,24 @@ static b3HullHalfEdge* b3GetHullEdgesWrite( b3HullData* hull )
 	return (b3HullHalfEdge*)( (intptr_t)hull + hull->edgeOffset );
 }
 
+static float* b3GetHullSoaVerticesWrite( b3HullData* hull )
+{
+	if ( hull->soaVertexOffset == 0 )
+	{
+		return NULL;
+	}
+	return (float*)( (intptr_t)hull + hull->soaVertexOffset );
+}
+
+static float* b3GetHullSoaNormalsWrite( b3HullData* hull )
+{
+	if ( hull->soaNormalOffset == 0 )
+	{
+		return NULL;
+	}
+	return (float*)( (intptr_t)hull + hull->soaNormalOffset );
+}
+
 int b3FindHullSupportVertex( const b3HullData* hull, b3Vec3 direction )
 {
 	int bestIndex = B3_NULL_INDEX;
@@ -2028,7 +2047,7 @@ b3HullData* b3CreateHull( const b3Vec3* points, int pointCount, int maxVertexCou
 	}
 
 	b3Vec3 origin = points[0];
-	int clampedMaxCount = b3ClampInt( maxVertexCount, 4, B3_HULL_LIMIT );
+	int clampedMaxCount = b3ClampInt( maxVertexCount, 4, B3_MAX_HULL_VERTICES );
 
 	// Single allocation for all working memory.
 	b3HullWorkSizes sizes = b3ComputeHullWorkSizes( pointCount, clampedMaxCount );
@@ -2040,40 +2059,41 @@ b3HullData* b3CreateHull( const b3Vec3* points, int pointCount, int maxVertexCou
 	b3Vec3* shiftedPoints = (b3Vec3*)( work + sizes.offsetShiftedPoints );
 
 	bool ok = b3HullBuilder_Construct( &builder, points, pointCount, clampedMaxCount, origin, shiftedPoints );
-	if ( !ok )
+	if ( ok == false )
 	{
 		b3Free( work, sizes.totalBytes );
 		return NULL;
 	}
 
-	if ( builder.finalVertexCount >= B3_HULL_LIMIT )
+	if ( builder.finalVertexCount > B3_MAX_HULL_VERTICES )
 	{
-		b3Log( "hull final vertex count of %d exceeds limit of %d", builder.finalVertexCount, B3_HULL_LIMIT );
+		b3Log( "hull final vertex count of %d exceeds limit of %d", builder.finalVertexCount, B3_MAX_HULL_VERTICES );
 		b3Free( work, sizes.totalBytes );
 		return NULL;
 	}
 
-	if ( builder.finalFaceCount >= B3_HULL_LIMIT )
+	if ( builder.finalFaceCount > B3_MAX_HULL_FACES )
 	{
-		b3Log( "hull final face count of %d exceeds limit of %d", builder.finalFaceCount, B3_HULL_LIMIT );
+		b3Log( "hull final face count of %d exceeds limit of %d", builder.finalFaceCount, B3_MAX_HULL_FACES );
 		b3Free( work, sizes.totalBytes );
 		return NULL;
 	}
 
-	if ( builder.finalHalfEdgeCount >= B3_HULL_LIMIT )
+	int maxHalfEdgeCount = 2 * B3_MAX_HULL_EDGES;
+	if ( builder.finalHalfEdgeCount > maxHalfEdgeCount )
 	{
-		b3Log( "hull final half edge count of %d exceeds limit of %d", builder.finalHalfEdgeCount, B3_HULL_LIMIT );
+		b3Log( "hull final half edge count of %d exceeds limit of %d", builder.finalHalfEdgeCount, maxHalfEdgeCount );
 		b3Free( work, sizes.totalBytes );
 		return NULL;
 	}
 
-	// Walk lists into temp arrays bounded by B3_HULL_LIMIT, stamping finalIndex on each node so
+	// Walk lists into temp arrays bounded by B3_HULL_MAX_COUNT, stamping finalIndex on each node so
 	// the resolution pass below is O(E + F) instead of O(E^2 + F^2).
-	const b3QHVertex* tempVertices[B3_HULL_LIMIT];
+	const b3QHVertex* tempVertices[B3_HULL_MAX_COUNT];
 	int vertexCount = 0;
 	for ( b3QHListNode* node = builder.vertexList.link.next; node != &builder.vertexList.link; node = node->next )
 	{
-		B3_ASSERT( vertexCount <= B3_HULL_LIMIT - 1 );
+		B3_ASSERT( vertexCount < B3_HULL_MAX_COUNT );
 
 		b3QHVertex* vertex = (b3QHVertex*)node;
 		vertex->finalIndex = vertexCount;
@@ -2081,15 +2101,14 @@ b3HullData* b3CreateHull( const b3Vec3* points, int pointCount, int maxVertexCou
 	}
 
 	// Collect edges in twin-paired order (i, i+1) by stamping each pair as we discover it.
-	// Replaces b3SortEdges' O(E^2) twin pairing.
-	const b3QHFace* tempFaces[B3_HULL_LIMIT];
-	const b3QHHalfEdge* tempEdges[B3_HULL_LIMIT];
+	const b3QHFace* tempFaces[B3_HULL_MAX_COUNT];
+	const b3QHHalfEdge* tempEdges[B3_HULL_MAX_COUNT];
 	int faceCount = 0;
 	int edgeCount = 0;
 
 	for ( b3QHListNode* faceNode = builder.faceList.link.next; faceNode != &builder.faceList.link; faceNode = faceNode->next )
 	{
-		B3_ASSERT( faceCount <= B3_HULL_LIMIT - 1 );
+		B3_ASSERT( faceCount < B3_HULL_MAX_COUNT );
 
 		b3QHFace* face = (b3QHFace*)faceNode;
 		face->finalIndex = faceCount;
@@ -2100,7 +2119,7 @@ b3HullData* b3CreateHull( const b3Vec3* points, int pointCount, int maxVertexCou
 		{
 			if ( edge->finalIndex < 0 )
 			{
-				B3_ASSERT( edgeCount + 1 <= B3_HULL_LIMIT - 1 );
+				B3_ASSERT( edgeCount + 1 < B3_HULL_MAX_COUNT );
 
 				edge->finalIndex = edgeCount;
 				tempEdges[edgeCount++] = edge;
@@ -2112,6 +2131,9 @@ b3HullData* b3CreateHull( const b3Vec3* points, int pointCount, int maxVertexCou
 		while ( edge != face->edge );
 	}
 
+	int soaVertexCount = ( vertexCount + 3 ) & ~3;
+	int soaNormalCount = ( faceCount + 3 ) & ~3;
+
 	// Allocate the hull. Arrays hang off the end.
 	size_t byteCount = b3AlignUp8( sizeof( b3HullData ) );
 	int vertexOffset = (int)byteCount;
@@ -2120,10 +2142,14 @@ b3HullData* b3CreateHull( const b3Vec3* points, int pointCount, int maxVertexCou
 	byteCount += b3AlignUp8( vertexCount * (int)sizeof( b3Vec3 ) );
 	int edgeOffset = (int)byteCount;
 	byteCount += b3AlignUp8( edgeCount * (int)sizeof( b3HullHalfEdge ) );
-	int faceOffset = (int)byteCount;
-	byteCount += b3AlignUp8( faceCount * (int)sizeof( b3HullFace ) );
 	int planeOffset = (int)byteCount;
 	byteCount += b3AlignUp8( faceCount * (int)sizeof( b3Plane ) );
+	int faceOffset = (int)byteCount;
+	byteCount += b3AlignUp8( faceCount * (int)sizeof( b3HullFace ) );
+	int soaVertexOffset = (int)byteCount;
+	byteCount += b3AlignUp8( 3 * soaVertexCount * (int)sizeof( float ) );
+	int soaNormalOffset = (int)byteCount;
+	byteCount += b3AlignUp8( 3 * soaNormalCount * (int)sizeof( float ) );
 
 	b3HullData* hull = b3Alloc( byteCount );
 	memset( hull, 0, byteCount );
@@ -2132,8 +2158,10 @@ b3HullData* b3CreateHull( const b3Vec3* points, int pointCount, int maxVertexCou
 	hull->vertexOffset = vertexOffset;
 	hull->pointOffset = pointOffset;
 	hull->edgeOffset = edgeOffset;
-	hull->faceOffset = faceOffset;
 	hull->planeOffset = planeOffset;
+	hull->faceOffset = faceOffset;
+	hull->soaVertexOffset = soaVertexOffset;
+	hull->soaNormalOffset = soaNormalOffset;
 
 	hull->vertexCount = vertexCount;
 	hull->edgeCount = edgeCount;
@@ -2146,11 +2174,29 @@ b3HullData* b3CreateHull( const b3Vec3* points, int pointCount, int maxVertexCou
 	b3HullFace* faces = (b3HullFace*)( (intptr_t)hull + hull->faceOffset );
 	b3Vec3* finalPoints = b3GetHullPointsWrite( hull );
 	b3Plane* planes = b3GetHullPlanesWrite( hull );
+	float* soaVertices = b3GetHullSoaVerticesWrite( hull );
+	float* soaNormals = b3GetHullSoaNormalsWrite( hull );
+
+	float* vx = soaVertices;
+	float* vy = vx + soaVertexCount;
+	float* vz = vy + soaVertexCount;
 
 	for ( int index = 0; index < vertexCount; ++index )
 	{
 		vertices[index].edge = 0;
-		finalPoints[index] = tempVertices[index]->position;
+		b3Vec3 p = tempVertices[index]->position;
+		finalPoints[index] = p;
+
+		vx[index] = p.x;
+		vy[index] = p.y;
+		vz[index] = p.z;
+	}
+
+	for ( int index = vertexCount; index < soaVertexCount; ++index )
+	{
+		vx[index] = vx[0];
+		vy[index] = vy[0];
+		vz[index] = vz[0];
 	}
 
 	for ( int index = 0; index < edgeCount; ++index )
@@ -2169,6 +2215,10 @@ b3HullData* b3CreateHull( const b3Vec3* points, int pointCount, int maxVertexCou
 		vertices[edge->origin->finalIndex].edge = (uint8_t)index;
 	}
 
+	float* nx = soaNormals;
+	float* ny = nx + soaNormalCount;
+	float* nz = ny + soaNormalCount;
+
 	for ( int index = 0; index < faceCount; ++index )
 	{
 		const b3QHFace* face = tempFaces[index];
@@ -2176,6 +2226,18 @@ b3HullData* b3CreateHull( const b3Vec3* points, int pointCount, int maxVertexCou
 
 		faces[index].edge = (uint8_t)face->edge->finalIndex;
 		planes[index] = face->plane;
+
+		b3Vec3 n = face->plane.normal;
+		nx[index] = n.x;
+		ny[index] = n.y;
+		nz[index] = n.z;
+	}
+
+	for ( int index = faceCount; index < soaNormalCount; ++index )
+	{
+		nx[index] = 0.0f;
+		ny[index] = 0.0f;
+		nz[index] = 0.0f;
 	}
 
 	// All builder pointers are dead from here on.
@@ -2238,9 +2300,10 @@ bool b3CompareHullData( const b3HullData* hull1, const b3HullData* hull2 )
 
 // Hull identity covers every byte, so the structs carry explicit padding. These lock
 // the layout, re-audit padding if a size changes.
-_Static_assert( sizeof( b3HullData ) == 136, "unexpected hull data size" );
-_Static_assert( sizeof( b3BoxHull ) == 440, "unexpected box hull size" );
+_Static_assert( sizeof( b3HullData ) == 144, "unexpected hull data size" );
+_Static_assert( sizeof( b3BoxHull ) == 648, "unexpected box hull size" );
 
+// Implement b3HullMap.
 #define NAME b3HullMap
 #define KEY_TY const b3HullData*
 #define VAL_TY int
@@ -2269,7 +2332,7 @@ b3HullData* b3CloneAndTransformHull( const b3HullData* original, b3Transform tra
 		return NULL;
 	}
 
-	b3HullData* hull = (b3HullData*)b3Alloc( original->byteCount );
+	b3HullData* hull = b3Alloc( original->byteCount );
 	memcpy( hull, original, original->byteCount );
 
 	b3Vec3 safeScale = b3SafeScale( scale );
@@ -2286,9 +2349,9 @@ b3HullData* b3CloneAndTransformHull( const b3HullData* original, b3Transform tra
 		{
 			const b3HullFace* face = faces + i;
 
-			uint8_t startEdgeIndex = face->edge;
-			uint8_t currentEdgeIndex = startEdgeIndex;
-			uint8_t prevEdgeIndex = UINT8_MAX;
+			int startEdgeIndex = face->edge;
+			int currentEdgeIndex = startEdgeIndex;
+			int prevEdgeIndex = B3_NULL_INDEX;
 
 			do
 			{
@@ -2304,7 +2367,7 @@ b3HullData* b3CloneAndTransformHull( const b3HullData* original, b3Transform tra
 			}
 			while ( currentEdgeIndex != startEdgeIndex );
 
-			B3_ASSERT( prevEdgeIndex != UINT8_MAX );
+			B3_ASSERT( prevEdgeIndex != B3_NULL_INDEX );
 
 			currentEdgeIndex = startEdgeIndex;
 
@@ -2312,7 +2375,7 @@ b3HullData* b3CloneAndTransformHull( const b3HullData* original, b3Transform tra
 			{
 				b3HullHalfEdge* edge = edges + currentEdgeIndex;
 				uint8_t nextIndex = edge->next;
-				edge->next = prevEdgeIndex;
+				edge->next = (uint8_t)prevEdgeIndex;
 
 				if ( currentEdgeIndex < edge->twin )
 				{
@@ -2339,12 +2402,32 @@ b3HullData* b3CloneAndTransformHull( const b3HullData* original, b3Transform tra
 	b3Matrix3 matrix = b3MakeMatrixFromQuat( transform.q );
 	b3Vec3* points = b3GetHullPointsWrite( hull );
 
+	int soaVertexCount = ( vertexCount + 3 ) & ~3;
+	float* vx = b3GetHullSoaVerticesWrite( hull );
+	float* vy = vx + soaVertexCount;
+	float* vz = vy + soaVertexCount;
+
 	for ( int i = 0; i < vertexCount; ++i )
 	{
-		points[i] = b3Add( b3MulMV( matrix, b3Mul( safeScale, points[i] ) ), transform.p );
+		b3Vec3 p = b3Add( b3MulMV( matrix, b3Mul( safeScale, points[i] ) ), transform.p );
+		points[i] = p;
+		vx[i] = p.x;
+		vy[i] = p.y;
+		vz[i] = p.z;
+	}
+
+	for ( int i = vertexCount; i < soaVertexCount; ++i )
+	{
+		vx[i] = vx[0];
+		vy[i] = vy[0];
+		vz[i] = vz[0];
 	}
 
 	b3Plane* planes = b3GetHullPlanesWrite( hull );
+	int soaNormalCount = ( faceCount + 3 ) & ~3;
+	float* nx = b3GetHullSoaNormalsWrite( hull );
+	float* ny = nx + soaNormalCount;
+	float* nz = ny + soaNormalCount;
 
 	for ( int i = 0; i < faceCount; ++i )
 	{
@@ -2390,6 +2473,17 @@ b3HullData* b3CloneAndTransformHull( const b3HullData* original, b3Transform tra
 		normal = b3MulSV( 1.0f / area, normal );
 
 		planes[i] = b3MakePlaneFromNormalAndPoint( normal, centroid );
+
+		nx[i] = normal.x;
+		ny[i] = normal.y;
+		nz[i] = normal.z;
+	}
+
+	for ( int i = faceCount; i < soaNormalCount; ++i )
+	{
+		nx[i] = 0.0f;
+		ny[i] = 0.0f;
+		nz[i] = 0.0f;
 	}
 
 	b3UpdateHullBounds( hull );
@@ -2641,8 +2735,10 @@ static const b3BoxHull s_boxHull = {
 			.vertexOffset = offsetof( b3BoxHull, boxVertices ),
 			.pointOffset = offsetof( b3BoxHull, boxPoints ),
 			.edgeOffset = offsetof( b3BoxHull, boxEdges ),
-			.faceOffset = offsetof( b3BoxHull, boxFaces ),
 			.planeOffset = offsetof( b3BoxHull, boxPlanes ),
+			.faceOffset = offsetof( b3BoxHull, boxFaces ),
+			.soaVertexOffset = offsetof( b3BoxHull, vx ),
+			.soaNormalOffset = offsetof( b3BoxHull, nx ),
 		},
 	.boxVertices =
 		{
@@ -2677,6 +2773,8 @@ static const b3BoxHull s_boxHull = {
 
 b3BoxHull b3MakeTransformedBoxHull( float hx, float hy, float hz, b3Transform transform )
 {
+	B3_ASSERT( b3IsValidTransform( transform ) );
+
 	b3BoxHull boxHull = s_boxHull;
 
 	float minH = 0.2f * B3_LINEAR_SLOP;
@@ -2710,6 +2808,61 @@ b3BoxHull b3MakeTransformedBoxHull( float hx, float hy, float hz, b3Transform tr
 	boxHull.boxPoints[6] = b3TransformPoint( transform, (b3Vec3){ -h.x, -h.y, -h.z } );
 	boxHull.boxPoints[7] = b3TransformPoint( transform, (b3Vec3){ h.x, -h.y, -h.z } );
 
+	// SOA
+	boxHull.vx[0] = boxHull.boxPoints[0].x;
+	boxHull.vx[1] = boxHull.boxPoints[1].x;
+	boxHull.vx[2] = boxHull.boxPoints[2].x;
+	boxHull.vx[3] = boxHull.boxPoints[3].x;
+	boxHull.vx[4] = boxHull.boxPoints[4].x;
+	boxHull.vx[5] = boxHull.boxPoints[5].x;
+	boxHull.vx[6] = boxHull.boxPoints[6].x;
+	boxHull.vx[7] = boxHull.boxPoints[7].x;
+
+	boxHull.vy[0] = boxHull.boxPoints[0].y;
+	boxHull.vy[1] = boxHull.boxPoints[1].y;
+	boxHull.vy[2] = boxHull.boxPoints[2].y;
+	boxHull.vy[3] = boxHull.boxPoints[3].y;
+	boxHull.vy[4] = boxHull.boxPoints[4].y;
+	boxHull.vy[5] = boxHull.boxPoints[5].y;
+	boxHull.vy[6] = boxHull.boxPoints[6].y;
+	boxHull.vy[7] = boxHull.boxPoints[7].y;
+
+	boxHull.vz[0] = boxHull.boxPoints[0].z;
+	boxHull.vz[1] = boxHull.boxPoints[1].z;
+	boxHull.vz[2] = boxHull.boxPoints[2].z;
+	boxHull.vz[3] = boxHull.boxPoints[3].z;
+	boxHull.vz[4] = boxHull.boxPoints[4].z;
+	boxHull.vz[5] = boxHull.boxPoints[5].z;
+	boxHull.vz[6] = boxHull.boxPoints[6].z;
+	boxHull.vz[7] = boxHull.boxPoints[7].z;
+
+	boxHull.nx[0] = boxHull.boxPlanes[0].normal.x;
+	boxHull.nx[1] = boxHull.boxPlanes[1].normal.x;
+	boxHull.nx[2] = boxHull.boxPlanes[2].normal.x;
+	boxHull.nx[3] = boxHull.boxPlanes[3].normal.x;
+	boxHull.nx[4] = boxHull.boxPlanes[4].normal.x;
+	boxHull.nx[5] = boxHull.boxPlanes[5].normal.x;
+	boxHull.nx[6] = 0.0f;
+	boxHull.nx[7] = 0.0f;
+
+	boxHull.ny[0] = boxHull.boxPlanes[0].normal.y;
+	boxHull.ny[1] = boxHull.boxPlanes[1].normal.y;
+	boxHull.ny[2] = boxHull.boxPlanes[2].normal.y;
+	boxHull.ny[3] = boxHull.boxPlanes[3].normal.y;
+	boxHull.ny[4] = boxHull.boxPlanes[4].normal.y;
+	boxHull.ny[5] = boxHull.boxPlanes[5].normal.y;
+	boxHull.ny[6] = 0.0f;
+	boxHull.ny[7] = 0.0f;
+
+	boxHull.nz[0] = boxHull.boxPlanes[0].normal.z;
+	boxHull.nz[1] = boxHull.boxPlanes[1].normal.z;
+	boxHull.nz[2] = boxHull.boxPlanes[2].normal.z;
+	boxHull.nz[3] = boxHull.boxPlanes[3].normal.z;
+	boxHull.nz[4] = boxHull.boxPlanes[4].normal.z;
+	boxHull.nz[5] = boxHull.boxPlanes[5].normal.z;
+	boxHull.nz[6] = 0.0f;
+	boxHull.nz[7] = 0.0f;
+
 	boxHull.base.hash = 0;
 	boxHull.base.hash = b3NonZeroHash( b3Hash( B3_HASH_INIT, (uint8_t*)&boxHull, sizeof( b3BoxHull ) ) );
 
@@ -2784,6 +2937,8 @@ void b3ScaleBox( b3Vec3* halfWidths, b3Transform* transform, b3Vec3 postScale, f
 // todo use new hull scaling technique
 b3BoxHull b3MakeScaledBoxHull( b3Vec3 halfWidths, b3Transform transform, b3Vec3 postScale )
 {
+	B3_ASSERT( b3IsValidTransform( transform ) );
+
 	b3Vec3 h = halfWidths;
 	b3Transform xf = transform;
 	b3ScaleBox( &h, &xf, postScale, 4.0f * B3_LINEAR_SLOP );
diff --git a/vendor/box3d/src/src/hull_map.h b/vendor/box3d/src/src/hull.h
similarity index 77%
rename from vendor/box3d/src/src/hull_map.h
rename to vendor/box3d/src/src/hull.h
index 5b50c56eb..a1077bb52 100644
--- a/vendor/box3d/src/src/hull_map.h
+++ b/vendor/box3d/src/src/hull.h
@@ -12,8 +12,8 @@
 uint64_t b3HashHullData( const b3HullData* hull );
 bool b3CompareHullData( const b3HullData* hull1, const b3HullData* hull2 );
 
-// Map keyed by hull content. The world hull database stores a reference count,
-// compound baking stores a byte offset. Implementation lives in hull.c.
+// Map keyed by hull content. The world hull database uses the value as a reference count,
+// while compound baking stores uses the value as a byte offset. Implementation is in hull.c.
 #define NAME b3HullMap
 #define KEY_TY const b3HullData*
 #define VAL_TY int
diff --git a/vendor/box3d/src/src/island.c b/vendor/box3d/src/src/island.c
index 625a1b345..6a1790923 100644
--- a/vendor/box3d/src/src/island.c
+++ b/vendor/box3d/src/src/island.c
@@ -498,7 +498,7 @@ void b3SplitIsland( b3World* world, int baseId )
 		}
 	}
 
-	// Early return — island is still fully connected, no split needed.
+	// Island is still fully connected, no split needed.
 	if ( componentCount == 1 )
 	{
 		baseIsland->constraintRemoveCount = 0;
diff --git a/vendor/box3d/src/src/manifold.c b/vendor/box3d/src/src/manifold.c
index 40e60ad57..f15db6c03 100644
--- a/vendor/box3d/src/src/manifold.c
+++ b/vendor/box3d/src/src/manifold.c
@@ -10,58 +10,6 @@
 
 #include "box3d/math_functions.h"
 
-// p1 : origin on edge 1
-// e1 : edge 1
-// c1 : shape 1 centroid
-// p2 : origin on edge 2
-// e2 : edge 2
-// c2 : shape 2 centroid
-float b3EdgeEdgeSeparation( b3Vec3 p1, b3Vec3 e1, b3Vec3 c1, b3Vec3 p2, b3Vec3 e2, b3Vec3 c2 )
-{
-	// Build search direction
-	b3Vec3 u = b3Cross( e1, e2 );
-	float length = b3Length( u );
-
-	// Skip near parallel edges: |e1 x e1| = sin(alpha) * |e1| * |e2|
-	const float kTolerance = 0.005f;
-	if ( length < kTolerance * sqrtf( b3LengthSquared( e1 ) * b3LengthSquared( e2 ) ) )
-	{
-		return -FLT_MAX;
-	}
-
-	if ( length * length < 1000.0f * FLT_MIN )
-	{
-		return -FLT_MAX;
-	}
-
-	b3Vec3 n = b3MulSV( 1.0f / length, u );
-
-	// Make sure normal points away from the first shape
-	// For a triangle, it is possible that N is aligned with the triangle normal and the sign
-	// value can be close to zero and flicker between small negative and positive values, leading to
-	// an incorrect separation value. So we assume the other hull has some volume and pick the most
-	// significant sign value to orient N.
-	float sign1 = b3Dot( n, b3Sub( p1, c1 ) );
-	float sign2 = b3Dot( n, b3Sub( p2, c2 ) );
-	if ( b3AbsFloat( sign1 ) > b3AbsFloat( sign2 ) )
-	{
-		if ( sign1 < 0.0f )
-		{
-			n = b3Neg( n );
-		}
-	}
-	else
-	{
-		if ( sign2 > 0.0f )
-		{
-			n = b3Neg( n );
-		}
-	}
-
-	// s = Dot(n, p2) - d = Dot(n, p2) - Dot(n, p1) = Dot(n, p2 - p1)
-	return b3Dot( n, b3Sub( p2, p1 ) );
-}
-
 // This was extended to make the wedge shape get the correct incident face.
 // Instead of looking directly for the most anti-parallel face, we first find the closest vertex (passed in).
 // Then we look for all edges coming out of that vertex and look for the edge that is
@@ -69,6 +17,8 @@ float b3EdgeEdgeSeparation( b3Vec3 p1, b3Vec3 e1, b3Vec3 c1, b3Vec3 p2, b3Vec3 e
 // Then from that edge, we select the adjacent face that is most anti-parallel to the reference normal.
 int b3FindIncidentFace( const b3HullData* hull, b3Vec3 refNormal, int vertexIndex )
 {
+	B3_ASSERT( 0 <= vertexIndex && vertexIndex < hull->vertexCount );
+
 	const b3HullVertex* vertices = b3GetHullVertices( hull );
 	const b3HullHalfEdge* edges = b3GetHullEdges( hull );
 	const b3Plane* planes = b3GetHullPlanes( hull );
diff --git a/vendor/box3d/src/src/manifold.h b/vendor/box3d/src/src/manifold.h
index 9e529ab97..fca3cde0b 100644
--- a/vendor/box3d/src/src/manifold.h
+++ b/vendor/box3d/src/src/manifold.h
@@ -8,19 +8,22 @@
 
 #define B3_MAX_CLIP_POINTS 64
 
-typedef struct b3FaceQuery
-{
-	float separation;
-	int faceIndex;
-	int vertexIndex;
-} b3FaceQuery;
-
-typedef struct b3EdgeQuery
+typedef struct b3SeparatingAxis
 {
+	b3Vec3 normal;
 	float separation;
 	int indexA;
 	int indexB;
-} b3EdgeQuery;
+	b3SeparatingFeature type;
+} b3SeparatingAxis;
+
+typedef struct b3AxisQuery
+{
+	b3SeparatingAxis faceA;
+	b3SeparatingAxis faceB;
+	b3SeparatingAxis edge;
+	b3SeparatingFeature separatedFeature;
+} b3AxisQuery;
 
 typedef struct b3ClipVertex
 {
@@ -35,7 +38,6 @@ typedef enum b3FeatureOwner
 	b3_featureShapeB = 1
 } b3FeatureOwner;
 
-float b3EdgeEdgeSeparation( b3Vec3 p1, b3Vec3 e1, b3Vec3 c1, b3Vec3 p2, b3Vec3 e2, b3Vec3 c2 );
 int b3FindIncidentFace( const b3HullData* hull, b3Vec3 refNormal, int vertexIndex );
 b3FeaturePair b3MakeFeaturePair( b3FeatureOwner owner1, int index1, b3FeatureOwner owner2, int index2 );
 
@@ -43,6 +45,8 @@ b3FeaturePair b3FlipPair( b3FeaturePair pair );
 
 int b3ClipPolygon( b3ClipVertex* out, b3ClipVertex* polygon, int count, b3Plane clipPlane, int edge, b3Plane refPlane );
 
+b3AxisQuery b3ComputeSeparatingAxis( const b3HullData* hullA, const b3HullData* hullB, b3Transform xfB, bool earlyReturn );
+
 #if B3_ENABLE_VALIDATION
 bool b3ValidatePolygon( b3ClipVertex* polygon, int count );
 #endif
@@ -55,3 +59,27 @@ static inline uint32_t b3MakeFeatureId( b3FeaturePair pair )
 	return ( (uint32_t)pair.owner1 << 24 ) | ( (uint32_t)pair.index1 << 16 ) | ( (uint32_t)pair.owner2 << 8 ) |
 		   (uint32_t)pair.index2;
 }
+
+static inline b3SeparatingAxis b3GetBestAxis( const b3AxisQuery* query )
+{
+	B3_VALIDATE( query->faceA.type == b3_faceAxisA );
+	B3_VALIDATE( query->edge.type == b3_edgePairAxis );
+	B3_VALIDATE( query->faceB.type == b3_faceAxisB );
+
+	if ( query->faceA.separation > query->faceB.separation )
+	{
+		if ( query->edge.separation > query->faceA.separation )
+		{
+			return query->edge;
+		}
+
+		return query->faceA;
+	}
+
+	if ( query->edge.separation > query->faceB.separation )
+	{
+		return query->edge;
+	}
+
+	return query->faceB;
+}
diff --git a/vendor/box3d/src/src/math_internal.h b/vendor/box3d/src/src/math_internal.h
index 4d152c5fc..d975c65dc 100644
--- a/vendor/box3d/src/src/math_internal.h
+++ b/vendor/box3d/src/src/math_internal.h
@@ -61,6 +61,7 @@ b3Matrix3 b3BoxInertia( float mass, b3Vec3 min, b3Vec3 max );
 int b3GetProxySupport( const b3ShapeProxy* proxy, b3Vec3 axis );
 int b3GetPointSupport( const b3Vec3* points, int count, b3Vec3 axis );
 
+// Align up to 8 byte alignment.
 static inline size_t b3AlignUp8( size_t x )
 {
 	return ( x + 7u ) & ~(size_t)7u;
diff --git a/vendor/box3d/src/src/mesh.c b/vendor/box3d/src/src/mesh.c
index c03489955..acfbda0e1 100644
--- a/vendor/box3d/src/src/mesh.c
+++ b/vendor/box3d/src/src/mesh.c
@@ -928,7 +928,8 @@ static int b3BuildRecursive( b3Array( b3MeshNode ) * nodes, int count, b3Primiti
 		node->data.asNode.childOffset = rightIndex - index;
 		node->lowerBound = aabb.lowerBound;
 		node->upperBound = aabb.upperBound;
-		// triangleOffset is leaf-only, but lives outside the union — zero it so mesh->hash is deterministic
+
+		// Zero so mesh->hash is deterministic
 		node->triangleOffset = 0;
 
 		return index;
@@ -1321,14 +1322,17 @@ b3MeshData* b3CreateWaveMesh( int xCount, int zCount, float cellWidth, float amp
 	float omegaX = 2.0f * B3_PI * columnFrequency * cellWidth;
 
 	float x = -0.5f * xWidth;
+	b3CosSin cs = { 0 };
 	for ( int ix = 0; ix <= xCount; ++ix )
 	{
-		float rowHeight = sinf( omegaX * ix );
+		cs = b3ComputeCosSin( omegaX * ix );
+		float rowHeight = cs.sine;
 
 		float z = -0.5f * zWidth;
 		for ( int iz = 0; iz <= zCount; ++iz )
 		{
-			float columnHeight = sinf( omegaZ * iz );
+			cs = b3ComputeCosSin( omegaZ * iz );
+			float columnHeight = cs.sine;
 
 			float y = amplitude * rowHeight * columnHeight;
 			vertices.data[index] = (b3Vec3){ x, y, z };
@@ -1482,7 +1486,7 @@ b3MeshData* b3CreateBoxMesh( b3Vec3 center, b3Vec3 extent, bool identifyEdges )
 	return b3CreateMesh( &def, NULL, 0 );
 }
 
-b3MeshData* b3CreateHollowBoxMesh(b3Vec3 center, b3Vec3 extent)
+b3MeshData* b3CreateHollowBoxMesh( b3Vec3 center, b3Vec3 extent )
 {
 	float x = extent.x;
 	float y = extent.y;
diff --git a/vendor/box3d/src/src/mesh_contact.c b/vendor/box3d/src/src/mesh_contact.c
index a7163477a..60158e4b9 100644
--- a/vendor/box3d/src/src/mesh_contact.c
+++ b/vendor/box3d/src/src/mesh_contact.c
@@ -608,7 +608,7 @@ bool b3ComputeMeshManifolds( b3World* world, int workerIndex, b3Contact* contact
 		switch ( shapeB->type )
 		{
 			case b3_capsuleShape:
-				b3CollideCapsuleAndTriangle( manifold, pointCapacity, &shapeB->capsule, vertices, &cache->simplexCache );
+				b3CollideTriangleAndCapsule( manifold, pointCapacity, vertices, &shapeB->capsule, &cache->simplexCache );
 				break;
 
 			case b3_hullShape:
@@ -619,14 +619,14 @@ bool b3ComputeMeshManifolds( b3World* world, int workerIndex, b3Contact* contact
 					cache->satCache = (b3SATCache){ 0 };
 				}
 
-				b3CollideHullAndTriangle( manifold, pointCapacity, hullB, vertices[0], vertices[1], vertices[2], triangle.flags,
+				b3CollideTriangleAndHull( manifold, pointCapacity, vertices[0], vertices[1], vertices[2], triangle.flags, hullB,
 										  &cache->satCache, enableSpeculative );
 				context->satCallCount += 1;
 				context->satCacheHitCount += cache->satCache.hit;
 				break;
 
 			case b3_sphereShape:
-				b3CollideSphereAndTriangle( manifold, pointCapacity, &shapeB->sphere, vertices );
+				b3CollideTriangleAndSphere( manifold, pointCapacity, vertices, &shapeB->sphere );
 				break;
 
 			default:
diff --git a/vendor/box3d/src/src/parallel_for.c b/vendor/box3d/src/src/parallel_for.c
index 07d1c3fdc..c16ac18f0 100644
--- a/vendor/box3d/src/src/parallel_for.c
+++ b/vendor/box3d/src/src/parallel_for.c
@@ -77,7 +77,8 @@ void b3ParallelFor( b3World* world, b3ParallelForCallback* callback, int itemCou
 	// Target multiple blocks per worker to reduce thread stalls.
 	// block size grows once items exceed maxBlockCount * minRange
 	// so the block count stays bounded and per-block sync overhead stays low.
-	int blocksPerWorker = 4;
+	// Benchmarking shows 32 is optimal for the convex pile benchmark and others.
+	int blocksPerWorker = 32;
 	int maxBlockCount = blocksPerWorker * workerCount;
 
 	int blockSize;
diff --git a/vendor/box3d/src/src/physics_world.c b/vendor/box3d/src/src/physics_world.c
index f0dc19e2d..4309e085b 100644
--- a/vendor/box3d/src/src/physics_world.c
+++ b/vendor/box3d/src/src/physics_world.c
@@ -11,7 +11,7 @@
 #include "contact.h"
 #include "core.h"
 #include "ctz.h"
-#include "hull_map.h"
+#include "hull.h"
 #include "island.h"
 #include "joint.h"
 #include "parallel_for.h"
@@ -41,18 +41,21 @@ const b3HullData* b3AddHullToDatabase( b3World* world, const b3HullData* src )
 {
 	b3HullMap* database = world->hullDatabase;
 
-	// Compare by content so an unowned query hull finds the shared copy.
+	// Compare by content to de-duplicate. Not trusting the hash.
 	b3HullMap_itr itr = b3HullMap_get( database, src );
 	if ( b3HullMap_is_end( itr ) == false )
 	{
+		// Bump reference count.
 		itr.data->val += 1;
 		return itr.data->key;
 	}
 
-	b3HullData* owned = b3CloneHull( src );
-	B3_ASSERT( owned != NULL );
-	b3HullMap_insert( database, owned, 1 );
-	return owned;
+	b3HullData* clone = b3CloneHull( src );
+	B3_ASSERT( clone != NULL );
+
+	// Start with reference count of 1.
+	b3HullMap_insert( database, clone, 1 );
+	return clone;
 }
 
 const b3HullData* b3AddOwnedHullToDatabase( b3World* world, b3HullData* owned )
@@ -1426,20 +1429,20 @@ void b3World_Draw( b3WorldId worldId, b3DebugDraw* draw, uint64_t maskBits )
 				const char* name = b3FindName( &world->names, body->nameId );
 				if ( name != NULL )
 				{
-					draw->DrawStringFcn( p, name, b3_colorOrange, draw->context );
+					draw->DrawStringFcn( p, name, b3_colorWhite, draw->context );
 				}
 			}
 
 			if ( draw->drawMass && body->type == b3_dynamicBody )
 			{
-				b3Vec3 offset = { 0.1f, 0.1f, 0.1f };
+				b3Vec3 offset = { 0.05f, 0.05f, 0.05f };
 
 				b3WorldTransform transform = { bodySim->center, bodySim->transform.q };
 				draw->DrawTransformFcn( transform, draw->context );
 				b3Pos p = b3TransformWorldPoint( transform, offset );
 
 				char buffer[32];
-				snprintf( buffer, 32, "  %.2f", body->mass );
+				snprintf( buffer, 32, "%.2f", body->mass );
 				draw->DrawStringFcn( p, buffer, b3_colorWhite, draw->context );
 			}
 
@@ -1523,8 +1526,10 @@ void b3World_Draw( b3WorldId worldId, b3DebugDraw* draw, uint64_t maskBits )
 							b3Vec3 normal = manifold->normal;
 
 							// Average the anchors not the world points so the friction center stays exact far from the origin
-							b3Pos contactCenter = draw->drawAnchorA == 1 ? bodySimA->center : bodySimB->center;
-							b3Vec3 anchorSum = b3Vec3_zero;
+							b3Pos contactCenter = draw->drawAnchorA ? bodySimA->center : bodySimB->center;
+							b3Vec3 frictionAnchor = b3Vec3_zero;
+							float totalWeight = 0.0f;
+							float invTau = 1.0f / B3_SPECULATIVE_DISTANCE;
 
 							const b3ManifoldPoint* points = manifold->points;
 							for ( int pointIndex = 0; pointIndex < manifold->pointCount; ++pointIndex )
@@ -1533,10 +1538,13 @@ void b3World_Draw( b3WorldId worldId, b3DebugDraw* draw, uint64_t maskBits )
 
 								char buffer[32];
 
-								b3Vec3 anchor = draw->drawAnchorA == 1 ? mp->anchorA : mp->anchorB;
+								b3Vec3 anchor = draw->drawAnchorA ? mp->anchorA : mp->anchorB;
 								b3Pos p = b3OffsetPos( contactCenter, anchor );
 
-								anchorSum = b3Add( anchorSum, anchor );
+								// See similar friction anchor weights in b3PrepareContacts_Mesh.
+								float weight = b3ClampFloat( 2.0f - mp->separation * invTau, B3_MIN_FRICTION_WEIGHT, 1.0f );
+								frictionAnchor = b3MulAdd( frictionAnchor, weight, anchor );
+								totalWeight += weight;
 
 								if ( draw->drawContactNormals )
 								{
@@ -1599,9 +1607,8 @@ void b3World_Draw( b3WorldId worldId, b3DebugDraw* draw, uint64_t maskBits )
 							{
 								// Hack inv_dt for single step debugging
 								float inv_dt = world->inv_dt > 0.0f ? world->inv_dt : 60.0f;
-
-								b3Vec3 avgAnchor = b3MulSV( 1.0f / manifold->pointCount, anchorSum );
-								b3Pos p1 = b3OffsetPos( contactCenter, avgAnchor );
+								frictionAnchor = b3MulSV( 1.0f / totalWeight, frictionAnchor );
+								b3Pos p1 = b3OffsetPos( contactCenter, frictionAnchor );
 								b3Vec3 frictionForce = b3MulSV( 0.5f * inv_dt, manifold->frictionImpulse );
 								b3Pos p2 = b3OffsetPos( p1, b3MulSV( draw->forceScale, frictionForce ) );
 								draw->DrawSegmentFcn( p1, p2, frictionColor, draw->context );
diff --git a/vendor/box3d/src/src/physics_world.h b/vendor/box3d/src/src/physics_world.h
index 12f169561..8bd3df865 100644
--- a/vendor/box3d/src/src/physics_world.h
+++ b/vendor/box3d/src/src/physics_world.h
@@ -178,7 +178,7 @@ typedef struct b3World
 	b3Array( b3Shape ) shapes;
 
 	// Reference counted store of shared hull data keyed by content. Shapes hold a
-	// pointer to the owned copy here. Opaque to avoid leaking the verstable map
+	// pointer to the hull stored in the db. Type erased to avoid leaking the verstable map
 	// type into this header.
 	void* hullDatabase;
 
diff --git a/vendor/box3d/src/src/recording.c b/vendor/box3d/src/src/recording.c
index 4d5c5995d..341ddbf0b 100644
--- a/vendor/box3d/src/src/recording.c
+++ b/vendor/box3d/src/src/recording.c
@@ -799,23 +799,15 @@ uint64_t b3Hash64Blob( const uint8_t* bytes, int n )
 static uint32_t b3RegistryPush( b3GeometryRegistry* reg, b3GeometryHashMap* map, b3GeometryHashMap_itr itr, bool hashPresent,
 								b3GeometryKind kind, uint64_t contentHash, uint8_t* bytes, int byteCount )
 {
-	if ( reg->count >= reg->capacity )
-	{
-		int newCap = reg->capacity < 8 ? 8 : reg->capacity * 2;
-		reg->entries = (b3GeometryEntry*)b3GrowAlloc( reg->entries, reg->capacity * (int)sizeof( b3GeometryEntry ),
-													  newCap * (int)sizeof( b3GeometryEntry ) );
-		reg->capacity = newCap;
-	}
-
-	uint32_t id = (uint32_t)reg->count;
-	b3GeometryEntry* entry = reg->entries + reg->count;
+	uint32_t id = (uint32_t)reg->entries.count;
+	b3GeometryEntry* entry = b3Array_Emplace( reg->entries );
 	entry->contentHash = contentHash;
 	entry->id = id;
 	entry->kind = kind;
 	entry->byteCount = byteCount;
-	entry->bytes = bytes; // take ownership
+	// Take ownership.
+	entry->bytes = bytes;
 	entry->hashNext = hashPresent ? (int)itr.data->val : B3_NULL_INDEX;
-	reg->count++;
 
 	if ( hashPresent )
 	{
@@ -832,11 +824,11 @@ static b3GeometryHashMap* b3RegistryMap( b3GeometryRegistry* reg )
 {
 	if ( reg->dedupMap == NULL )
 	{
-		b3GeometryHashMap* fresh = (b3GeometryHashMap*)b3Alloc( sizeof( b3GeometryHashMap ) );
+		b3GeometryHashMap* fresh = b3Alloc( sizeof( b3GeometryHashMap ) );
 		b3GeometryHashMap_init( fresh );
 		reg->dedupMap = fresh;
 	}
-	return (b3GeometryHashMap*)reg->dedupMap;
+	return reg->dedupMap;
 }
 
 uint32_t b3InternGeometry( b3GeometryRegistry* reg, b3GeometryKind kind, uint64_t contentHash, uint8_t* bytes, int byteCount )
@@ -848,12 +840,12 @@ uint32_t b3InternGeometry( b3GeometryRegistry* reg, b3GeometryKind kind, uint64_
 	if ( hashPresent )
 	{
 		// Walk every entry sharing this hash so a collision still finds the identical blob.
-		for ( int idx = (int)itr.data->val; idx != B3_NULL_INDEX; idx = reg->entries[idx].hashNext )
+		for ( int index = (int)itr.data->val; index != B3_NULL_INDEX; index = reg->entries.data[index].hashNext )
 		{
-			b3GeometryEntry* e = reg->entries + idx;
+			b3GeometryEntry* e = reg->entries.data + index;
 			if ( e->byteCount == byteCount && memcmp( e->bytes, bytes, (size_t)byteCount ) == 0 )
 			{
-				// Duplicate: the caller transferred ownership; return existing id
+				// Duplicate. Free bytes because the caller transferred ownership. Return existing id.
 				b3Free( bytes, (size_t)byteCount );
 				return e->id;
 			}
@@ -873,22 +865,18 @@ uint32_t b3AppendGeometry( b3GeometryRegistry* reg, b3GeometryKind kind, uint64_
 
 void b3FreeRegistry( b3GeometryRegistry* reg )
 {
-	for ( int i = 0; i < reg->count; ++i )
+	for ( int i = 0; i < reg->entries.count; ++i )
 	{
-		b3Free( reg->entries[i].bytes, (size_t)reg->entries[i].byteCount );
-	}
-	if ( reg->entries != NULL )
-	{
-		b3Free( reg->entries, (size_t)( reg->capacity * (int)sizeof( b3GeometryEntry ) ) );
+		b3Free( reg->entries.data[i].bytes, (size_t)reg->entries.data[i].byteCount );
 	}
+
+	b3Array_Destroy( reg->entries );
+
 	if ( reg->dedupMap != NULL )
 	{
 		b3GeometryHashMap_cleanup( (b3GeometryHashMap*)reg->dedupMap );
 		b3Free( reg->dedupMap, sizeof( b3GeometryHashMap ) );
 	}
-	reg->entries = NULL;
-	reg->count = 0;
-	reg->capacity = 0;
 	reg->dedupMap = NULL;
 }
 
@@ -955,10 +943,10 @@ void b3RecInternTag( b3Recording* rec, uint64_t key, uint64_t id, const char* na
 // the tag table stops after the geometry entries and ignores the trailing tag bytes.
 void b3RecWriteRegistry( b3Recording* rec )
 {
-	b3RecW_U32( &rec->buffer, (uint32_t)rec->registry.count );
-	for ( int i = 0; i < rec->registry.count; ++i )
+	b3RecW_U32( &rec->buffer, (uint32_t)rec->registry.entries.count );
+	for ( int i = 0; i < rec->registry.entries.count; ++i )
 	{
-		b3GeometryEntry* e = rec->registry.entries + i;
+		b3GeometryEntry* e = rec->registry.entries.data + i;
 		b3RecW_U8( &rec->buffer, (uint8_t)e->kind );
 		b3RecW_U32( &rec->buffer, (uint32_t)e->byteCount );
 		b3RecBufAppend( &rec->buffer, e->bytes, e->byteCount );
@@ -977,7 +965,7 @@ void b3RecWriteRegistry( b3Recording* rec )
 
 b3Recording* b3CreateRecording( int byteCapacity )
 {
-	b3Recording* rec = (b3Recording*)b3Alloc( sizeof( b3Recording ) );
+	b3Recording* rec = b3Alloc( sizeof( b3Recording ) );
 	*rec = (b3Recording){ 0 };
 
 	int initCap = byteCapacity > 0 ? byteCapacity : 65536;
@@ -1196,7 +1184,7 @@ b3Recording* b3LoadRecordingFromFile( const char* path )
 uint32_t b3RecInternHull( b3Recording* rec, const b3HullData* hull )
 {
 	int byteCount = hull->byteCount;
-	uint8_t* bytes = (uint8_t*)b3Alloc( (size_t)byteCount );
+	uint8_t* bytes = b3Alloc( (size_t)byteCount );
 	memcpy( bytes, hull, (size_t)byteCount );
 	uint64_t h = b3Hash64Blob( bytes, byteCount );
 	return b3InternGeometry( &rec->registry, b3_geometryHull, h, bytes, byteCount );
@@ -1205,7 +1193,7 @@ uint32_t b3RecInternHull( b3Recording* rec, const b3HullData* hull )
 uint32_t b3RecInternMesh( b3Recording* rec, const b3MeshData* mesh )
 {
 	int byteCount = mesh->byteCount;
-	uint8_t* bytes = (uint8_t*)b3Alloc( (size_t)byteCount );
+	uint8_t* bytes = b3Alloc( (size_t)byteCount );
 	memcpy( bytes, mesh, (size_t)byteCount );
 	uint64_t h = b3Hash64Blob( bytes, byteCount );
 	return b3InternGeometry( &rec->registry, b3_geometryMesh, h, bytes, byteCount );
@@ -1214,7 +1202,7 @@ uint32_t b3RecInternMesh( b3Recording* rec, const b3MeshData* mesh )
 uint32_t b3RecInternHeightField( b3Recording* rec, const b3HeightFieldData* hf )
 {
 	int byteCount = hf->byteCount;
-	uint8_t* bytes = (uint8_t*)b3Alloc( (size_t)byteCount );
+	uint8_t* bytes = b3Alloc( (size_t)byteCount );
 	memcpy( bytes, hf, (size_t)byteCount );
 	uint64_t h = b3Hash64Blob( bytes, byteCount );
 	return b3InternGeometry( &rec->registry, b3_geometryHeightField, h, bytes, byteCount );
@@ -1223,7 +1211,7 @@ uint32_t b3RecInternHeightField( b3Recording* rec, const b3HeightFieldData* hf )
 uint32_t b3RecInternCompound( b3Recording* rec, const b3CompoundData* compound )
 {
 	int byteCount = compound->byteCount;
-	uint8_t* bytes = (uint8_t*)b3Alloc( (size_t)byteCount );
+	uint8_t* bytes = b3Alloc( (size_t)byteCount );
 	memcpy( bytes, compound, (size_t)byteCount );
 	// Null the tree node pointer in the copy so the canonical bytes are pointer-free.
 	// b3ConvertBytesToCompound fixes it back on load via nodeOffset.
diff --git a/vendor/box3d/src/src/recording.h b/vendor/box3d/src/src/recording.h
index 3ba2fd3bb..19a96c572 100644
--- a/vendor/box3d/src/src/recording.h
+++ b/vendor/box3d/src/src/recording.h
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include "container.h"
 #include "core.h"
 
 #include "box3d/id.h"
@@ -50,10 +51,10 @@ typedef struct b3World b3World;
 #define B3_REC_VERSION_MAJOR 4
 
 // Minor tracks op-stream additions that keep the 48 byte header shape.
-// Minor version 3 added name cache.
-#define B3_REC_VERSION_MINOR 3
+// Minor version 4 added b3Shape_SetMeshMaterial, b3Shape_SetHull, b3Shape_SetMesh
+#define B3_REC_VERSION_MINOR 4
 
-// File header, fixed 48 bytes, little-endian. Contains the registry locator so the player
+// File header, fixed 48 bytes. Contains the registry locator so the player
 // can load geometry before replaying any ops.
 typedef struct b3RecHeader
 {
@@ -106,13 +107,13 @@ typedef struct b3GeometryEntry
 	int hashNext;
 } b3GeometryEntry;
 
+b3DeclareArray( b3GeometryEntry );
+
 // Growable array of geometry entries. Ids are array indices, so the array is serialized in order.
 // dedupMap maps content hash to entry id for O(1) dedup; it is opaque here and owned by recording.c.
 typedef struct b3GeometryRegistry
 {
-	b3GeometryEntry* entries;
-	int count;
-	int capacity;
+	b3Array( b3GeometryEntry ) entries;
 	void* dedupMap;
 } b3GeometryRegistry;
 
@@ -126,7 +127,7 @@ typedef struct b3GeometryRegistry
 typedef struct b3RecTag
 {
 	// hash of (id, queryName)
-	uint64_t key;				  
+	uint64_t key;
 	uint64_t id;
 	char queryName[B3_MAX_QUERY_NAME_LENGTH + 1];
 } b3RecTag;
diff --git a/vendor/box3d/src/src/recording_ops.inl b/vendor/box3d/src/src/recording_ops.inl
index b8a3625da..3f0cf4260 100644
--- a/vendor/box3d/src/src/recording_ops.inl
+++ b/vendor/box3d/src/src/recording_ops.inl
@@ -68,6 +68,7 @@ B3_REC_OP( 0x36, BodySetMotionLocks, RET_NONE, ARG( BODYID, body ) ARG( LOCKS, l
 B3_REC_OP( 0x37, BodySetBullet, RET_NONE, ARG( BODYID, body ) ARG( BOOL, flag ) )
 B3_REC_OP( 0x38, BodyEnableContactRecycling, RET_NONE, ARG( BODYID, body ) ARG( BOOL, flag ) )
 B3_REC_OP( 0x39, BodyEnableHitEvents, RET_NONE, ARG( BODYID, body ) ARG( BOOL, flag ) )
+B3_REC_OP( 0x3A, BodyAllowFastRotation, RET_NONE, ARG( BODYID, body ) ARG( BOOL, flag ) )
 
 // Shape create/destroy
 B3_REC_OP( 0x40, CreateSphereShape, RET_SHAPEID, ARG( BODYID, body ) ARG( SHAPEDEF, def ) ARG( SPHERE, sphere ) )
@@ -90,9 +91,11 @@ B3_REC_OP( 0x57, ShapeEnablePreSolveEvents, RET_NONE, ARG( SHAPEID, shape ) ARG(
 B3_REC_OP( 0x58, ShapeEnableHitEvents, RET_NONE, ARG( SHAPEID, shape ) ARG( BOOL, flag ) )
 B3_REC_OP( 0x59, ShapeSetSphere, RET_NONE, ARG( SHAPEID, shape ) ARG( SPHERE, sphere ) )
 B3_REC_OP( 0x5A, ShapeSetCapsule, RET_NONE, ARG( SHAPEID, shape ) ARG( CAPSULE, capsule ) )
-B3_REC_OP( 0x5B, ShapeApplyWind, RET_NONE,
-		   ARG( SHAPEID, shape ) ARG( VEC3, wind ) ARG( F32, drag ) ARG( F32, lift ) ARG( F32, maxSpeed ) ARG( BOOL, wake ) )
+B3_REC_OP( 0x5B, ShapeApplyWind, RET_NONE, ARG( SHAPEID, shape ) ARG( VEC3, wind ) ARG( F32, drag ) ARG( F32, lift ) ARG( F32, maxSpeed ) ARG( BOOL, wake ) )
 B3_REC_OP( 0x5C, ShapeSetName, RET_NONE, ARG( SHAPEID, shape ) ARG( STR, name ) )
+B3_REC_OP( 0x5D, ShapeSetMeshMaterial, RET_NONE, ARG( SHAPEID, shape ) ARG( MATERIAL, material ) ARG( I32, index ) )
+B3_REC_OP( 0x5E, ShapeSetHull, RET_NONE, ARG( SHAPEID, shape ) ARG( GEOMID, geometryId ) )
+B3_REC_OP( 0x5F, ShapeSetMesh, RET_NONE, ARG( SHAPEID, shape ) ARG( GEOMID, geometryId ) ARG( VEC3, scale ) )
 
 // Joint create and destroy
 B3_REC_OP( 0x90, CreateParallelJoint, RET_JOINTID, ARG( WORLDID, world ) ARG( PARALLELJOINTDEF, def ) )
diff --git a/vendor/box3d/src/src/recording_replay.c b/vendor/box3d/src/src/recording_replay.c
index 584912d59..f2f578d07 100644
--- a/vendor/box3d/src/src/recording_replay.c
+++ b/vendor/box3d/src/src/recording_replay.c
@@ -957,6 +957,11 @@ static void b3RecDispatch_BodySetBullet( const b3RecArgs_BodySetBullet* a, b3Rec
 	b3Body_SetBullet( b3RecMakeBodyId( rdr, a->body ), a->flag );
 }
 
+static void b3RecDispatch_BodyAllowFastRotation( const b3RecArgs_BodyAllowFastRotation* a, b3RecReader* rdr )
+{
+	b3Body_AllowFastRotation( b3RecMakeBodyId( rdr, a->body ), a->flag );
+}
+
 static void b3RecDispatch_BodyEnableContactRecycling( const b3RecArgs_BodyEnableContactRecycling* a, b3RecReader* rdr )
 {
 	b3Body_EnableContactRecycling( b3RecMakeBodyId( rdr, a->body ), a->flag );
@@ -1019,7 +1024,7 @@ static void b3RecDispatch_CreateMeshShape( const b3RecArgs_CreateMeshShape* a, b
 		return;
 	}
 	b3RegistrySlot* slot = rdr->slots + id;
-	const b3MeshData* mesh = (const b3MeshData*)b3RecGetLiveMesh( slot );
+	const b3MeshData* mesh = b3RecGetLiveMesh( slot );
 	b3BodyId bodyId = b3RecMakeBodyId( rdr, a->body );
 	b3ShapeId gotId = b3CreateMeshShape( bodyId, &a->def, mesh, a->scale );
 	b3RecCheckShapeId( rdr, gotId, recId );
@@ -1071,7 +1076,7 @@ static void b3RecDispatch_CreateCompoundShape( const b3RecArgs_CreateCompoundSha
 	b3BodyId bodyId = b3RecMakeBodyId( rdr, a->body );
 	// b3CreateCompoundShape takes a non-const def pointer; cast away const for the scratch def
 	b3ShapeDef shapeDef = a->def;
-	b3ShapeId gotId = b3CreateCompoundShape( bodyId, &shapeDef, compound );
+	b3ShapeId gotId = b3CreateBakedCompoundShape( bodyId, &shapeDef, compound );
 	b3RecCheckShapeId( rdr, gotId, recId );
 }
 
@@ -1105,6 +1110,11 @@ static void b3RecDispatch_ShapeSetSurfaceMaterial( const b3RecArgs_ShapeSetSurfa
 	b3Shape_SetSurfaceMaterial( b3RecMakeShapeId( rdr, a->shape ), a->material );
 }
 
+static void b3RecDispatch_ShapeSetMeshMaterial( const b3RecArgs_ShapeSetMeshMaterial* a, b3RecReader* rdr )
+{
+	b3Shape_SetMeshMaterial( b3RecMakeShapeId( rdr, a->shape ), a->material, a->index );
+}
+
 static void b3RecDispatch_ShapeSetFilter( const b3RecArgs_ShapeSetFilter* a, b3RecReader* rdr )
 {
 	b3Shape_SetFilter( b3RecMakeShapeId( rdr, a->shape ), a->filter, a->invokeContacts );
@@ -1140,6 +1150,35 @@ static void b3RecDispatch_ShapeSetCapsule( const b3RecArgs_ShapeSetCapsule* a, b
 	b3Shape_SetCapsule( b3RecMakeShapeId( rdr, a->shape ), &a->capsule );
 }
 
+static void b3RecDispatch_ShapeSetHull( const b3RecArgs_ShapeSetHull* a, b3RecReader* rdr )
+{
+	uint32_t id = a->geometryId;
+	if ( id >= (uint32_t)rdr->slotCount )
+	{
+		printf( "b3ReplayFile: hull geometryId %u out of range\n", id );
+		rdr->ok = false;
+		return;
+	}
+	b3RegistrySlot* slot = rdr->slots + id;
+	b3ShapeId shapeId = b3RecMakeShapeId( rdr, a->shape );
+	b3Shape_SetHull( shapeId, (const b3HullData*)slot->bytes );
+}
+
+static void b3RecDispatch_ShapeSetMesh( const b3RecArgs_ShapeSetMesh* a, b3RecReader* rdr )
+{
+	uint32_t id = a->geometryId;
+	if ( id >= (uint32_t)rdr->slotCount )
+	{
+		printf( "b3ReplayFile: mesh geometryId %u out of range\n", id );
+		rdr->ok = false;
+		return;
+	}
+	b3RegistrySlot* slot = rdr->slots + id;
+	b3ShapeId shapeId = b3RecMakeShapeId( rdr, a->shape );
+	const b3MeshData* mesh = b3RecGetLiveMesh( slot );
+	b3Shape_SetMesh( shapeId, mesh, a->scale );
+}
+
 static void b3RecDispatch_ShapeApplyWind( const b3RecArgs_ShapeApplyWind* a, b3RecReader* rdr )
 {
 	b3Shape_ApplyWind( b3RecMakeShapeId( rdr, a->shape ), a->wind, a->drag, a->lift, a->maxSpeed, a->wake );
@@ -2576,12 +2615,12 @@ static void b3RecCaptureKeyframe( b3RecPlayer* player )
 	b3World* world = b3GetWorldFromId( player->rdr.replayWorldId );
 	b3RecBuffer buf = { 0 };
 
-	int regCountBefore = player->keyframeRec->registry.count;
+	int regCountBefore = player->keyframeRec->registry.entries.count;
 	B3_UNUSED( regCountBefore );
 
 	b3SerializeWorld( world, &buf, player->keyframeRec );
 	// Registry must not grow: all geometry was pre-seeded and the registry dedups exactly.
-	B3_ASSERT( player->keyframeRec->registry.count == regCountBefore );
+	B3_ASSERT( player->keyframeRec->registry.entries.count == regCountBefore );
 
 	size_t bodyBytes = (size_t)player->bodyIdCount * sizeof( b3BodyId );
 	size_t newBytes = (size_t)buf.capacity + bodyBytes;
diff --git a/vendor/box3d/src/src/sensor.c b/vendor/box3d/src/src/sensor.c
index 0cd23a460..056708a3b 100644
--- a/vendor/box3d/src/src/sensor.c
+++ b/vendor/box3d/src/src/sensor.c
@@ -107,9 +107,8 @@ static bool b3SensorQueryCallback( int proxyId, uint64_t userData, void* context
 	b3World* world = queryContext->world;
 	b3Shape* otherShape = b3Array_Get( world->shapes, shapeId );
 
-	// Mesh vs mesh is not supported
-	if ( ( otherShape->type == b3_meshShape || otherShape->type == b3_heightShape ) &&
-		 ( sensorShape->type == b3_meshShape || sensorShape->type == b3_heightShape ) )
+	// Visitors must be convex.
+	if ( b3IsConvex( otherShape->type ) == false )
 	{
 		return true;
 	}
diff --git a/vendor/box3d/src/src/shape.c b/vendor/box3d/src/src/shape.c
index e4d9d9e0c..eabc1eb55 100644
--- a/vendor/box3d/src/src/shape.c
+++ b/vendor/box3d/src/src/shape.c
@@ -424,7 +424,7 @@ b3ShapeId b3CreateHeightFieldShape( b3BodyId bodyId, const b3ShapeDef* def, cons
 	return shapeId;
 }
 
-b3ShapeId b3CreateCompoundShape( b3BodyId bodyId, b3ShapeDef* def, const b3CompoundData* compound )
+b3ShapeId b3CreateBakedCompoundShape( b3BodyId bodyId, b3ShapeDef* def, const b3CompoundData* compound )
 {
 	b3ShapeId shapeId = b3CreateShape( bodyId, def, compound, b3_compoundShape, b3Transform_identity, b3Vec3_one, false );
 	if ( shapeId.index1 != 0 )
@@ -1295,6 +1295,8 @@ void b3Shape_SetMeshMaterial( b3ShapeId shapeId, b3SurfaceMaterial surfaceMateri
 
 	B3_ASSERT( 0 <= index && index < shape->materialCount );
 	B3_ASSERT( shape->type != b3_compoundShape );
+
+	B3_REC( world, ShapeSetMeshMaterial, shapeId, surfaceMaterial, index );
 	b3GetShapeMaterials( shape )[index] = surfaceMaterial;
 }
 
@@ -1613,6 +1615,14 @@ void b3Shape_SetHull( b3ShapeId shapeId, const b3HullData* hull )
 		return;
 	}
 
+	if ( world->recording != NULL )
+	{
+		// Intern the shared hull.
+		uint32_t geometryId = b3RecInternHull( world->recording, data );
+		b3RecArgs_ShapeSetHull setArgs = { shapeId, geometryId };
+		b3RecWrite_ShapeSetHull( world->recording, &setArgs );
+	}
+
 	b3DestroyShapeAllocationForShapeChange( world, shape );
 
 	shape->hull = data;
@@ -1640,6 +1650,13 @@ void b3Shape_SetMesh( b3ShapeId shapeId, const b3MeshData* meshData, b3Vec3 scal
 
 	world->locked = true;
 
+	if ( world->recording != NULL )
+	{
+		uint32_t geometryId = b3RecInternMesh( world->recording, meshData );
+		b3RecArgs_ShapeSetMesh setArgs = { shapeId, geometryId, scale };
+		b3RecWrite_ShapeSetMesh( world->recording, &setArgs );
+	}
+
 	b3Shape* shape = b3GetShape( world, shapeId );
 
 	b3DestroyShapeAllocationForShapeChange( world, shape );
diff --git a/vendor/box3d/src/src/shape.h b/vendor/box3d/src/src/shape.h
index 519ce8694..ed76dd41c 100644
--- a/vendor/box3d/src/src/shape.h
+++ b/vendor/box3d/src/src/shape.h
@@ -153,3 +153,8 @@ static inline bool b3ShouldQueryCollide( const b3Filter* shapeFilter, const b3Qu
 	return ( shapeFilter->categoryBits & queryFilter->maskBits ) != 0 &&
 		   ( shapeFilter->maskBits & queryFilter->categoryBits ) != 0;
 }
+
+static inline bool b3IsConvex( b3ShapeType type )
+{
+	return type == b3_sphereShape || type == b3_capsuleShape || type == b3_hullShape;
+}
diff --git a/vendor/box3d/src/src/simd.h b/vendor/box3d/src/src/simd.h
index ac7e9e8b5..6e313a0a4 100644
--- a/vendor/box3d/src/src/simd.h
+++ b/vendor/box3d/src/src/simd.h
@@ -7,10 +7,35 @@
 
 #include <stdbool.h>
 
-#if defined( B3_SIMD_SSE2 )
+#if defined( B3_SIMD_NEON )
+
+#include <arm_neon.h>
+
+// wide float holds 4 numbers
+typedef float32x4_t b3FloatW;
+
+#elif defined( B3_SIMD_SSE2 )
 
 #include <emmintrin.h>
 
+// wide float holds 4 numbers
+typedef __m128 b3FloatW;
+
+#else
+
+#include <math.h>
+#include <string.h>
+
+// scalar math
+typedef struct b3FloatW
+{
+	float x, y, z, w;
+} b3FloatW;
+
+#endif
+
+#if defined( B3_SIMD_SSE2 )
+
 // wide float holds 4 numbers
 typedef __m128 b3V32;
 
@@ -355,3 +380,544 @@ static inline bool b3TestBoundsRayOverlap( b3V32 nodeMin, b3V32 nodeMax, b3V32 r
 
 bool b3TestBoundsTriangleOverlap( b3V32 nodeCenter, b3V32 nodeExtent, b3V32 vertex1, b3V32 vertex2, b3V32 vertex3 );
 float b3IntersectRayTriangle( b3V32 rayStart, b3V32 rayDelta, b3V32 vertex1, b3V32 vertex2, b3V32 vertex3 );
+
+#if defined( B3_SIMD_NEON )
+
+static inline b3FloatW b3ZeroW( void )
+{
+	return vdupq_n_f32( 0.0f );
+}
+
+static inline b3FloatW b3SplatW( float scalar )
+{
+	return vdupq_n_f32( scalar );
+}
+
+static inline b3FloatW b3SetW( float a, float b, float c, float d )
+{
+	float32_t array[4] = { a, b, c, d };
+	return vld1q_f32( array );
+}
+
+static inline b3FloatW b3LoadW( const float* data )
+{
+	return vld1q_f32( data );
+}
+
+static inline void b3StoreW( float* data, b3FloatW a )
+{
+	vst1q_f32( data, a );
+}
+
+static inline b3FloatW b3NegW( b3FloatW a )
+{
+	return vnegq_f32( a );
+}
+
+static inline b3FloatW b3AddW( b3FloatW a, b3FloatW b )
+{
+	return vaddq_f32( a, b );
+}
+
+static inline b3FloatW b3SubW( b3FloatW a, b3FloatW b )
+{
+	return vsubq_f32( a, b );
+}
+
+static inline b3FloatW b3MulW( b3FloatW a, b3FloatW b )
+{
+	return vmulq_f32( a, b );
+}
+
+static inline b3FloatW b3DivW( b3FloatW a, b3FloatW b )
+{
+	return vdivq_f32( a, b );
+}
+
+static inline b3FloatW b3SqrtW( b3FloatW a )
+{
+	return vsqrtq_f32( a );
+}
+
+// Cannot use real FMA because it doesn't match the non-SIMD path
+static inline b3FloatW b3MulAddW( b3FloatW a, b3FloatW b, b3FloatW c )
+{
+	return vaddq_f32( a, vmulq_f32( b, c ) );
+}
+
+static inline b3FloatW b3MinW( b3FloatW a, b3FloatW b )
+{
+	return vminq_f32( a, b );
+}
+
+static inline b3FloatW b3MaxW( b3FloatW a, b3FloatW b )
+{
+	return vmaxq_f32( a, b );
+}
+
+// clamp a to [-b, b]
+static inline b3FloatW b3SymClampW( b3FloatW a, b3FloatW b )
+{
+	b3FloatW nb = b3NegW( b );
+	b3FloatW c = b3MaxW( nb, a );
+	return b3MinW( c, b );
+}
+
+static inline b3FloatW b3AndW( b3FloatW a, b3FloatW b )
+{
+	return vreinterpretq_f32_u32( vandq_u32( vreinterpretq_u32_f32( a ), vreinterpretq_u32_f32( b ) ) );
+}
+
+static inline b3FloatW b3OrW( b3FloatW a, b3FloatW b )
+{
+	return vreinterpretq_f32_u32( vorrq_u32( vreinterpretq_u32_f32( a ), vreinterpretq_u32_f32( b ) ) );
+}
+
+static inline b3FloatW b3GreaterThanW( b3FloatW a, b3FloatW b )
+{
+	return vreinterpretq_f32_u32( vcgtq_f32( a, b ) );
+}
+
+static inline b3FloatW b3LessThanW( b3FloatW a, b3FloatW b )
+{
+	return vreinterpretq_f32_u32( vcltq_f32( a, b ) );
+}
+
+static inline b3FloatW b3EqualsW( b3FloatW a, b3FloatW b )
+{
+	return vreinterpretq_f32_u32( vceqq_f32( a, b ) );
+}
+
+static inline bool b3AllZeroW( b3FloatW a )
+{
+	// Create a zero vector for comparison
+	b3FloatW zero = vdupq_n_f32( 0.0f );
+
+	// Compare the input vector with zero
+	uint32x4_t cmp_result = vceqq_f32( a, zero );
+
+// Check if all comparison results are non-zero using vminvq
+#ifdef __ARM_FEATURE_SVE
+	// ARM v8.2+ has horizontal minimum instruction
+	return vminvq_u32( cmp_result ) != 0;
+#else
+	// For older ARM architectures, we need to manually check all lanes
+	return vgetq_lane_u32( cmp_result, 0 ) != 0 && vgetq_lane_u32( cmp_result, 1 ) != 0 && vgetq_lane_u32( cmp_result, 2 ) != 0 &&
+		   vgetq_lane_u32( cmp_result, 3 ) != 0;
+#endif
+}
+
+// _mm_movemask_ps equivalent, compatible with ARM v7.
+static inline bool b3AnyTrueW( b3FloatW mask )
+{
+	uint32x4_t m = vreinterpretq_u32_f32( mask );
+	uint32x2_t p = vorr_u32( vget_low_u32( m ), vget_high_u32( m ) );
+	return ( vget_lane_u32( p, 0 ) | vget_lane_u32( p, 1 ) ) != 0;
+}
+
+// component-wise returns mask ? b : a
+static inline b3FloatW b3BlendW( b3FloatW a, b3FloatW b, b3FloatW mask )
+{
+	uint32x4_t mask32 = vreinterpretq_u32_f32( mask );
+	return vbslq_f32( mask32, b, a );
+}
+
+static inline b3FloatW b3Dot3W( b3FloatW ax, b3FloatW ay, b3FloatW az, b3FloatW bx, b3FloatW by, b3FloatW bz )
+{
+	return vaddq_f32( vmulq_f32( ax, bx ), vaddq_f32( vmulq_f32( ay, by ), vmulq_f32( az, bz ) ) );
+}
+
+static inline b3FloatW b3EmbedIndexW( b3FloatW value, int baseIndex, int bitCount )
+{
+	uint32_t mask = ( 1u << bitCount ) - 1;
+	const int32_t lanes[4] = { 0, 1, 2, 3 };
+	int32x4_t index = vaddq_s32( vdupq_n_s32( baseIndex ), vld1q_s32( lanes ) );
+	uint32x4_t clearLow = vdupq_n_u32( ~mask );
+	uint32x4_t bits = vorrq_u32( vandq_u32( vreinterpretq_u32_f32( value ), clearLow ), vreinterpretq_u32_s32( index ) );
+	return vreinterpretq_f32_u32( bits );
+}
+
+static inline int b3MinIndexW( b3FloatW a, int bitCount )
+{
+	float32x2_t m = vmin_f32( vget_low_f32( a ), vget_high_f32( a ) );
+	m = vpmin_f32( m, m );
+	uint32_t bits = vget_lane_u32( vreinterpret_u32_f32( m ), 0 );
+	return (int)( bits & ( ( 1u << bitCount ) - 1 ) );
+}
+
+#elif defined( B3_SIMD_SSE2 )
+
+static inline b3FloatW b3ZeroW( void )
+{
+	return _mm_setzero_ps();
+}
+
+static inline b3FloatW b3SplatW( float scalar )
+{
+	return _mm_set1_ps( scalar );
+}
+
+static inline b3FloatW b3SetW( float a, float b, float c, float d )
+{
+	return _mm_setr_ps( a, b, c, d );
+}
+
+static inline b3FloatW b3LoadW( const float* data )
+{
+	return _mm_loadu_ps( data );
+}
+
+static inline void b3StoreW( float* data, b3FloatW a )
+{
+	_mm_storeu_ps( data, a );
+}
+
+static inline b3FloatW b3NegW( b3FloatW a )
+{
+	// Create a mask with the sign bit set for each element
+	__m128 mask = _mm_set1_ps( -0.0f );
+
+	// XOR the input with the mask to negate each element
+	return _mm_xor_ps( a, mask );
+}
+
+static inline b3FloatW b3AddW( b3FloatW a, b3FloatW b )
+{
+	return _mm_add_ps( a, b );
+}
+
+static inline b3FloatW b3SubW( b3FloatW a, b3FloatW b )
+{
+	return _mm_sub_ps( a, b );
+}
+
+static inline b3FloatW b3MulW( b3FloatW a, b3FloatW b )
+{
+	return _mm_mul_ps( a, b );
+}
+
+static inline b3FloatW b3DivW( b3FloatW a, b3FloatW b )
+{
+	return _mm_div_ps( a, b );
+}
+
+static inline b3FloatW b3SqrtW( b3FloatW a )
+{
+	return _mm_sqrt_ps( a );
+}
+
+// a + b * c
+static inline b3FloatW b3MulAddW( b3FloatW a, b3FloatW b, b3FloatW c )
+{
+	return _mm_add_ps( a, _mm_mul_ps( b, c ) );
+}
+
+static inline b3FloatW b3MinW( b3FloatW a, b3FloatW b )
+{
+	return _mm_min_ps( a, b );
+}
+
+static inline b3FloatW b3MaxW( b3FloatW a, b3FloatW b )
+{
+	return _mm_max_ps( a, b );
+}
+
+// Horizontal min over a 4-lane vector (result broadcast to all lanes).
+static inline b3FloatW b3HorizontalMinW( b3FloatW v )
+{
+	v = _mm_min_ps( v, _mm_shuffle_ps( v, v, _MM_SHUFFLE( 2, 3, 0, 1 ) ) );
+	return _mm_min_ps( v, _mm_shuffle_ps( v, v, _MM_SHUFFLE( 1, 0, 3, 2 ) ) );
+}
+
+// clamp a to [-b, b]
+static inline b3FloatW b3SymClampW( b3FloatW a, b3FloatW b )
+{
+	b3FloatW nb = b3NegW( b );
+	b3FloatW c = b3MaxW( nb, a );
+	return b3MinW( c, b );
+}
+
+static inline b3FloatW b3AndW( b3FloatW a, b3FloatW b )
+{
+	return _mm_and_ps( a, b );
+}
+
+static inline b3FloatW b3OrW( b3FloatW a, b3FloatW b )
+{
+	return _mm_or_ps( a, b );
+}
+
+static inline b3FloatW b3GreaterThanW( b3FloatW a, b3FloatW b )
+{
+	return _mm_cmpgt_ps( a, b );
+}
+
+static inline b3FloatW b3LessThanW( b3FloatW a, b3FloatW b )
+{
+	return _mm_cmplt_ps( a, b );
+}
+
+static inline b3FloatW b3EqualsW( b3FloatW a, b3FloatW b )
+{
+	return _mm_cmpeq_ps( a, b );
+}
+
+static inline bool b3AllZeroW( b3FloatW a )
+{
+	// Compare each element with zero
+	b3FloatW zero = _mm_setzero_ps();
+	b3FloatW cmp = _mm_cmpeq_ps( a, zero );
+
+	// Create a mask from the comparison results
+	int mask = _mm_movemask_ps( cmp );
+
+	// If all elements are zero, the mask will be 0xF (1111 in binary)
+	return mask == 0xF;
+}
+
+static inline bool b3AnyTrueW( b3FloatW mask )
+{
+	return _mm_movemask_ps( mask ) != 0;
+}
+
+// component-wise returns mask ? b : a
+static inline b3FloatW b3BlendW( b3FloatW a, b3FloatW b, b3FloatW mask )
+{
+	return _mm_or_ps( _mm_and_ps( mask, b ), _mm_andnot_ps( mask, a ) );
+}
+
+static inline b3FloatW b3Dot3W( b3FloatW ax, b3FloatW ay, b3FloatW az, b3FloatW bx, b3FloatW by, b3FloatW bz )
+{
+	return _mm_add_ps( _mm_mul_ps( ax, bx ), _mm_add_ps( _mm_mul_ps( ay, by ), _mm_mul_ps( az, bz ) ) );
+}
+
+// Replace the low bitCount mantissa bits of each lane with baseIndex + lane. The value must be
+// positive so the embedded index sorts with the value, and ties fall to the lower index.
+static inline b3FloatW b3EmbedIndexW( b3FloatW value, int baseIndex, int bitCount )
+{
+	int mask = ( 1 << bitCount ) - 1;
+	__m128i index = _mm_add_epi32( _mm_set1_epi32( baseIndex ), _mm_setr_epi32( 0, 1, 2, 3 ) );
+	__m128 clearLow = _mm_castsi128_ps( _mm_set1_epi32( ~mask ) );
+	return _mm_or_ps( _mm_and_ps( value, clearLow ), _mm_castsi128_ps( index ) );
+}
+
+// Recovers the index embedded by b3EmbedIndexW from the lane holding the minimum.
+static inline int b3MinIndexW( b3FloatW a, int bitCount )
+{
+	a = _mm_min_ps( a, _mm_shuffle_ps( a, a, _MM_SHUFFLE( 2, 3, 0, 1 ) ) );
+	a = _mm_min_ps( a, _mm_shuffle_ps( a, a, _MM_SHUFFLE( 1, 0, 3, 2 ) ) );
+	return _mm_cvtsi128_si32( _mm_castps_si128( a ) ) & ( ( 1 << bitCount ) - 1 );
+}
+
+#else
+
+static inline b3FloatW b3ZeroW( void )
+{
+	return (b3FloatW){ 0.0f, 0.0f, 0.0f, 0.0f };
+}
+
+static inline b3FloatW b3SplatW( float scalar )
+{
+	return (b3FloatW){ scalar, scalar, scalar, scalar };
+}
+
+static inline b3FloatW b3SetW( float a, float b, float c, float d )
+{
+	return (b3FloatW){ a, b, c, d };
+}
+
+static inline b3FloatW b3LoadW( const float* data )
+{
+	return (b3FloatW){ data[0], data[1], data[2], data[3] };
+}
+
+static inline void b3StoreW( float* data, b3FloatW a )
+{
+	data[0] = a.x;
+	data[1] = a.y;
+	data[2] = a.z;
+	data[3] = a.w;
+}
+
+static inline b3FloatW b3NegW( b3FloatW a )
+{
+	return (b3FloatW){ -a.x, -a.y, -a.z, -a.w };
+}
+
+static inline b3FloatW b3AddW( b3FloatW a, b3FloatW b )
+{
+	return (b3FloatW){ a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w };
+}
+
+static inline b3FloatW b3SubW( b3FloatW a, b3FloatW b )
+{
+	return (b3FloatW){ a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w };
+}
+
+static inline b3FloatW b3MulW( b3FloatW a, b3FloatW b )
+{
+	return (b3FloatW){ a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w };
+}
+
+static inline b3FloatW b3DivW( b3FloatW a, b3FloatW b )
+{
+	return (b3FloatW){ a.x / b.x, a.y / b.y, a.z / b.z, a.w / b.w };
+}
+
+static inline b3FloatW b3SqrtW( b3FloatW a )
+{
+	return (b3FloatW){ sqrtf( a.x ), sqrtf( a.y ), sqrtf( a.z ), sqrtf( a.w ) };
+}
+
+static inline b3FloatW b3MulAddW( b3FloatW a, b3FloatW b, b3FloatW c )
+{
+	return (b3FloatW){ a.x + b.x * c.x, a.y + b.y * c.y, a.z + b.z * c.z, a.w + b.w * c.w };
+}
+
+static inline b3FloatW b3MinW( b3FloatW a, b3FloatW b )
+{
+	b3FloatW r;
+	r.x = a.x <= b.x ? a.x : b.x;
+	r.y = a.y <= b.y ? a.y : b.y;
+	r.z = a.z <= b.z ? a.z : b.z;
+	r.w = a.w <= b.w ? a.w : b.w;
+	return r;
+}
+
+static inline b3FloatW b3MaxW( b3FloatW a, b3FloatW b )
+{
+	b3FloatW r;
+	r.x = a.x >= b.x ? a.x : b.x;
+	r.y = a.y >= b.y ? a.y : b.y;
+	r.z = a.z >= b.z ? a.z : b.z;
+	r.w = a.w >= b.w ? a.w : b.w;
+	return r;
+}
+
+// clamp a to [-b, b]
+static inline b3FloatW b3SymClampW( b3FloatW a, b3FloatW b )
+{
+	b3FloatW r;
+	r.x = a.x <= b.x ? a.x : b.x;
+	r.y = a.y <= b.y ? a.y : b.y;
+	r.z = a.z <= b.z ? a.z : b.z;
+	r.w = a.w <= b.w ? a.w : b.w;
+	r.x = r.x <= -b.x ? -b.x : r.x;
+	r.y = r.y <= -b.y ? -b.y : r.y;
+	r.z = r.z <= -b.z ? -b.z : r.z;
+	r.w = r.w <= -b.w ? -b.w : r.w;
+	return r;
+}
+
+// Logical operations on the scalar path are 0/1 float values. Not bit-wise like SIMD.
+
+static inline b3FloatW b3AndW( b3FloatW a, b3FloatW b )
+{
+	b3FloatW r;
+	r.x = a.x != 0.0f && b.x != 0.0f ? 1.0f : 0.0f;
+	r.y = a.y != 0.0f && b.y != 0.0f ? 1.0f : 0.0f;
+	r.z = a.z != 0.0f && b.z != 0.0f ? 1.0f : 0.0f;
+	r.w = a.w != 0.0f && b.w != 0.0f ? 1.0f : 0.0f;
+	return r;
+}
+
+static inline b3FloatW b3OrW( b3FloatW a, b3FloatW b )
+{
+	b3FloatW r;
+	r.x = a.x != 0.0f || b.x != 0.0f ? 1.0f : 0.0f;
+	r.y = a.y != 0.0f || b.y != 0.0f ? 1.0f : 0.0f;
+	r.z = a.z != 0.0f || b.z != 0.0f ? 1.0f : 0.0f;
+	r.w = a.w != 0.0f || b.w != 0.0f ? 1.0f : 0.0f;
+	return r;
+}
+
+static inline b3FloatW b3GreaterThanW( b3FloatW a, b3FloatW b )
+{
+	b3FloatW r;
+	r.x = a.x > b.x ? 1.0f : 0.0f;
+	r.y = a.y > b.y ? 1.0f : 0.0f;
+	r.z = a.z > b.z ? 1.0f : 0.0f;
+	r.w = a.w > b.w ? 1.0f : 0.0f;
+	return r;
+}
+
+static inline b3FloatW b3LessThanW( b3FloatW a, b3FloatW b )
+{
+	b3FloatW r;
+	r.x = a.x < b.x ? 1.0f : 0.0f;
+	r.y = a.y < b.y ? 1.0f : 0.0f;
+	r.z = a.z < b.z ? 1.0f : 0.0f;
+	r.w = a.w < b.w ? 1.0f : 0.0f;
+	return r;
+}
+
+static inline b3FloatW b3EqualsW( b3FloatW a, b3FloatW b )
+{
+	b3FloatW r;
+	r.x = a.x == b.x ? 1.0f : 0.0f;
+	r.y = a.y == b.y ? 1.0f : 0.0f;
+	r.z = a.z == b.z ? 1.0f : 0.0f;
+	r.w = a.w == b.w ? 1.0f : 0.0f;
+	return r;
+}
+
+static inline bool b3AllZeroW( b3FloatW a )
+{
+	return a.x == 0.0f && a.y == 0.0f && a.z == 0.0f && a.w == 0.0f;
+}
+
+static inline bool b3AnyTrueW( b3FloatW mask )
+{
+	return mask.x != 0.0f || mask.y != 0.0f || mask.z != 0.0f || mask.w != 0.0f;
+}
+
+// component-wise returns mask ? b : a
+static inline b3FloatW b3BlendW( b3FloatW a, b3FloatW b, b3FloatW mask )
+{
+	b3FloatW r;
+	r.x = mask.x != 0.0f ? b.x : a.x;
+	r.y = mask.y != 0.0f ? b.y : a.y;
+	r.z = mask.z != 0.0f ? b.z : a.z;
+	r.w = mask.w != 0.0f ? b.w : a.w;
+	return r;
+}
+
+static inline b3FloatW b3Dot3W( b3FloatW ax, b3FloatW ay, b3FloatW az, b3FloatW bx, b3FloatW by, b3FloatW bz )
+{
+	b3FloatW r;
+	r.x = ax.x * bx.x + ( ay.x * by.x + az.x * bz.x );
+	r.y = ax.y * bx.y + ( ay.y * by.y + az.y * bz.y );
+	r.z = ax.z * bx.z + ( ay.z * by.z + az.z * bz.z );
+	r.w = ax.w * bx.w + ( ay.w * by.w + az.w * bz.w );
+	return r;
+}
+
+static inline b3FloatW b3EmbedIndexW( b3FloatW value, int baseIndex, int bitCount )
+{
+	uint32_t mask = ( 1u << bitCount ) - 1;
+	float lanes[4] = { value.x, value.y, value.z, value.w };
+
+	for ( int i = 0; i < 4; ++i )
+	{
+		uint32_t bits;
+		memcpy( &bits, lanes + i, sizeof( bits ) );
+		bits = ( bits & ~mask ) | (uint32_t)( baseIndex + i );
+		memcpy( lanes + i, &bits, sizeof( bits ) );
+	}
+
+	return (b3FloatW){ lanes[0], lanes[1], lanes[2], lanes[3] };
+}
+
+static inline int b3MinIndexW( b3FloatW a, int bitCount )
+{
+	float m = a.x;
+	m = a.y < m ? a.y : m;
+	m = a.z < m ? a.z : m;
+	m = a.w < m ? a.w : m;
+
+	uint32_t bits;
+	memcpy( &bits, &m, sizeof( bits ) );
+	return (int)( bits & ( ( 1u << bitCount ) - 1 ) );
+}
+
+#endif
diff --git a/vendor/box3d/src/src/solver.c b/vendor/box3d/src/src/solver.c
index a2b1be977..d8aace052 100644
--- a/vendor/box3d/src/src/solver.c
+++ b/vendor/box3d/src/src/solver.c
@@ -24,6 +24,8 @@
 #include <stddef.h>
 #include <stdio.h>
 
+_Static_assert( B3_RESTITUTION_ITERATIONS >= 1, "must be 1 or more" );
+
 // these are useful for solver testing
 #define ITERATIONS 1
 #define RELAX_ITERATIONS 1
@@ -118,33 +120,33 @@ static void b3IntegrateVelocitiesTask( b3SolverBlock block, b3StepContext* conte
 			b3Vec3 omega2 = omega1;
 
 			// Symmetric inertia tensor: 6 unique entries (column-major)
-			const float i00 = inertiaLocal.cx.x;
-			const float i01 = inertiaLocal.cy.x;
-			const float i02 = inertiaLocal.cz.x;
-			const float i11 = inertiaLocal.cy.y;
-			const float i12 = inertiaLocal.cz.y;
-			const float i22 = inertiaLocal.cz.z;
+			float i00 = inertiaLocal.cx.x;
+			float i01 = inertiaLocal.cy.x;
+			float i02 = inertiaLocal.cz.x;
+			float i11 = inertiaLocal.cy.y;
+			float i12 = inertiaLocal.cz.y;
+			float i22 = inertiaLocal.cz.z;
 
-			for ( int gyroIteration = 0; gyroIteration < 1; ++gyroIteration )
+			for ( int gyroIteration = 0; gyroIteration < B3_GYROSCOPIC_ITERATIONS; ++gyroIteration )
 			{
-				const float w1 = omega2.x;
-				const float w2 = omega2.y;
-				const float w3 = omega2.z;
+				float w1 = omega2.x;
+				float w2 = omega2.y;
+				float w3 = omega2.z;
 
 				// Iw = I * omega2 (shared between residual and Jacobian)
-				const float Iw1 = i00 * w1 + i01 * w2 + i02 * w3;
-				const float Iw2 = i01 * w1 + i11 * w2 + i12 * w3;
-				const float Iw3 = i02 * w1 + i12 * w2 + i22 * w3;
+				float Iw1 = i00 * w1 + i01 * w2 + i02 * w3;
+				float Iw2 = i01 * w1 + i11 * w2 + i12 * w3;
+				float Iw3 = i02 * w1 + i12 * w2 + i22 * w3;
 
-				// Residual: b = I*(omega2 - omega1) + h * (omega2 × I*omega2)
-				const b3Vec3 dw = b3Sub( omega2, omega1 );
+				// Residual: b = I * (omega2 - omega1) + h * cross(omega2, I * omega2)
+				b3Vec3 dw = b3Sub( omega2, omega1 );
 				b3Vec3 b = {
 					i00 * dw.x + i01 * dw.y + i02 * dw.z + h * ( w2 * Iw3 - w3 * Iw2 ),
 					i01 * dw.x + i11 * dw.y + i12 * dw.z + h * ( w3 * Iw1 - w1 * Iw3 ),
 					i02 * dw.x + i12 * dw.y + i22 * dw.z + h * ( w1 * Iw2 - w2 * Iw1 ),
 				};
 
-				// Jacobian J = I + h * (skew(omega2) * I - skew(I*omega2))
+				// Jacobian J = I + h * (skew(omega2) * I - skew(I * omega2))
 				// Jacobian derived by Erin Catto, Ph.D. Do not attempt to do this without a Ph.D.
 				// Doubled inertia terms above fold into Iw, e.g. row 2 col 1: i00*w3 - i02*w1 - Iw3.
 				b3Matrix3 J = {
@@ -1313,6 +1315,7 @@ static void b3SolverTask( void* taskContext )
 		stageIndex += 1 + activeColorCount + ITERATIONS * activeColorCount + 1 + RELAX_ITERATIONS * activeColorCount;
 
 		// Restitution
+		for ( int iteration = 0; iteration < B3_RESTITUTION_ITERATIONS; ++iteration )
 		{
 			b3ApplyRestitution_Overflow( context );
 
@@ -1324,7 +1327,7 @@ static void b3SolverTask( void* taskContext )
 				b3ExecuteMainStage( stages + iterStageIndex, context, syncBits );
 				iterStageIndex += 1;
 			}
-			// graphSyncIndex += 1;
+			graphSyncIndex += 1;
 			stageIndex += activeColorCount;
 		}
 
@@ -1690,7 +1693,7 @@ void b3Solve( b3World* world, b3StepContext* stepContext )
 		// b3_stageRelax
 		stageCount += RELAX_ITERATIONS * activeColorCount;
 		// b3_stageRestitution
-		stageCount += activeColorCount;
+		stageCount += B3_RESTITUTION_ITERATIONS * activeColorCount;
 		// b3_stageStoreWideImpulses
 		stageCount += 1;
 		// b3_stageStoreImpulses
@@ -1775,8 +1778,8 @@ void b3Solve( b3World* world, b3StepContext* stepContext )
 		stage = b3InitColorStages( stage, b3_stageRelax, RELAX_ITERATIONS, activeColorCount, graphColorBlocks, graphBlockCounts,
 								   activeColorIndices );
 		// Note: joint blocks mixed in, could have joint limit restitution
-		stage = b3InitColorStages( stage, b3_stageRestitution, 1, activeColorCount, graphColorBlocks, graphBlockCounts,
-								   activeColorIndices );
+		stage = b3InitColorStages( stage, b3_stageRestitution, B3_RESTITUTION_ITERATIONS, activeColorCount, graphColorBlocks,
+								   graphBlockCounts, activeColorIndices );
 		stage = b3InitStage( stage, b3_stageStoreWideImpulses, convexBlocks, convexPrepareDim.count, UINT8_MAX );
 		stage = b3InitStage( stage, b3_stageStoreImpulses, meshBlocks, meshPrepareDim.count, UINT8_MAX );
 
diff --git a/vendor/box3d/src/src/timer.c b/vendor/box3d/src/src/timer.c
index 826b1495c..f779e3bbb 100644
--- a/vendor/box3d/src/src/timer.c
+++ b/vendor/box3d/src/src/timer.c
@@ -23,7 +23,8 @@
 #define WIN32_LEAN_AND_MEAN 1
 #endif
 
-#include <Windows.h>
+// Lower-case windows.h intentionally for cross compiling on mingw.
+#include <windows.h>
 #include <limits.h>
 
 static double s_invFrequency = 0.0;
@@ -517,7 +518,7 @@ typedef struct b3Thread
 	char name[NAME_LENGTH];
 } b3Thread;
 
-// macOS pthread_setname_np takes only the name — it always names the calling thread.
+// macOS pthread_setname_np takes only the name, it always names the calling thread.
 static void b3SetCurrentThreadName( const char* name )
 {
 	if ( name == NULL || name[0] == 0 )
diff --git a/vendor/box3d/src/src/triangle_manifold.c b/vendor/box3d/src/src/triangle_manifold.c
index b87973add..3de7fee23 100644
--- a/vendor/box3d/src/src/triangle_manifold.c
+++ b/vendor/box3d/src/src/triangle_manifold.c
@@ -18,7 +18,6 @@ typedef struct b3TriangleData
 {
 	b3Vec3 v1, v2, v3;
 	b3Vec3 e1, e2, e3;
-	b3Vec3 center;
 	b3Plane plane;
 	int flags;
 } b3TriangleData;
@@ -51,7 +50,7 @@ static b3TriangleFeature b3GetTriangleFeature( const b3SimplexCache* cache )
 	return s_triangleFeatures[mask];
 }
 
-void b3CollideSphereAndTriangle( b3LocalManifold* manifold, int capacity, const b3Sphere* sphereA, const b3Vec3* triangleB )
+void b3CollideTriangleAndSphere( b3LocalManifold* manifold, int capacity, const b3Vec3* triangleA, const b3Sphere* sphereB )
 {
 	manifold->pointCount = 0;
 
@@ -60,8 +59,8 @@ void b3CollideSphereAndTriangle( b3LocalManifold* manifold, int capacity, const
 		return;
 	}
 
-	b3Vec3 center = sphereA->center;
-	b3Vec3 v1 = triangleB[0], v2 = triangleB[1], v3 = triangleB[2];
+	b3Vec3 center = sphereB->center;
+	b3Vec3 v1 = triangleA[0], v2 = triangleA[1], v3 = triangleA[2];
 	b3Plane plane = b3MakePlaneFromPoints( v1, v2, v3 );
 
 	float offset = b3PlaneSeparation( plane, center );
@@ -71,19 +70,23 @@ void b3CollideSphereAndTriangle( b3LocalManifold* manifold, int capacity, const
 		return;
 	}
 
+	float radius = sphereB->radius;
+
 	// Closest point on triangle to sphere center
 	b3TrianglePoint closest = b3ClosestPointOnTriangle( v1, v2, v3, center );
 
 	// Test separating axis
 	float squaredDistance = b3DistanceSquared( closest.point, center );
 	float speculativeDistance = B3_SPECULATIVE_DISTANCE;
-	float maxDistance = sphereA->radius + speculativeDistance;
+	float maxDistance = radius + speculativeDistance;
 	if ( squaredDistance > maxDistance * maxDistance )
 	{
 		return;
 	}
 
 	float distance = sqrtf( squaredDistance );
+
+	// Normal points from triangle to sphere
 	b3Vec3 normal;
 	if ( distance * distance > 1000.0f * FLT_MIN )
 	{
@@ -95,7 +98,8 @@ void b3CollideSphereAndTriangle( b3LocalManifold* manifold, int capacity, const
 	}
 
 	// contact point mid-way
-	b3Vec3 contactPoint = b3MulSV( 0.5f, b3Add( b3Sub( center, b3MulSV( sphereA->radius, normal ) ), closest.point ) );
+	// p = 0.5 * (c + q) - 0.5 * r * n
+	b3Vec3 contactPoint = b3MulSV( 0.5f, b3Add( b3Sub( center, b3MulSV( radius, normal ) ), closest.point ) );
 
 	manifold->normal = normal;
 	manifold->pointCount = 1;
@@ -104,7 +108,7 @@ void b3CollideSphereAndTriangle( b3LocalManifold* manifold, int capacity, const
 
 	b3LocalManifoldPoint* mp = manifold->points + 0;
 	mp->point = contactPoint;
-	mp->separation = distance - sphereA->radius;
+	mp->separation = distance - radius;
 	mp->pair = b3FeaturePair_single;
 }
 
@@ -157,56 +161,85 @@ static bool b3ClipSegmentToTriangleFace( b3ClipVertex segment[2], const b3Vec3*
 	return true;
 }
 
-static b3FaceQuery b3QueryTriangleFaceAndCapsule( b3Plane plane, const b3Capsule* capsule )
+static b3SeparatingAxis b3QueryTriangleFaceAndCapsule( b3Plane plane, const b3Capsule* capsule )
 {
 	float separation1 = b3PlaneSeparation( plane, capsule->center1 );
 	float separation2 = b3PlaneSeparation( plane, capsule->center2 );
 
 	if ( separation1 < separation2 )
 	{
-		return (b3FaceQuery){
+		return (b3SeparatingAxis){
+			.normal = plane.normal,
 			.separation = separation1,
-			.faceIndex = 0,
-			.vertexIndex = 0,
+			.indexA = 0,
+			.indexB = 0,
 		};
 	}
 
-	return (b3FaceQuery){
+	return (b3SeparatingAxis){
+		.normal = plane.normal,
 		.separation = separation2,
-		.faceIndex = 0,
-		.vertexIndex = 1,
+		.indexA = 0,
+		.indexB = 1,
 	};
 }
 
-static b3EdgeQuery b3QueryTriangleAndCapsuleEdges( const b3Vec3* vertices, const b3Capsule* capsule )
+static b3SeparatingAxis b3QueryTriangleAndCapsuleEdges( const b3Vec3* vertices, b3Plane plane, const b3Capsule* capsule )
 {
 	// Work in the local space of the capsule
 	b3Vec3 p1 = capsule->center1;
 	b3Vec3 p2 = capsule->center2;
 	b3Vec3 capsuleEdge = b3Sub( p2, p1 );
 
-	b3Vec3 capsuleCenter = b3Lerp( p1, p2, 0.5f );
-
-	b3Vec3 triangleCenter = b3MulSV( 1.0f / 3.0f, b3Add( vertices[0], b3Add( vertices[1], vertices[2] ) ) );
-
 	// Find axis of minimum penetration
+	b3Vec3 maxNormal = b3Vec3_zero;
 	float maxSeparation = -FLT_MAX;
-	int maxIndex1 = UINT8_MAX;
-	int maxIndex2 = UINT8_MAX;
+	int maxIndex1 = B3_NULL_INDEX;
+	int maxIndex2 = B3_NULL_INDEX;
+	float squaredTolerance = 0.005f * 0.005f;
 
 	int edgeIndex = 2;
 	b3Vec3 v1 = vertices[2];
 	for ( int index = 0; index < 3; ++index )
 	{
 		b3Vec3 v2 = vertices[index];
-
 		b3Vec3 triangleEdge = b3Sub( v2, v1 );
+		b3Vec3 sideNormal = b3Normalize( b3Cross( triangleEdge, plane.normal ) );
+
+		// Pretend the triangle edge embeds a zero area face with a side normal. This
+		// provides a way to find an edge-edge normal that points outward from
+		// the triangle.
+		float a = b3Dot( capsuleEdge, plane.normal );
+		float b = b3Dot( capsuleEdge, sideNormal );
+
+		// Is the capsule edge parallel to the triangle edge? If so, face contact can handle it.
+		if ( a * a + b * b < squaredTolerance * b3LengthSquared( capsuleEdge ) )
+		{
+			continue;
+		}
+
+		// Similar to hull vs hull (b3QueryEdgeDirections)
+		b3Vec3 axis;
+		if ( a * b <= 0.0f )
+		{
+			float t = b / ( b - a );
+			axis = b3Lerp( sideNormal, plane.normal, t );
+		}
+		else
+		{
+			float t = b / ( a + b );
+			axis = b3Lerp( sideNormal, b3Neg( plane.normal ), t );
+		}
+
+		B3_VALIDATE( b3LengthSquared( axis ) > 1000.0f * FLT_MIN );
+		axis = b3Normalize( axis );
+		float separation = b3Dot( axis, b3Sub( p1, v1 ) );
 
-		float separation = b3EdgeEdgeSeparation( p1, capsuleEdge, capsuleCenter, v1, triangleEdge, triangleCenter );
 		if ( separation > maxSeparation )
 		{
 			// Note: We don't exit early if we find a separating axis here since we want to
 			// find the best one for caching and account for the convex radius later.
+			maxNormal = axis;
 			maxSeparation = separation;
 			maxIndex1 = edgeIndex;
 			maxIndex2 = 0;
@@ -217,10 +250,11 @@ static b3EdgeQuery b3QueryTriangleAndCapsuleEdges( const b3Vec3* vertices, const
 	}
 
 	// Save result
-	return (b3EdgeQuery){
+	return (b3SeparatingAxis){
+		.normal = maxNormal,
 		.separation = maxSeparation,
-		.indexA = (uint8_t)maxIndex1,
-		.indexB = (uint8_t)maxIndex2,
+		.indexA = maxIndex1,
+		.indexB = maxIndex2,
 	};
 }
 
@@ -272,8 +306,8 @@ static void b3BuildTriangleAndCapsuleFaceContact( b3LocalManifold* manifold, con
 	pt->pair = segment[1].pair;
 }
 
-static void b3BuildTriangleAndCapsuleEdgeContact( b3LocalManifold* manifold, const b3Vec3* triangle, const b3Capsule* capsule,
-												  b3EdgeQuery query )
+static void b3BuildTriangleAndCapsuleEdgeContact( b3LocalManifold* manifold, const b3Vec3* triangle, b3Plane plane,
+												  const b3Capsule* capsule, b3SeparatingAxis query )
 {
 	B3_ASSERT( 0 <= query.indexA && query.indexA < 3 );
 
@@ -283,20 +317,27 @@ static void b3BuildTriangleAndCapsuleEdgeContact( b3LocalManifold* manifold, con
 
 	const b3Vec3* vs = triangle;
 
-	b3Vec3 triangleCenter = b3MulSV( 1.0f / 3.0f, b3Add( vs[0], b3Add( vs[1], vs[2] ) ) );
 	b3Vec3 v1 = vs[query.indexA];
 	b3Vec3 v2 = vs[( query.indexA + 1 ) % 3];
 	b3Vec3 triangleEdge = b3Sub( v2, v1 );
 
-	b3Vec3 normal = b3Cross( capsuleEdge, triangleEdge );
-	normal = b3Normalize( normal );
+	b3Vec3 sideNormal = b3Normalize( b3Cross( triangleEdge, plane.normal ) );
 
-	// Normal should point away from triangle center
-	if ( b3Dot( normal, b3Sub( v1, triangleCenter ) ) < 0.0f )
+	// Pretend the triangle edge embeds a zero area face with a side normal. This
+	// provides a way to find an edge-edge normal that points outward from
+	// the triangle.
+	float a = b3Dot( capsuleEdge, plane.normal );
+	float b = b3Dot( capsuleEdge, sideNormal );
+
+	// Is the capsule edge parallel to the triangle edge? If so, face contact can handle it.
+	float squaredTolerance = 0.005f * 0.005f;
+	if ( a * a + b * b < squaredTolerance * b3LengthSquared( capsuleEdge ) )
 	{
-		normal = b3Neg( normal );
+		return;
 	}
 
+	// Similar to hull vs hull (b3QueryEdgeDirections)
+	b3Vec3 normal = query.normal;
 	b3SegmentDistanceResult result = b3LineDistance( v1, triangleEdge, p1, capsuleEdge );
 
 	if ( result.fraction1 < 0.0f || 1.0f < result.fraction1 || result.fraction2 < 0.0f || 1.0f < result.fraction2 )
@@ -306,8 +347,7 @@ static void b3BuildTriangleAndCapsuleEdgeContact( b3LocalManifold* manifold, con
 	}
 
 	b3Vec3 point = b3Lerp( b3MulSub( result.point1, capsule->radius, normal ), result.point2, 0.5f );
-
-	float separation = b3Dot( normal, b3Sub( result.point2, result.point1 ) );
+	float separation = b3Dot( normal, b3Sub( p1, v1 ) );
 	B3_VALIDATE( b3AbsFloat( separation - query.separation ) < B3_LINEAR_SLOP );
 
 	manifold->normal = normal;
@@ -322,7 +362,7 @@ static void b3BuildTriangleAndCapsuleEdgeContact( b3LocalManifold* manifold, con
 	pt->pair = b3MakeFeaturePair( b3_featureShapeA, query.indexA, b3_featureShapeB, query.indexB );
 }
 
-void b3CollideCapsuleAndTriangle( b3LocalManifold* manifold, int capacity, const b3Capsule* capsuleA, const b3Vec3* triangleB,
+void b3CollideTriangleAndCapsule( b3LocalManifold* manifold, int capacity, const b3Vec3* triangleA, const b3Capsule* capsuleB,
 								  b3SimplexCache* cache )
 {
 	manifold->pointCount = 0;
@@ -332,9 +372,9 @@ void b3CollideCapsuleAndTriangle( b3LocalManifold* manifold, int capacity, const
 		return;
 	}
 
-	b3Vec3 v1 = triangleB[0], v2 = triangleB[1], v3 = triangleB[2];
+	b3Vec3 v1 = triangleA[0], v2 = triangleA[1], v3 = triangleA[2];
 	b3Plane plane = b3MakePlaneFromPoints( v1, v2, v3 );
-	b3Vec3 capsuleCenter = b3Lerp( capsuleA->center1, capsuleA->center2, 0.5f );
+	b3Vec3 capsuleCenter = b3Lerp( capsuleB->center1, capsuleB->center2, 0.5f );
 
 	float offset = b3PlaneSeparation( plane, capsuleCenter );
 	if ( offset < 0.0f )
@@ -344,15 +384,15 @@ void b3CollideCapsuleAndTriangle( b3LocalManifold* manifold, int capacity, const
 	}
 
 	b3DistanceInput distanceInput;
-	distanceInput.proxyA = (b3ShapeProxy){ triangleB, 3, 0.0f };
-	distanceInput.proxyB = (b3ShapeProxy){ &capsuleA->center1, 2, 0.0f };
+	distanceInput.proxyA = (b3ShapeProxy){ triangleA, 3, 0.0f };
+	distanceInput.proxyB = (b3ShapeProxy){ &capsuleB->center1, 2, 0.0f };
 	distanceInput.transform = b3Transform_identity;
 	distanceInput.useRadii = false;
 
 	b3DistanceOutput distanceOutput = b3ShapeDistance( &distanceInput, cache, NULL, 0 );
-
-	float radius = capsuleA->radius;
-	if ( distanceOutput.distance > radius + B3_SPECULATIVE_DISTANCE )
+	float speculativeDistance = B3_SPECULATIVE_DISTANCE;
+	float radius = capsuleB->radius;
+	if ( distanceOutput.distance > radius + speculativeDistance )
 	{
 		// Shapes are separated, persist the cache
 		return;
@@ -370,14 +410,14 @@ void b3CollideCapsuleAndTriangle( b3LocalManifold* manifold, int capacity, const
 		{
 			// Clip capsule segment against side planes of reference face
 			b3ClipVertex segment[2];
-			segment[0].position = capsuleA->center1;
+			segment[0].position = capsuleB->center1;
 			segment[0].separation = 0.0f;
 			segment[0].pair = b3MakeFeaturePair( b3_featureShapeA, 0, b3_featureShapeA, 0 );
-			segment[1].position = capsuleA->center2;
+			segment[1].position = capsuleB->center2;
 			segment[1].separation = 0.0f;
 			segment[1].pair = b3MakeFeaturePair( b3_featureShapeA, 1, b3_featureShapeA, 1 );
 
-			bool havePoints = b3ClipSegmentToTriangleFace( segment, triangleB, plane );
+			bool havePoints = b3ClipSegmentToTriangleFace( segment, triangleA, plane );
 
 			if ( havePoints == true )
 			{
@@ -388,6 +428,7 @@ void b3CollideCapsuleAndTriangle( b3LocalManifold* manifold, int capacity, const
 				b3Vec3 point1 = b3MulSub( segment[0].position, 0.5f * ( radius + distance1 ), normal );
 				b3Vec3 point2 = b3MulSub( segment[1].position, 0.5f * ( radius + distance2 ), normal );
 
+				// Normal points from triangle to capsule
 				manifold->normal = normal;
 				manifold->feature = b3_featureTriangleFace;
 				manifold->pointCount = 2;
@@ -406,9 +447,10 @@ void b3CollideCapsuleAndTriangle( b3LocalManifold* manifold, int capacity, const
 			}
 		}
 
-		// Create contact from closest points
+		// Create contact from closest points.
 		b3Vec3 point = b3MulSV( 0.5f, b3Add( b3Sub( distanceOutput.pointA, b3MulSV( radius, delta ) ), distanceOutput.pointB ) );
 
+		// Normal points from triangle to capsule.
 		manifold->normal = delta;
 		manifold->pointCount = 1;
 		manifold->feature = b3GetTriangleFeature( cache );
@@ -423,38 +465,38 @@ void b3CollideCapsuleAndTriangle( b3LocalManifold* manifold, int capacity, const
 
 	// Deep penetration
 
-	b3FaceQuery faceQuery = b3QueryTriangleFaceAndCapsule( plane, capsuleA );
+	b3SeparatingAxis faceQuery = b3QueryTriangleFaceAndCapsule( plane, capsuleB );
 	if ( faceQuery.separation > radius )
 	{
-		// Shapes are separated
+		// Shapes are separated. Should be impossible for a reasonable capsule radius.
 		return;
 	}
 
-	b3EdgeQuery edgeQuery = b3QueryTriangleAndCapsuleEdges( triangleB, capsuleA );
+	b3SeparatingAxis edgeQuery = b3QueryTriangleAndCapsuleEdges( triangleA, plane, capsuleB );
 	if ( edgeQuery.separation > radius )
 	{
-		// Shapes are separated
+		// Shapes are separated. Should be impossible for a reasonable capsule radius.
 		return;
 	}
 
 	// Create face contact
 	float faceSeparation = faceQuery.separation - radius;
-	b3BuildTriangleAndCapsuleFaceContact( manifold, triangleB, plane, capsuleA );
+	b3BuildTriangleAndCapsuleFaceContact( manifold, triangleA, plane, capsuleB );
+	B3_VALIDATE( manifold->pointCount == 0 || manifold->pointCount == 2 );
 	if ( manifold->pointCount == 2 )
 	{
+		// This becomes the clipped separation.
 		faceSeparation = b3MinFloat( manifold->points[0].separation, manifold->points[1].separation );
 	}
-	B3_VALIDATE( faceSeparation <= 0.0f );
 
 	// Face contact can be empty if it does not realize the axis of minimum penetration.
 	// Create edge contact if face contact fails or edge contact is significantly better!
-	const float kRelEdgeTolerance = 0.50f;
-	const float kAbsTolerance = 1.0f * B3_LINEAR_SLOP;
+	float linearSlop = B3_LINEAR_SLOP;
 	float edgeSeparation = edgeQuery.separation - radius;
-	if ( manifold->pointCount == 0 || edgeSeparation > kRelEdgeTolerance * faceSeparation + kAbsTolerance )
+	if ( manifold->pointCount == 0 || edgeSeparation > faceSeparation + linearSlop )
 	{
 		// Edge contact
-		b3BuildTriangleAndCapsuleEdgeContact( manifold, triangleB, capsuleA, edgeQuery );
+		b3BuildTriangleAndCapsuleEdgeContact( manifold, triangleA, plane, capsuleB, edgeQuery );
 	}
 }
 
@@ -479,31 +521,35 @@ static inline int b3GetTriangleSupport( b3Vec3* points, b3Vec3 direction )
 	return index;
 }
 
-static b3FaceQuery b3QueryTriangleFace( const b3TriangleData* triangle, const b3HullData* hull )
+static b3SeparatingAxis b3QueryTriangleFace( const b3TriangleData* triangle, const b3HullData* hull )
 {
 	const b3Vec3* hullPoints = b3GetHullPoints( hull );
 	b3Plane plane = triangle->plane;
-	int vertexIndex = b3FindHullSupportVertex( hull, b3Neg( plane.normal ) );
+	b3Vec3 normal = b3Neg( plane.normal );
+	int vertexIndex = b3FindHullSupportVertex( hull, normal );
 	b3Vec3 support = hullPoints[vertexIndex];
 	float separation = b3PlaneSeparation( plane, support );
 
-	return (b3FaceQuery){
+	return (b3SeparatingAxis){
+		.normal = plane.normal,
 		.separation = separation,
-		.faceIndex = 0,
-		.vertexIndex = (uint8_t)vertexIndex,
+		.indexA = 0,
+		.indexB = vertexIndex,
+		.type = b3_faceAxisA,
 	};
 }
 
-static b3FaceQuery b3QueryHullFace( const b3TriangleData* triangle, const b3HullData* hull )
+static b3SeparatingAxis b3QueryHullFace( const b3TriangleData* triangle, const b3HullData* hull )
 {
 	const b3Plane* hullPlanes = b3GetHullPlanes( hull );
 	int faceCount = hull->faceCount;
 
 	b3Vec3 trianglePoints[] = { triangle->v1, triangle->v2, triangle->v3 };
 
-	int maxFaceIndex = -1;
-	int maxVertexIndex = -1;
-	float maxFaceSeparation = -FLT_MAX;
+	b3Vec3 maxNormal = b3Vec3_zero;
+	float maxFaceSeparation = -INFINITY;
+	int maxFaceIndex = B3_NULL_INDEX;
+	int maxVertexIndex = B3_NULL_INDEX;
 
 	for ( int faceIndex = 0; faceIndex < faceCount; ++faceIndex )
 	{
@@ -514,25 +560,32 @@ static b3FaceQuery b3QueryHullFace( const b3TriangleData* triangle, const b3Hull
 		float separation = b3PlaneSeparation( plane, support );
 		if ( separation > maxFaceSeparation )
 		{
+			maxNormal = plane.normal;
+			maxFaceSeparation = separation;
 			maxFaceIndex = faceIndex;
 			maxVertexIndex = vertexIndex;
-			maxFaceSeparation = separation;
 		}
 	}
 
-	return (b3FaceQuery){
+	// Normal points from triangle to hull
+	return (b3SeparatingAxis){
+		.normal = b3Neg( maxNormal ),
 		.separation = maxFaceSeparation,
-		.faceIndex = maxFaceIndex,
-		.vertexIndex = maxVertexIndex,
+		.indexA = maxVertexIndex,
+		.indexB = maxFaceIndex,
+		.type = b3_faceAxisB,
 	};
 }
 
-static b3EdgeQuery b3TestEdgePairs( const b3TriangleData* triangle, const b3HullData* hull )
+// A: hull, B: triangle
+static b3SeparatingAxis b3QueryTriangleAndHullEdges( const b3TriangleData* triangle, const b3HullData* hull )
 {
-	b3EdgeQuery result = {
-		.separation = -FLT_MAX,
+	b3SeparatingAxis result = {
+		.normal = b3Vec3_zero,
+		.separation = -INFINITY,
 		.indexA = B3_NULL_INDEX,
 		.indexB = B3_NULL_INDEX,
+		.type = b3_edgePairAxis,
 	};
 
 	b3Vec3 trianglePoints[] = { triangle->v1, triangle->v2, triangle->v3 };
@@ -552,6 +605,7 @@ static b3EdgeQuery b3TestEdgePairs( const b3TriangleData* triangle, const b3Hull
 	const b3Vec3* hullPoints = b3GetHullPoints( hull );
 	const b3Plane* hullPlanes = b3GetHullPlanes( hull );
 	int edgeCount = hull->edgeCount;
+	float squaredTolerance = 0.005f * 0.005f;
 
 	for ( int i = 0; i < edgeCount; i += 2 )
 	{
@@ -577,14 +631,28 @@ static b3EdgeQuery b3TestEdgePairs( const b3TriangleData* triangle, const b3Hull
 				continue;
 			}
 
-			b3Vec3 triPoint = trianglePoints[j];
-			float separation = b3EdgeEdgeSeparation( triPoint, triEdge, triangle->center, hullPoint, hullEdge, hull->center );
+			// Avoid nearly parallel edges that may lead to invalid separation values at the noise floor.
+			if ( b3MaxFloat( cab * cab, dab * dab ) < squaredTolerance * b3LengthSquared( triEdge ) )
+			{
+				continue;
+			}
+
+			// Similar to hull vs hull (b3QueryEdgeDirections)
+			// dot(hullNormal1 + t * (hullNormal2 - hullNormal1), triEdge) = 0
+			// Normal points out of hull by construction.
+			float t = cab / ( cab - dab );
+			b3Vec3 axis = b3Lerp( hullNormal1, hullNormal2, t );
+			B3_VALIDATE( b3LengthSquared( axis ) > 1000.0f * FLT_MIN );
+			axis = b3Normalize( axis );
+			float separation = b3Dot( axis, b3Sub( trianglePoints[j], hullPoint ) );
 
 			// if ( separation > result.separation && ( edgeFlags[j] & triangleFlags ) == 0 )
 			if ( separation > result.separation )
 			{
 				// Note: We don't exit early if we find a separating axis here since we want to
 				// find the best one for caching.
+				// Flip normal to point from triangle to hull.
+				result.normal = b3Neg( axis );
 				result.separation = separation;
 				result.indexA = j;
 				result.indexB = i;
@@ -596,8 +664,12 @@ static b3EdgeQuery b3TestEdgePairs( const b3TriangleData* triangle, const b3Hull
 }
 
 static float b3CollideHullFace( b3LocalManifold* manifold, int pointCapacity, const b3TriangleData* triangle,
-								const b3HullData* hull, b3FaceQuery query, b3SATCache* cache, bool enableSpeculative )
+								const b3HullData* hull, b3SeparatingAxis query, b3SATCache* cache, bool enableSpeculative )
 {
+	B3_VALIDATE( query.type == b3_faceAxisB );
+	B3_VALIDATE( 0 <= query.indexA && query.indexA < 3 );
+	B3_VALIDATE( 0 <= query.indexB && query.indexB < hull->faceCount );
+
 	manifold->pointCount = 0;
 
 	const b3HullFace* hullFaces = b3GetHullFaces( hull );
@@ -606,8 +678,7 @@ static float b3CollideHullFace( b3LocalManifold* manifold, int pointCapacity, co
 	const b3Vec3* hullPoints = b3GetHullPoints( hull );
 
 	// Reference hull face
-	int refFace = query.faceIndex;
-	b3Plane refPlane = hullPlanes[refFace];
+	b3Plane refPlane = hullPlanes[query.indexB];
 
 	// Build clip polygon from triangle face (the incident face)
 	b3ClipVertex buffer1[B3_MAX_CLIP_POINTS], buffer2[B3_MAX_CLIP_POINTS];
@@ -630,7 +701,7 @@ static float b3CollideHullFace( b3LocalManifold* manifold, int pointCapacity, co
 	b3ClipVertex* input = buffer1;
 	b3ClipVertex* output = buffer2;
 
-	const b3HullFace* face = hullFaces + refFace;
+	const b3HullFace* face = hullFaces + query.indexB;
 	int edgeIndex = face->edge;
 
 	do
@@ -702,14 +773,17 @@ static float b3CollideHullFace( b3LocalManifold* manifold, int pointCapacity, co
 	// Save cache
 	cache->separation = minSeparation;
 	cache->type = b3_faceAxisB;
-	cache->indexA = (uint8_t)query.vertexIndex;
-	cache->indexB = (uint8_t)query.faceIndex;
+	cache->indexA = (uint8_t)query.indexA;
+	cache->indexB = (uint8_t)query.indexB;
 	return minSeparation;
 }
 
 static float b3CollideTriangleFace( b3LocalManifold* manifold, int pointCapacity, const b3TriangleData* triangle,
-									const b3HullData* hull, b3FaceQuery query, b3SATCache* cache, bool enableSpeculative )
+									const b3HullData* hull, b3SeparatingAxis query, b3SATCache* cache, bool enableSpeculative )
 {
+	B3_VALIDATE( query.type == b3_faceAxisA );
+	B3_VALIDATE( query.indexA == 0 );
+	B3_VALIDATE( 0 <= query.indexB && query.indexB < hull->vertexCount );
 	B3_VALIDATE( manifold->pointCount == 0 );
 
 	const b3HullFace* hullFaces = b3GetHullFaces( hull );
@@ -717,10 +791,9 @@ static float b3CollideTriangleFace( b3LocalManifold* manifold, int pointCapacity
 	const b3Vec3* hullPoints = b3GetHullPoints( hull );
 
 	// Find incident face
-	B3_ASSERT( query.faceIndex == 0 );
 	b3Plane refPlane = triangle->plane;
 
-	int incFace = b3FindIncidentFace( hull, refPlane.normal, query.vertexIndex );
+	int incFace = b3FindIncidentFace( hull, refPlane.normal, query.indexB );
 
 	// Build clip polygon from incident face
 	b3ClipVertex buffer1[2 * B3_MAX_CLIP_POINTS], buffer2[2 * B3_MAX_CLIP_POINTS];
@@ -816,18 +889,19 @@ static float b3CollideTriangleFace( b3LocalManifold* manifold, int pointCapacity
 	// Save cache
 	cache->separation = minSeparation;
 	cache->type = b3_faceAxisA;
-	cache->indexA = (uint8_t)query.faceIndex;
-	cache->indexB = (uint8_t)query.vertexIndex;
+	cache->indexA = (uint8_t)query.indexA;
+	cache->indexB = (uint8_t)query.indexB;
 	return minSeparation;
 }
 
-static void b3CollideHullAndTriangleEdges( b3LocalManifold* manifold, int capacity, b3Vec3 trianglePoint, b3Vec3 triangleEdge,
-										   b3Vec3 triangleCenter, const b3HullData* hull, b3EdgeQuery query, b3SATCache* cache )
+static void b3CollideTriangleAndHullEdges( b3LocalManifold* manifold, int capacity, b3Vec3 trianglePoint, b3Vec3 triangleEdge,
+										   const b3HullData* hull, b3SeparatingAxis query, b3SATCache* cache )
 {
+	B3_VALIDATE( query.type == b3_edgePairAxis );
+	B3_VALIDATE( 0 <= query.indexA && query.indexA < 3 );
+	B3_VALIDATE( 0 <= query.indexB && query.indexB < hull->edgeCount );
 	B3_VALIDATE( query.separation <= 2.0f * B3_SPECULATIVE_DISTANCE );
-	B3_ASSERT( query.indexA < 3 );
 
-	b3Vec3 cA = triangleCenter;
 	b3Vec3 pA = trianglePoint;
 	b3Vec3 eA = triangleEdge;
 
@@ -839,32 +913,6 @@ static void b3CollideHullAndTriangleEdges( b3LocalManifold* manifold, int capaci
 	b3Vec3 qB = pointsB[twinB->origin];
 	b3Vec3 eB = b3Sub( qB, pB );
 
-	b3Vec3 normal = b3Cross( eA, eB );
-	normal = b3Normalize( normal );
-
-	// Ensure normal points outward from triangle center
-	float outwardA = b3Dot( normal, b3Sub( pA, cA ) );
-
-	// Ensure normal points towards hull center
-	float outwardB = b3Dot( normal, b3Sub( hull->center, pB ) );
-
-	// Use the largest magnitude. The triangle outward value
-	// may be unreliable as some angles.
-	if ( b3AbsFloat( outwardA ) > b3AbsFloat( outwardB ) )
-	{
-		if ( outwardA < 0.0f )
-		{
-			normal = b3Neg( normal );
-		}
-	}
-	else
-	{
-		if ( outwardB < 0.0f )
-		{
-			normal = b3Neg( normal );
-		}
-	}
-
 	// Get the closest points between the infinite edge lines
 	b3SegmentDistanceResult result = b3LineDistance( pA, eA, pB, eB );
 
@@ -879,7 +927,7 @@ static void b3CollideHullAndTriangleEdges( b3LocalManifold* manifold, int capaci
 	}
 
 	// This can slide off the end from caching
-	float separation = b3Dot( normal, b3Sub( result.point2, result.point1 ) );
+	float separation = b3Dot( query.normal, b3Sub( pB, pA ) );
 	B3_VALIDATE( b3AbsFloat( separation - query.separation ) < B3_LINEAR_SLOP );
 
 	b3Vec3 point = b3MulSV( 0.5f, b3Add( result.point1, result.point2 ) );
@@ -895,30 +943,19 @@ static void b3CollideHullAndTriangleEdges( b3LocalManifold* manifold, int capaci
 	cache->indexA = (uint8_t)query.indexA;
 	cache->indexB = (uint8_t)query.indexB;
 
-	manifold->normal = normal;
+	manifold->normal = query.normal;
 	manifold->pointCount = 1;
 
 	b3TriangleFeature edgesFeatures[] = { b3_featureEdge1, b3_featureEdge2, b3_featureEdge3 };
 	manifold->feature = edgesFeatures[query.indexA];
 }
 
-// See "Collision Detection of Convex Polyhedra Based on Duality Transformation"
-// Simplified for triangle versus hull
-static inline bool b3IsTriangleMinkowskiFace( b3Vec3 triNormal, b3Vec3 triEdge, b3Vec3 hullNormal1, b3Vec3 hullNormal2,
-											  b3Vec3 hullEdge )
-{
-	float cab = b3Dot( hullNormal1, triEdge );
-	float dab = b3Dot( hullNormal2, triEdge );
-	float bcd = b3Dot( triNormal, hullEdge );
-	return cab * dab < 0.0f && cab * bcd > 0.0f;
-}
-
 b3AtomicInt b3_triangleConvexCalls;
 b3AtomicInt b3_triangleCacheHits;
 
-// Computes the manifold in the local space of the hull
-void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3HullData* hullA, b3Vec3 v1, b3Vec3 v2, b3Vec3 v3,
-							   int triangleFlags, b3SATCache* cache, bool enableSpeculative )
+// Triangle is in the local space of the hull for efficiency.
+void b3CollideTriangleAndHull( b3LocalManifold* manifold, int capacity, b3Vec3 v1, b3Vec3 v2, b3Vec3 v3, int triangleFlags,
+							   const b3HullData* hullB, b3SATCache* cache, bool enableSpeculative )
 {
 	manifold->pointCount = 0;
 	manifold->feature = b3_featureNone;
@@ -931,7 +968,7 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 	b3Plane trianglePlane = b3MakePlaneFromPoints( v1, v2, v3 );
 	float linearSlop = B3_LINEAR_SLOP;
 
-	float offset = b3PlaneSeparation( trianglePlane, hullA->center );
+	float offset = b3PlaneSeparation( trianglePlane, hullB->center );
 	if ( cache->type == b3_backsideAxis )
 	{
 		// Use hysteresis to avoid jitter on wavy meshes
@@ -951,7 +988,6 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 		return;
 	}
 
-	b3Vec3 triangleCenter = b3MulSV( 1.0f / 3.0f, b3Add( v1, b3Add( v2, v3 ) ) );
 	b3Vec3 trianglePoints[] = { v1, v2, v3 };
 	b3Vec3 triangleEdges[] = { b3Sub( v2, v1 ), b3Sub( v3, v2 ), b3Sub( v1, v3 ) };
 
@@ -962,14 +998,13 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 		.e1 = triangleEdges[0],
 		.e2 = triangleEdges[1],
 		.e3 = triangleEdges[2],
-		.center = triangleCenter,
 		.plane = trianglePlane,
 		.flags = triangleFlags,
 	};
 
-	const b3HullHalfEdge* edges = b3GetHullEdges( hullA );
-	const b3Plane* hullPlanes = b3GetHullPlanes( hullA );
-	const b3Vec3* hullPoints = b3GetHullPoints( hullA );
+	const b3HullHalfEdge* edges = b3GetHullEdges( hullB );
+	const b3Plane* hullPlanes = b3GetHullPlanes( hullB );
+	const b3Vec3* hullPoints = b3GetHullPoints( hullB );
 
 	float speculativeDistance = enableSpeculative ? B3_SPECULATIVE_DISTANCE : 0.0f;
 	cache->hit = 1;
@@ -981,7 +1016,7 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 		{
 			B3_ASSERT( cache->indexA == 0 );
 
-			int vertexIndex = b3FindHullSupportVertex( hullA, b3Neg( trianglePlane.normal ) );
+			int vertexIndex = b3FindHullSupportVertex( hullB, b3Neg( trianglePlane.normal ) );
 			b3Vec3 support = hullPoints[vertexIndex];
 			float separation = b3PlaneSeparation( trianglePlane, support );
 			if ( separation > speculativeDistance )
@@ -990,15 +1025,17 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 				return;
 			}
 
-			b3FaceQuery faceQuery;
+			b3SeparatingAxis faceQuery;
+			faceQuery.normal = trianglePlane.normal;
 			faceQuery.separation = separation;
-			faceQuery.faceIndex = cache->indexA;
-			faceQuery.vertexIndex = vertexIndex;
+			faceQuery.indexA = cache->indexA;
+			faceQuery.indexB = vertexIndex;
+			faceQuery.type = b3_faceAxisA;
 
 			// Read cache but don't modify it
 			b3SATCache localCache = *cache;
 			float clippedSeparation =
-				b3CollideTriangleFace( manifold, capacity, &triangle, hullA, faceQuery, &localCache, enableSpeculative );
+				b3CollideTriangleFace( manifold, capacity, &triangle, hullB, faceQuery, &localCache, enableSpeculative );
 
 			if ( manifold->pointCount > 0 && b3AbsFloat( cache->separation - clippedSeparation ) < linearSlop )
 			{
@@ -1014,7 +1051,7 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 
 		case b3_faceAxisB:
 		{
-			B3_ASSERT( cache->indexB < hullA->faceCount );
+			B3_ASSERT( cache->indexB < hullB->faceCount );
 
 			b3Plane plane = hullPlanes[cache->indexB];
 
@@ -1049,15 +1086,17 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 			if ( isDeep == false )
 			{
 				//  Try to rebuild contact from last features
-				b3FaceQuery faceQuery;
+				b3SeparatingAxis faceQuery;
+				faceQuery.normal = b3Neg( plane.normal );
 				faceQuery.separation = separation;
-				faceQuery.faceIndex = cache->indexB;
-				faceQuery.vertexIndex = vertexIndex;
+				faceQuery.indexA = vertexIndex;
+				faceQuery.indexB = cache->indexB;
+				faceQuery.type = b3_faceAxisB;
 
 				// Read cache but don't modify it
 				b3SATCache localCache = *cache;
 				float clippedSeparation =
-					b3CollideHullFace( manifold, capacity, &triangle, hullA, faceQuery, &localCache, enableSpeculative );
+					b3CollideHullFace( manifold, capacity, &triangle, hullB, faceQuery, &localCache, enableSpeculative );
 
 				// Cache reuse is only successful if it creates contact points and the clipped separation didn't change much.
 				if ( manifold->pointCount > 0 && b3AbsFloat( cache->separation - clippedSeparation ) < linearSlop )
@@ -1081,7 +1120,7 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 			b3Vec3 triPoint = trianglePoints[indexA];
 			b3Vec3 triEdge = triangleEdges[indexA];
 
-			B3_ASSERT( cache->indexB < hullA->edgeCount - 1 );
+			B3_ASSERT( cache->indexB < hullB->edgeCount - 1 );
 			int indexB = cache->indexB;
 
 			const b3HullHalfEdge* edge2 = edges + indexB;
@@ -1093,36 +1132,55 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 			b3Vec3 hullNormal1 = hullPlanes[edge2->face].normal;
 			b3Vec3 hullNormal2 = hullPlanes[twin2->face].normal;
 
-			// Confirm the edge pair is still a Minkowski face
-			bool isMinkowski = b3IsTriangleMinkowskiFace( trianglePlane.normal, triEdge, hullNormal1, hullNormal2, hullEdge );
-			if ( isMinkowski )
+			// Confirm the edge pair is still a Minkowski face.
+			// See "Collision Detection of Convex Polyhedra Based on Duality Transformation"
+			// Simplified for triangle versus hull.
+			float cab = b3Dot( hullNormal1, triEdge );
+			float dab = b3Dot( hullNormal2, triEdge );
+			float bcd = b3Dot( trianglePlane.normal, hullEdge );
+
+			if ( cab * dab < 0.0f && cab * bcd > 0.0f )
 			{
-				// Transform reference center of the first hull into local space of the second hull
-				float separation = b3EdgeEdgeSeparation( triPoint, triEdge, triangleCenter, hullPoint, hullEdge, hullA->center );
-				if ( separation > speculativeDistance )
+				float squaredTolerance = 0.005f * 0.005f;
+
+				// Avoid nearly parallel edges that may lead to invalid separation values at the noise floor.
+				if ( b3MaxFloat( cab * cab, dab * dab ) >= squaredTolerance * b3LengthSquared( triEdge ) )
 				{
-					// Cache hit, shapes are separated
-					return;
-				}
-
-				if ( b3AbsFloat( cache->separation - separation ) < linearSlop )
-				{
-					// Try to rebuild contact from last features
-					b3EdgeQuery edgeQuery;
-					edgeQuery.indexA = indexA;
-					edgeQuery.indexB = indexB;
-					edgeQuery.separation = separation;
-
-					// Read cache but don't modify it
-					b3SATCache localCache = *cache;
-					b3CollideHullAndTriangleEdges( manifold, capacity, triPoint, triEdge, triangleCenter, hullA, edgeQuery,
-												   &localCache );
-
-					if ( manifold->pointCount > 0 )
+					// Similar to hull vs hull (b3QueryEdgeDirections)
+					// dot(hullNormal1 + t * (hullNormal2 - hullNormal1), triEdge) = 0
+					// Normal points out of hull by construction.
+					float t = cab / ( cab - dab );
+					b3Vec3 axis = b3Lerp( hullNormal1, hullNormal2, t );
+					B3_VALIDATE( b3LengthSquared( axis ) > 1000.0f * FLT_MIN );
+					axis = b3Normalize( axis );
+					float separation = b3Dot( axis, b3Sub( triPoint, hullPoint ) );
+					if ( separation > speculativeDistance )
 					{
-						// Cache hit, contact point generated
+						// Cache hit, shapes are separated
 						return;
 					}
+
+					if ( b3AbsFloat( cache->separation - separation ) < linearSlop )
+					{
+						// Try to rebuild contact from last features
+						// Flip normal to point from triangle to hull
+						b3SeparatingAxis edgeQuery;
+						edgeQuery.normal = b3Neg( axis );
+						edgeQuery.indexA = indexA;
+						edgeQuery.indexB = indexB;
+						edgeQuery.separation = separation;
+						edgeQuery.type = b3_edgePairAxis;
+
+						// Read cache but don't modify it
+						b3SATCache localCache = *cache;
+						b3CollideTriangleAndHullEdges( manifold, capacity, triPoint, triEdge, hullB, edgeQuery, &localCache );
+
+						if ( manifold->pointCount > 0 )
+						{
+							// Cache hit, contact point generated
+							return;
+						}
+					}
 				}
 			}
 
@@ -1134,29 +1192,28 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 			// This case is for testing
 		case b3_manualFaceAxisA:
 		{
-			b3FaceQuery faceQueryA = b3QueryTriangleFace( &triangle, hullA );
-			b3CollideTriangleFace( manifold, capacity, &triangle, hullA, faceQueryA, cache, enableSpeculative );
+			b3SeparatingAxis query = b3QueryTriangleFace( &triangle, hullB );
+			b3CollideTriangleFace( manifold, capacity, &triangle, hullB, query, cache, enableSpeculative );
 			return;
 		}
 
 			// This case is for testing
 		case b3_manualFaceAxisB:
 		{
-			b3FaceQuery faceQueryB = b3QueryHullFace( &triangle, hullA );
-			b3CollideHullFace( manifold, capacity, &triangle, hullA, faceQueryB, cache, enableSpeculative );
+			b3SeparatingAxis query = b3QueryHullFace( &triangle, hullB );
+			b3CollideHullFace( manifold, capacity, &triangle, hullB, query, cache, enableSpeculative );
 			return;
 		}
 
 			// This case is for testing
 		case b3_manualEdgePairAxis:
 		{
-			b3EdgeQuery edgeQuery = b3TestEdgePairs( &triangle, hullA );
-			if ( edgeQuery.indexA != B3_NULL_INDEX )
+			b3SeparatingAxis query = b3QueryTriangleAndHullEdges( &triangle, hullB );
+			if ( query.indexA != B3_NULL_INDEX )
 			{
-				b3Vec3 trianglePoint = trianglePoints[edgeQuery.indexA];
-				b3Vec3 triangleEdge = triangleEdges[edgeQuery.indexA];
-				b3CollideHullAndTriangleEdges( manifold, capacity, trianglePoint, triangleEdge, triangleCenter, hullA, edgeQuery,
-											   cache );
+				b3Vec3 trianglePoint = trianglePoints[query.indexA];
+				b3Vec3 triangleEdge = triangleEdges[query.indexA];
+				b3CollideTriangleAndHullEdges( manifold, capacity, trianglePoint, triangleEdge, hullB, query, cache );
 			}
 			return;
 		}
@@ -1170,29 +1227,29 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 	cache->hit = 0;
 
 	// Find axis of minimum penetration
-	b3FaceQuery faceQueryA = b3QueryTriangleFace( &triangle, hullA );
+	b3SeparatingAxis faceQueryA = b3QueryTriangleFace( &triangle, hullB );
 	if ( faceQueryA.separation > speculativeDistance )
 	{
 		// Separating axis found
 		cache->separation = faceQueryA.separation;
 		cache->type = b3_faceAxisA;
-		cache->indexA = 0;
-		cache->indexB = UINT8_MAX;
+		cache->indexA = (uint8_t)faceQueryA.indexA;
+		cache->indexB = (uint8_t)faceQueryA.indexB;
 		return;
 	}
 
-	b3FaceQuery faceQueryB = b3QueryHullFace( &triangle, hullA );
+	b3SeparatingAxis faceQueryB = b3QueryHullFace( &triangle, hullB );
 	if ( faceQueryB.separation > speculativeDistance )
 	{
 		// Separating axis found
 		cache->separation = faceQueryB.separation;
 		cache->type = b3_faceAxisB;
-		cache->indexA = UINT8_MAX;
-		cache->indexB = (uint8_t)faceQueryB.faceIndex;
+		cache->indexA = (uint8_t)faceQueryB.indexA;
+		cache->indexB = (uint8_t)faceQueryB.indexB;
 		return;
 	}
 
-	b3EdgeQuery edgeQuery = b3TestEdgePairs( &triangle, hullA );
+	b3SeparatingAxis edgeQuery = b3QueryTriangleAndHullEdges( &triangle, hullB );
 	if ( edgeQuery.separation > speculativeDistance )
 	{
 		// Separating axis found
@@ -1203,21 +1260,18 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 		return;
 	}
 
-	float clippedFaceSeparation;
+	float clipSeparation;
 
 	// Don't admit a hull face significantly opposed to the triangle face.
 	// Need a tolerance to avoid ghost collisions.
-	// todo hull query skips faces that point along the triangle normal
-	b3Vec3 hullNormal = hullPlanes[faceQueryB.faceIndex].normal;
-	bool pushingDown = b3Dot( hullNormal, trianglePlane.normal ) > 0.25f;
-	if ( faceQueryB.separation > faceQueryA.separation + linearSlop && pushingDown == false )
+	bool pushingDown = b3Dot( faceQueryB.normal, trianglePlane.normal ) < -0.25f;
+	if ( faceQueryB.separation >= faceQueryA.separation && pushingDown == false )
 	{
-		clippedFaceSeparation = b3CollideHullFace( manifold, capacity, &triangle, hullA, faceQueryB, cache, enableSpeculative );
+		clipSeparation = b3CollideHullFace( manifold, capacity, &triangle, hullB, faceQueryB, cache, enableSpeculative );
 	}
 	else
 	{
-		clippedFaceSeparation =
-			b3CollideTriangleFace( manifold, capacity, &triangle, hullA, faceQueryA, cache, enableSpeculative );
+		clipSeparation = b3CollideTriangleFace( manifold, capacity, &triangle, hullB, faceQueryA, cache, enableSpeculative );
 	}
 
 	// Does an edge axis exist?
@@ -1228,14 +1282,13 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 		float maxFaceSeparation = b3MaxFloat( faceQueryA.separation, faceQueryB.separation );
 
 		if ( ( manifold->pointCount == 0 && edgeQuery.separation > maxFaceSeparation ) ||
-			 ( manifold->pointCount == 1 && edgeQuery.separation > clippedFaceSeparation + linearSlop ) )
+			 ( manifold->pointCount == 1 && edgeQuery.separation > clipSeparation + linearSlop ) )
 		{
 			B3_ASSERT( 0 <= edgeQuery.indexA && edgeQuery.indexA < 3 );
 			b3Vec3 trianglePoint = trianglePoints[edgeQuery.indexA];
 			b3Vec3 triangleEdge = triangleEdges[edgeQuery.indexA];
 			manifold->pointCount = 0;
-			b3CollideHullAndTriangleEdges( manifold, capacity, trianglePoint, triangleEdge, triangleCenter, hullA, edgeQuery,
-										   cache );
+			b3CollideTriangleAndHullEdges( manifold, capacity, trianglePoint, triangleEdge, hullB, edgeQuery, cache );
 		}
 	}
 
@@ -1250,7 +1303,7 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 			.count = 3,
 			.radius = 0.0f,
 		};
-		input.proxyB = (b3ShapeProxy){ .points = hullPoints, .count = hullA->vertexCount, .radius = 0.0f };
+		input.proxyB = (b3ShapeProxy){ .points = hullPoints, .count = hullB->vertexCount, .radius = 0.0f };
 		input.transform = b3Transform_identity;
 		input.useRadii = false;
 
@@ -1270,5 +1323,8 @@ void b3CollideHullAndTriangle( b3LocalManifold* manifold, int capacity, const b3
 			// This feature pair not accurate but maybe it doesn't matter
 			manifold->points[0].pair = b3FeaturePair_single;
 		}
+
+		// No way to cache this scenario
+		*cache = (b3SATCache){ 0 };
 	}
 }
diff --git a/vendor/box3d/src/src/types.c b/vendor/box3d/src/src/types.c
index b199cd15d..7e2cd071e 100644
--- a/vendor/box3d/src/src/types.c
+++ b/vendor/box3d/src/src/types.c
@@ -80,10 +80,9 @@ b3ShapeDef b3DefaultShapeDef( void )
 	return def;
 }
 
-static bool b3EmptyDrawShape( void* userShape, b3WorldTransform transform, b3HexColor color, void* context )
+static void b3EmptyDrawShape( void* userShape, b3WorldTransform transform, b3HexColor color, void* context )
 {
 	B3_UNUSED( userShape, transform, color, context );
-	return false;
 }
 
 static void b3EmptyDrawSegment( b3Pos p1, b3Pos p2, b3HexColor color, void* context )
diff --git a/vendor/raylib/raymath.odin b/vendor/raylib/raymath.odin
index 98eb5c03e..c5df7cb7b 100644
--- a/vendor/raylib/raymath.odin
+++ b/vendor/raylib/raymath.odin
@@ -80,7 +80,7 @@ Vector2Subtract :: proc "c" (a, b: Vector2) -> Vector2 {
 	return a - b
 }
 // Subtract vector by float value
-@(require_results, deprecated="Prefer v + value")
+@(require_results, deprecated="Prefer v - value")
 Vector2SubtractValue :: proc "c" (v: Vector2, value: f32) -> Vector2 {
 	return v - value
 }
@@ -270,7 +270,7 @@ Vector3Subtract :: proc "c" (a, b: Vector3) -> Vector3 {
 	return a - b
 }
 // Subtract vector by float value
-@(require_results, deprecated="Prefer v + value")
+@(require_results, deprecated="Prefer v - value")
 Vector3SubtractValue :: proc "c" (v: Vector3, value: f32) -> Vector3 {
 	return v - value
 }