diff --git a/base/runtime/default_temp_allocator_arena.odin b/base/runtime/default_temp_allocator_arena.odin
index eafaf9fbe..f1d09792a 100644
--- a/base/runtime/default_temp_allocator_arena.odin
+++ b/base/runtime/default_temp_allocator_arena.odin
@@ -97,15 +97,6 @@ alloc_from_memory_block :: proc(block: ^Memory_Block, min_size, alignment: uint)
 
 @(require_results)
 arena_alloc :: proc(arena: ^Arena, size, alignment: uint, loc := #caller_location) -> (data: []byte, err: Allocator_Error) {
-	align_forward_uint :: proc "contextless" (ptr, align: uint) -> uint {
-		p := ptr
-		modulo := p & (align-1)
-		if modulo != 0 {
-			p += align - modulo
-		}
-		return p
-	}
-
 	assert(alignment & (alignment-1) == 0, "non-power of two alignment", loc)
 
 	size := size
diff --git a/base/runtime/internal.odin b/base/runtime/internal.odin
index 12f0dceca..db17cb033 100644
--- a/base/runtime/internal.odin
+++ b/base/runtime/internal.odin
@@ -29,6 +29,30 @@ byte_slice :: #force_inline proc "contextless" (data: rawptr, len: int) -> []byt
 	return ([^]byte)(data)[:max(len, 0)]
 }
 
+@(require_results)
+align_forward_uint :: #force_inline proc "odin" (ptr, align: uint) -> uint {
+	assert(is_power_of_two_uint(align))
+	return (ptr + align-1) & ~(align-1)
+}
+
+@(require_results)
+align_forward_int :: #force_inline proc "odin" (ptr, align: int) -> int {
+	assert(is_power_of_two_int(align))
+	return int(align_forward_uint(uint(ptr), uint(align)))
+}
+
+@(require_results)
+align_forward_uintptr :: #force_inline proc "odin" (ptr, align: uintptr) -> uintptr {
+	return uintptr(align_forward_uint(uint(ptr), uint(align)))
+}
+
+align_forward :: proc {
+	align_forward_int,
+	align_forward_uint,
+	align_forward_uintptr,
+}
+
+@(require_results)
 is_power_of_two_int :: #force_inline proc "contextless" (x: int) -> bool {
 	if x <= 0 {
 		return false
@@ -36,51 +60,17 @@ is_power_of_two_int :: #force_inline proc "contextless" (x: int) -> bool {
 	return (x & (x-1)) == 0
 }
 
-align_forward_int :: #force_inline proc "odin" (ptr, align: int) -> int {
-	assert(is_power_of_two_int(align))
-
-	p := ptr
-	modulo := p & (align-1)
-	if modulo != 0 {
-		p += align - modulo
-	}
-	return p
-}
-
+@(require_results)
 is_power_of_two_uint :: #force_inline proc "contextless" (x: uint) -> bool {
-	if x <= 0 {
+	if x == 0 {
 		return false
 	}
 	return (x & (x-1)) == 0
 }
 
-align_forward_uint :: #force_inline proc "odin" (ptr, align: uint) -> uint {
-	assert(is_power_of_two_uint(align))
-
-	p := ptr
-	modulo := p & (align-1)
-	if modulo != 0 {
-		p += align - modulo
-	}
-	return p
-}
-
+@(require_results)
 is_power_of_two_uintptr :: #force_inline proc "contextless" (x: uintptr) -> bool {
-	if x <= 0 {
-		return false
-	}
-	return (x & (x-1)) == 0
-}
-
-align_forward_uintptr :: #force_inline proc "odin" (ptr, align: uintptr) -> uintptr {
-	assert(is_power_of_two_uintptr(align))
-
-	p := ptr
-	modulo := p & (align-1)
-	if modulo != 0 {
-		p += align - modulo
-	}
-	return p
+	return is_power_of_two_uint(uint(x))
 }
 
 is_power_of_two :: proc {
@@ -89,12 +79,6 @@ is_power_of_two :: proc {
 	is_power_of_two_uintptr,
 }
 
-align_forward :: proc {
-	align_forward_int,
-	align_forward_uint,
-	align_forward_uintptr,
-}
-
 mem_zero :: proc "contextless" (data: rawptr, len: int) -> rawptr {
 	if data == nil {
 		return nil
diff --git a/core/mem/mem.odin b/core/mem/mem.odin
index 8ce48d489..66da0f2d9 100644
--- a/core/mem/mem.odin
+++ b/core/mem/mem.odin
@@ -467,13 +467,7 @@ Check whether a number is a power of two.
 This procedure checks whether a given pointer-sized unsigned integer contains
 a power-of-two value.
 */
-@(require_results)
-is_power_of_two :: proc "contextless" (x: uintptr) -> bool {
-	if x <= 0 {
-		return false
-	}
-	return (x & (x-1)) == 0
-}
+is_power_of_two :: runtime.is_power_of_two_uintptr
 
 /*
 Check if a pointer is aligned.
@@ -497,11 +491,7 @@ bytes, `ptr` is returned.
 
 The specified alignment must be a power of 2.
 */
-@(require_results)
-align_forward_uintptr :: proc(ptr, align: uintptr) -> uintptr {
-	assert(is_power_of_two(align))
-	return (ptr + align-1) & ~(align-1)
-}
+align_forward_uintptr :: runtime.align_forward_uintptr
 
 /*
 Align pointer forward.
@@ -526,10 +516,7 @@ bytes, `ptr` is returned.
 
 The specified alignment must be a power of 2.
 */
-@(require_results)
-align_forward_int :: proc(ptr, align: int) -> int {
-	return int(align_forward_uintptr(uintptr(ptr), uintptr(align)))
-}
+align_forward_int :: runtime.align_forward_int
 
 /*
 Align uint forward.
@@ -540,10 +527,7 @@ bytes, `ptr` is returned.
 
 The specified alignment must be a power of 2.
 */
-@(require_results)
-align_forward_uint :: proc(ptr, align: uint) -> uint {
-	return uint(align_forward_uintptr(uintptr(ptr), uintptr(align)))
-}
+align_forward_uint :: runtime.align_forward_uint
 
 /*
 Align uintptr backwards.
@@ -626,32 +610,6 @@ reinterpret_copy :: proc "contextless" ($T: typeid, ptr: rawptr) -> (value: T) {
 	return
 }
 
-/*
-Dynamic array with a fixed capacity buffer.
-
-This type represents dynamic arrays with a fixed-size backing buffer. Upon
-allocating memory beyond reaching the maximum capacity, allocations from fixed
-byte buffers return `nil` and no error.
-*/
-Fixed_Byte_Buffer :: distinct [dynamic]byte
-
-/*
-Create a fixed byte buffer from a slice.
-*/
-@(require_results)
-make_fixed_byte_buffer :: proc "contextless" (backing: []byte) -> Fixed_Byte_Buffer {
-	s := transmute(Raw_Slice)backing
-	d: Raw_Dynamic_Array
-	d.data = s.data
-	d.len = 0
-	d.cap = s.len
-	d.allocator = Allocator{
-		procedure = nil_allocator_proc,
-		data = nil,
-	}
-	return transmute(Fixed_Byte_Buffer)d
-}
-
 /*
 General-purpose align formula.