diff --git a/build.sh b/build.sh
index d22b610..5bedded 100755
--- a/build.sh
+++ b/build.sh
@@ -112,6 +112,9 @@ if ! [ -f libvma.a ]; then
 	rm vma.o
 fi
 
+# Packer Codegen
+$compile $packer_source_files $compile_link $link_os_gfx $packer_flags -DBUILD_ASSET_CODEGEN $packer_include_flags $out PackerCodegen
+
 # Packer
 if [ -v packer ] || ! [ -f Packer ]; then
 	$compile $packer_source_files $compile_link $link_os_gfx $packer_flags $packer_include_flags $out $packer_out_name
@@ -121,5 +124,6 @@ if [ -v pack ] || ! [ -f assets.sgp ]; then
 	./Packer
 fi
 
-$compile $source_files $compile_link $link_os_gfx $out $out_name
-
+if ! [ -v packer ]; then
+	$compile $source_files $compile_link $link_os_gfx $out $out_name
+fi
diff --git a/src/allocators.c b/src/allocators.c
index 1871923..b5b325e 100644
--- a/src/allocators.c
+++ b/src/allocators.c
@@ -1,16 +1,23 @@
 // ::Allocator::Globals::
 
-FLAlloc FL_ALLOC = {0};
-Allocator ALLOC = {0};
-read_only FLNode FL_NIL_NODE = {0};
-read_only FreeList FL_NIL_LIST = {0};
+FLAlloc 
+FL_ALLOC = {0};
+Allocator 
+ALLOC = {0};
+read_only FLNode 
+FL_NIL_NODE = {0};
+read_only FreeList 
+FL_NIL_LIST = {0};
 
-constexpr usize FL_GLOBAL_SIZE = MB(32);
-static b32 FL_GLOBAL_INIT = false;
+constexpr usize 
+FL_GLOBAL_SIZE = MB(32);
+static b32 
+FL_GLOBAL_INIT = false;
 
 // ::Allocator::Util::Header::
 
-static inline usize CalcPaddingWithHeader(uintptr ptr, uintptr alignment, usize header_size)
+static inline usize 
+CalcPaddingWithHeader(uintptr ptr, uintptr alignment, usize header_size)
 {
 	Assert(IsPow2(alignment), "Alignment provided to CalcPaddingWithHeader is not a power of two");
 
@@ -30,7 +37,8 @@ static inline usize CalcPaddingWithHeader(uintptr ptr, uintptr alignment, usize
 	return (usize)padding;
 }
 
-static inline usize CalcPadding(uintptr ptr, uintptr alignment)
+static inline usize 
+CalcPadding(uintptr ptr, uintptr alignment)
 {
 	Assert(IsPow2(alignment), "CalcPadding failure: IsPow2 failed");
 
@@ -44,7 +52,8 @@ static inline usize CalcPadding(uintptr ptr, uintptr alignment)
 
 // ::Allocator::Arena::Start::
 
-static Arena *ArenaInit(rawptr buffer, usize size)
+static Arena *
+ArenaInit(rawptr buffer, usize size)
 {
 	Arena *arena = (Arena *)buffer;
 	buffer = PtrAdd(buffer, ARENA_HEADER_SIZE);
@@ -56,20 +65,23 @@ static Arena *ArenaInit(rawptr buffer, usize size)
 	return arena;
 }
 
-static Arena *ArenaCreate(usize size)
+static Arena *
+ArenaCreate(usize size)
 {
 	u8 *mem = pMemAllocZeroed(size);
 	return ArenaInit(mem, size);
 }
 
-static Arena *ArenaCreateDebug(usize size, u32 init_line_no)
+static Arena *
+ArenaCreateDebug(usize size, u32 init_line_no)
 {
 	u8 *mem = pMemAllocZeroed(size);
 	return ArenaInitDebug(mem, size, init_line_no);
 }
 
 // TODO: investigate overflows when out of memory because something bad is going on
-static rawptr ArenaAllocAlign(Arena *arena, usize size, usize align)
+static rawptr 
+ArenaAllocAlign(Arena *arena, usize size, usize align)
 {
 	rawptr ptr = NULL;
 
@@ -91,28 +103,33 @@ static rawptr ArenaAllocAlign(Arena *arena, usize size, usize align)
 	return ptr;
 }
 
-static rawptr ArenaAlloc(Arena *arena, usize size)
+static rawptr 
+ArenaAlloc(Arena *arena, usize size)
 {
 	return ArenaAllocAlign(arena, size, DEFAULT_ALIGNMENT);
 }
 
-static void ArenaFree(Arena *arena)
+static void 
+ArenaFree(Arena *arena)
 {
 	arena->pos = 0;
 }
 
-static void ArenaFreeZeroed(Arena *arena)
+static void 
+ArenaFreeZeroed(Arena *arena)
 {
 	MemZero(arena->buffer, arena->pos);
 	ArenaFree(arena);
 }
 
-static void DeallocArena(Arena *arena)
+static void 
+DeallocArena(Arena *arena)
 {
 	pMemFree(arena, arena->length);
 }
 
-static Arena * ArenaInitDebug(rawptr buffer, usize size, u32 init_line_no)
+static Arena * 
+ArenaInitDebug(rawptr buffer, usize size, u32 init_line_no)
 {
 	Arena *arena = ArenaInit(buffer, size);
 	arena->init_line_no = init_line_no;
@@ -125,7 +142,8 @@ static Arena * ArenaInitDebug(rawptr buffer, usize size, u32 init_line_no)
 
 // ::Allocator::GlobalAlloc::Start::
 
-static void InitAllocator(usize init_size)
+static void 
+InitAllocator(usize init_size)
 {
 	ALLOC.grow_size = init_size;
 	ALLOC.buffer = pMemAllocZeroed(init_size);
@@ -141,17 +159,20 @@ static void InitAllocator(usize init_size)
 	RBTreeInsert(ALLOC.tree, init_size, ALLOC.buffer);
 }
 
-static void DeinitAlloc()
+static void 
+DeinitAlloc()
 {
 	pMemFree(ALLOC.buffer, ALLOC.size);
 }
 
-static rawptr Alloc(usize size)
+static rawptr 
+Alloc(usize size)
 {
 	return AllocAlign(size, DEFAULT_ALIGNMENT);
 }
 
-static rawptr AllocAlign(usize size, usize alignment)
+static rawptr 
+AllocAlign(usize size, usize alignment)
 {
 	if (size == 0) return NULL;
 
@@ -178,14 +199,16 @@ static rawptr AllocAlign(usize size, usize alignment)
 
 // TODO: finish allocator
 // need an idea
-static void Free(rawptr ptr)
+static void 
+Free(rawptr ptr)
 {
 	if (ptr == NULL) return;
 
 	
 }
 
-static void AllocGrow(usize size)
+static void 
+AllocGrow(usize size)
 {
 	usize grow_size = size < ALLOC.grow_size ? ALLOC.grow_size : ALLOC.grow_size + size;
 	pMemRealloc(ALLOC.buffer, ALLOC.size, ALLOC.size + grow_size);
@@ -202,13 +225,15 @@ static void AllocGrow(usize size)
 
 // ::Allocator::FreeList::Start::
 
-static void GlobalFreeListInit(usize size)
+static void 
+GlobalFreeListInit(usize size)
 {
 	FreeListInit(&FL_ALLOC, size);
 	FL_GLOBAL_INIT = true;
 }
 
-static rawptr FLMemAlloc(usize size)
+static rawptr 
+FLMemAlloc(usize size)
 {
 	if (!FL_GLOBAL_INIT)
 	{
@@ -218,14 +243,16 @@ static rawptr FLMemAlloc(usize size)
 	return FreeListAlloc(&FL_ALLOC, size);
 }
 
-static rawptr FLMemAllocZeroed(usize size)
+static rawptr 
+FLMemAllocZeroed(usize size)
 {
 	rawptr ptr = FLMemAlloc(size);
 	MemZero(ptr, size);
 	return ptr;
 }
 
-static rawptr FLMemRealloc(rawptr old_ptr, usize size)
+static rawptr 
+FLMemRealloc(rawptr old_ptr, usize size)
 {
 	if (!FL_GLOBAL_INIT)
 	{
@@ -241,7 +268,8 @@ static rawptr FLMemRealloc(rawptr old_ptr, usize size)
 	return ptr;
 }
 
-static void FLMemFree(rawptr ptr)
+static void 
+FLMemFree(rawptr ptr)
 {
 	if (!FL_GLOBAL_INIT)
 	{
@@ -254,7 +282,8 @@ static void FLMemFree(rawptr ptr)
 /*
  * Should be async safe given no other thread frees a pointer in the middle of a realloc
  */
-static rawptr FreeListRealloc(FLAlloc *alloc, rawptr old_ptr, usize size)
+static rawptr 
+FreeListRealloc(FLAlloc *alloc, rawptr old_ptr, usize size)
 {
 	rawptr ptr = FreeListAlloc(alloc, size);
 	usize old_size = FreeListPtrSize(alloc, old_ptr);
@@ -266,7 +295,8 @@ static rawptr FreeListRealloc(FLAlloc *alloc, rawptr old_ptr, usize size)
 	return ptr;
 }
 
-static usize FreeListPtrSize(FLAlloc *alloc, rawptr ptr)
+static usize 
+FreeListPtrSize(FLAlloc *alloc, rawptr ptr)
 {
 	if (ptr == NULL) return 0;
 
@@ -286,7 +316,8 @@ static usize FreeListPtrSize(FLAlloc *alloc, rawptr ptr)
 	return size;
 }
 
-static void FreeListInit(FLAlloc *alloc, usize size)
+static void 
+FreeListInit(FLAlloc *alloc, usize size)
 {
 	alloc->list_head = pMemAllocZeroed(sizeof(FreeList));
 	alloc->nil = &FL_NIL_NODE;
@@ -297,7 +328,8 @@ static void FreeListInit(FLAlloc *alloc, usize size)
 	FreeListFreeAll(alloc);
 }
 
-static void _FreeListInit(FreeList **alloc, usize size)
+static void 
+_FreeListInit(FreeList **alloc, usize size)
 {
 	*alloc = (FreeList *)pMemAllocZeroed(size);
 	(*alloc)->data = (rawptr)(((uintptr)*alloc) + ((uintptr)sizeof(FreeList)));
@@ -306,7 +338,8 @@ static void _FreeListInit(FreeList **alloc, usize size)
 	(*alloc)->next = &FL_NIL_LIST;
 }
 
-static void FreeListFreeAll(FLAlloc *alloc)
+static void 
+FreeListFreeAll(FLAlloc *alloc)
 {
 	TicketMutLock(&alloc->mut);
 
@@ -331,7 +364,8 @@ static void FreeListFreeAll(FLAlloc *alloc)
 	TicketMutUnlock(&alloc->mut);
 }
 
-static FLNode *FreeListSearch(FreeList *alloc, usize size, usize alignment, usize *out_padding, FLNode **prev_node)
+static FLNode *
+FreeListSearch(FreeList *alloc, usize size, usize alignment, usize *out_padding, FLNode **prev_node)
 {
 	FLNode *node = alloc->head;
 	FLNode *prev = &FL_NIL_NODE;
@@ -361,7 +395,8 @@ static FLNode *FreeListSearch(FreeList *alloc, usize size, usize alignment, usiz
 /*
  *	NOT SAFE TO CALL OUTSIDE OF FreeListAlloc
  */
-static FreeList *FreeListGrow(FLAlloc *alloc, usize alloc_size)
+static FreeList *
+FreeListGrow(FLAlloc *alloc, usize alloc_size)
 {
 	usize grow_size = alloc->grow_size;
 	if (alloc_size > grow_size)
@@ -392,7 +427,8 @@ static FreeList *FreeListGrow(FLAlloc *alloc, usize alloc_size)
 	return list;
 }
 
-static rawptr _FreeListAllocAlign(FreeList *alloc, usize size, usize alignment)
+static rawptr 
+_FreeListAllocAlign(FreeList *alloc, usize size, usize alignment)
 {
 	if (size == 0) return NULL;
 
@@ -434,12 +470,14 @@ static rawptr _FreeListAllocAlign(FreeList *alloc, usize size, usize alignment)
 	return (rawptr)(((c8 *)header) + sizeof(FLAllocHeader));
 }
 
-static rawptr FreeListAlloc(FLAlloc *alloc, usize size)
+static rawptr 
+FreeListAlloc(FLAlloc *alloc, usize size)
 {
 	return FreeListAllocAlign(alloc, size, DEFAULT_ALIGNMENT);
 }
 
-static rawptr FreeListAllocAlign(FLAlloc *alloc, usize size, usize alignment)
+static rawptr 
+FreeListAllocAlign(FLAlloc *alloc, usize size, usize alignment)
 {
 	TicketMutLock(&alloc->mut);
 
@@ -469,7 +507,8 @@ static rawptr FreeListAllocAlign(FLAlloc *alloc, usize size, usize alignment)
 	return ptr;
 }
 
-static FreeList *_FreeListFindList(FLAlloc *alloc, rawptr ptr)
+static FreeList *
+_FreeListFindList(FLAlloc *alloc, rawptr ptr)
 {
 	FreeList *list = NULL;
 	FreeList *current = alloc->list_head;
@@ -488,7 +527,8 @@ static FreeList *_FreeListFindList(FLAlloc *alloc, rawptr ptr)
 	return list;
 }
 
-static void _FreeListFree(FreeList *alloc, rawptr ptr)
+static void 
+_FreeListFree(FreeList *alloc, rawptr ptr)
 {
 	FLAllocHeader *header = cast(FLAllocHeader *, u8ptr(ptr) - sizeof(FLAllocHeader));
 	FLNode *free_node = cast(FLNode *,header);
@@ -514,7 +554,8 @@ static void _FreeListFree(FreeList *alloc, rawptr ptr)
 	FreeListCoalescence(alloc, prev_node, free_node);
 }
 
-static void FreeListFree(FLAlloc *alloc, rawptr ptr)
+static void 
+FreeListFree(FLAlloc *alloc, rawptr ptr)
 {
 	if (ptr == NULL) return;
 
@@ -529,7 +570,8 @@ static void FreeListFree(FLAlloc *alloc, rawptr ptr)
 	TicketMutUnlock(&alloc->mut);
 }
 
-static void FreeListCoalescence(FreeList *alloc, FLNode *prev_node, FLNode *free_node)
+static void 
+FreeListCoalescence(FreeList *alloc, FLNode *prev_node, FLNode *free_node)
 {
 	if (free_node->next != &FL_NIL_NODE && (rawptr)(((c8 *)free_node) + free_node->size) == free_node->next)
 	{
@@ -544,7 +586,8 @@ static void FreeListCoalescence(FreeList *alloc, FLNode *prev_node, FLNode *free
 	}
 }
 
-static void FreeListRemove(FLNode **head, FLNode *prev_node, FLNode *del_node)
+static void 
+FreeListRemove(FLNode **head, FLNode *prev_node, FLNode *del_node)
 {
 	if (prev_node == &FL_NIL_NODE)
 		*head = del_node->next;
@@ -552,7 +595,8 @@ static void FreeListRemove(FLNode **head, FLNode *prev_node, FLNode *del_node)
 		prev_node->next = del_node->next;
 }
 
-static void FreeListInsert(FLNode **head, FLNode *prev_node, FLNode *new_node)
+static void 
+FreeListInsert(FLNode **head, FLNode *prev_node, FLNode *new_node)
 {
 	if (prev_node == &FL_NIL_NODE)
 	{
diff --git a/src/assets.c b/src/assets.c
index 76715d7..db434cb 100644
--- a/src/assets.c
+++ b/src/assets.c
@@ -80,6 +80,41 @@ static void apInit()
 
 // ::Assets::Loading::Functions::Start::
 
+static Asset
+apLoad(c8 *str)
+{
+	Asset asset = {0};
+
+	return asset;
+}
+
+static Asset
+apLoadS8(String8 str)
+{
+	return apLoad(str.value);
+}
+
+static void 
+apUnload(c8 *str)
+{
+	Asset asset = {0};
+
+	return asset;
+}
+
+static void
+apUnloadS8(String8 str)
+{
+	apUnload(str.value);
+}
+
+static u64
+apAssetIndex(c8 *str)
+{
+	return 0;
+}
+
+/*
 static Asset apLoadTexture(TextureAsset asset_id)
 {
 	if (!ASSET_HEADER_LOADED)
@@ -163,10 +198,8 @@ static TexMeta apGetTextureMeta(TextureAsset asset_id)
 
 static ModelMeta apGetModelMeta(ModelAsset asset_id)
 {
-	/*
-	AssetFile *asset_file = Model_Assets + asset_id;
-	return asset_file->model_meta;
-	*/
+	//AssetFile *asset_file = Model_Assets + asset_id;
+	//return asset_file->model_meta;
 
 	ModelMeta meta = {0};
 	Asset asset = Model_Asset_Lookup[asset_id];
@@ -211,6 +244,8 @@ static void apUnloadModel(ModelAsset asset_id)
 	}
 }
 
+*/
+
 // ::Assets::Loading::Functions::End::
 
 
diff --git a/src/assets.h b/src/assets.h
index b345921..6353bcc 100644
--- a/src/assets.h
+++ b/src/assets.h
@@ -6,70 +6,13 @@
 
 #define CreateMagicValue(a, b, c, d) ((u32)(d << 24) | (u32)(c << 16) | (u32)(b << 8) | (u32)(a))
 
+// ::Assets::Globals::Header::
+#ifndef BUILD_ASSET_CODEGEN
+#	include "codegen_assets.h"
+#endif
+
 // ::Assets::Types::Header::
 
-typedef enum AssetType_e : u32
-{
-	SHADER_ASSET,
-	TEXTURE_ASSET,
-	SOUND_ASSET,
-	MODEL_ASSET,
-	ASSET_TYPE_MAX,
-} AssetType;
-
-typedef enum ShaderAsset_e : u32
-{
-	QUAD_FRAG_SPIRV_SHADER,
-	QUAD_VERT_SPIRV_SHADER,
-	GUI_FRAG_SPIRV_SHADER,
-	GUI_VERT_SPIRV_SHADER,
-	PBR_FRAG_SPIRV_SHADER,
-	PBR_VERT_SPIRV_SHADER,
-	
-	SHADER_ASSET_MAX,
-} ShaderAsset;
-
-typedef enum TextureAsset_e : u32
-{
-	PATTERMON_OBESE,
-	PATTERMON_PURPLOID,
-	PATTERMON_YUKATA,
-	HAMSTER,
-	HAMSMOKER,
-	CHEESOID,
-	HOG,
-
-	TEXTURE_ASSET_MAX
-} TextureAsset;
-
-typedef enum TextureAssetTag_e : u32
-{
-	TEXTURE_ASSET_TAG_MAX,
-} TextureAssetTag;
-
-typedef enum SoundAsset_e : u32
-{
-	SOUND_ASSET_MAX,
-} SoundAsset;
-
-typedef enum SoundAssetTag_e : u32
-{
-	SOUND_ASSET_TAG_MAX,
-} SoundAssetTag;
-
-typedef enum ModelAsset_e : u32
-{
-	MODEL_YODA,
-	MODEL_BLOCK_CHAR,
-
-	MODEL_ASSET_MAX,
-} ModelAsset;
-
-typedef enum ModelAssetTag_e : u32
-{
-	MODEL_ASSET_TAG_MAX,
-} ModelAssetTag;
-
 typedef struct TexMeta
 {
 	u32 w;
@@ -100,6 +43,7 @@ typedef struct AssetTag
 
 typedef struct AssetFile
 {
+	u64 hash;
 	u64 data_offset;
 	u64 len;
 	union
@@ -113,11 +57,7 @@ typedef struct FileHeader
 {
 	u32 magic_num;
 	u32 version;
-
-	u32 tag_counts[ASSET_TYPE_MAX];
 	u32 asset_counts[ASSET_TYPE_MAX];
-
-	u64 tag_offsets[ASSET_TYPE_MAX];
 	u64 asset_offsets[ASSET_TYPE_MAX];
 } FileHeader;
 
@@ -127,20 +67,17 @@ static void apInit();
 
 // ::Assets::Loading::Functions::Header::
 
-static Asset apLoadTexture(TextureAsset asset_id);
-static Asset apLoadShader(ShaderAsset asset_id);
-static Asset apLoadModel(ModelAsset asset_id);
-static TexMeta apGetTextureMeta(TextureAsset asset_id);
-static ModelMeta apGetModelMeta(ModelAsset asset_id);
-static void apUnloadTexture(TextureAsset asset_id);
-static void apUnloadShader(ShaderAsset asset_id);
-static void apUnloadModel(ModelAsset asset_id);
+static Asset apLoad(c8 *str);
+static Asset apLoadS8(String8 str);
+static void  apUnload(c8 *str);
+static void  apUnloadS8(String8 str);
+static u64	 apAssetIndex(c8 *str);
 
 // ::Assets::Util::Functions::Header::
 
 // TODO(MA): Implement async asset handling
-static inline b32 apMarkUnloaded(AssetType type, u32 index);
-static inline void apMarkLoaded(AssetType type, u32 index);
+static inline b32 apMarkUnloaded(c8 *str);
+static inline void apMarkLoaded(c8 *str);
 
 // ::Assets::Models::Functions::Header::
 
diff --git a/src/codegen_assets.h b/src/codegen_assets.h
new file mode 100644
index 0000000..14539aa
--- /dev/null
+++ b/src/codegen_assets.h
@@ -0,0 +1,66 @@
+static c8 *
+g_Shader_Asset_Names[] = 
+{
+	"shaders/gui.frag",
+	"shaders/pbr.frag",
+	"shaders/gui.vert",
+	"shaders/quad.frag",
+	"shaders/quad.vert",
+	"shaders/pbr.vert",
+};
+
+static u64
+g_Shader_Asset_Hashes[] = 
+{
+	4076561469468128204U,
+	12546533630435803654U,
+	17203805968697784249U,
+	1277283055956479971U,
+	12273814537638279648U,
+	1941995729991819811U,
+};
+
+#define SHADER_ASSET_MAX 6
+
+static c8 *
+g_Model_Asset_Names[] = 
+{
+	"models/test_char",
+	"models/yoda",
+};
+
+static u64
+g_Model_Asset_Hashes[] = 
+{
+	17106564331948230266U,
+	1379945611816585992U,
+};
+
+#define MODEL_ASSET_MAX 2
+
+static c8 *
+g_Texture_Asset_Names[] = 
+{
+	"textures/ham_smoke",
+	"textures/cheesoid",
+	"textures/hog",
+	"textures/patamon",
+	"textures/pattermon",
+	"textures/hamster",
+	"textures/purplemon",
+};
+
+static u64
+g_Texture_Asset_Hashes[] = 
+{
+	3672471465693847963U,
+	17853259469867187617U,
+	12925726572206082157U,
+	1223697967736380744U,
+	16704275018603890077U,
+	13194708417649827129U,
+	12400748618931758111U,
+};
+
+#define TEXTURE_ASSET_MAX 7
+
diff --git a/src/ds.c b/src/ds.c
index 93cdbf1..92927dd 100644
--- a/src/ds.c
+++ b/src/ds.c
@@ -1,13 +1,19 @@
 // ::DataStructures::Globals::Start::
 
-RBNode RB_NIL = { .color = RB_BLACK };
-RBNode *P_RB_NIL = &RB_NIL;
+RBNode 
+RB_NIL = { .color = RB_BLACK };
+RBNode *
+P_RB_NIL = &RB_NIL;
 
-RBDataNode RB_DN_NIL = {0};
-RBDataNode *P_RB_DN_NIL = &RB_DN_NIL;
+RBDataNode 
+RB_DN_NIL = {0};
+RBDataNode *
+P_RB_DN_NIL = &RB_DN_NIL;
 
-HashNode HT_NIL = {0};
-HashNode *P_HT_NIL = &HT_NIL;
+HashNode 
+HT_NIL = {0};
+HashNode *
+P_HT_NIL = &HT_NIL;
 
 // ::DataStructures::Globals::End::
 
@@ -15,7 +21,8 @@ HashNode *P_HT_NIL = &HT_NIL;
 
 // ::DataStructures::RedBlackTree::Functions::Start::
 
-static void RBTreeInit(RBTree *tree)
+static void 
+RBTreeInit(RBTree *tree)
 {
 	Assert(tree != NULL, "RBTree is null");
 	RB_NIL.right = RB_NIL.left = RB_NIL.parent = P_RB_NIL;
@@ -25,14 +32,16 @@ static void RBTreeInit(RBTree *tree)
 	tree->nil = P_RB_NIL;
 }
 
-static inline void RBTreePushDataNode(RBDataNode *first, RBDataNode *last, rawptr value)
+static inline void 
+RBTreePushDataNode(RBDataNode *first, RBDataNode *last, rawptr value)
 {
 	RBDataNode *data_node = FLMemAllocZeroed(sizeof(RBDataNode));
 	data_node->data = value;
 	RBQueuePush(first, last, data_node);
 }
 
-static inline RBNode *RBTreeInitNode(u64 key, rawptr value)
+static inline RBNode *
+RBTreeInitNode(u64 key, rawptr value)
 {
 	RBNode *node = FLMemAllocZeroed(sizeof(RBNode));
 	node->parent = node->left = node->right = P_RB_NIL;
@@ -44,7 +53,8 @@ static inline RBNode *RBTreeInitNode(u64 key, rawptr value)
 	return node;
 }
 
-static void RBTreeInsert(RBTree *tree, u64 key, rawptr value)
+static void 
+RBTreeInsert(RBTree *tree, u64 key, rawptr value)
 {
 	RBNode *node = P_RB_NIL;
 
@@ -104,7 +114,8 @@ static void RBTreeInsert(RBTree *tree, u64 key, rawptr value)
 		RBTreeCorrect(tree, node);
 }
 
-static void RBTreeCorrect(RBTree *tree, RBNode *node)
+static void 
+RBTreeCorrect(RBTree *tree, RBNode *node)
 {
 	RBNode *gp = node->parent->parent;
 	RBNode *p = node->parent;
@@ -147,7 +158,8 @@ static void RBTreeCorrect(RBTree *tree, RBNode *node)
 	} while ((p = node->parent));
 }
 
-static void RBTreeDelete(RBTree *tree, u64 key, rawptr value)
+static void 
+RBTreeDelete(RBTree *tree, u64 key, rawptr value)
 {
 	RBNode *node = NULL;
 	Assert(RBTreeSearch(tree, key, &node), "Unable to find node in RBTreeDelete");
@@ -286,7 +298,8 @@ static void RBTreeDelete(RBTree *tree, u64 key, rawptr value)
 	}
 }
 
-static b32 RBTreeSearchNearest(RBTree *tree, u64 key, RBNode **out_node)
+static b32 
+RBTreeSearchNearest(RBTree *tree, u64 key, RBNode **out_node)
 {
 	if (tree->root == tree->nil) return false;
 
@@ -325,7 +338,8 @@ static b32 RBTreeSearchNearest(RBTree *tree, u64 key, RBNode **out_node)
 	return *out_node != tree->nil;
 }
 
-static b32 RBTreeSearch(RBTree *tree, u64 key, RBNode **out_node)
+static b32 
+RBTreeSearch(RBTree *tree, u64 key, RBNode **out_node)
 {
 	if (tree->root == tree->nil) return false;
 
@@ -355,7 +369,8 @@ static b32 RBTreeSearch(RBTree *tree, u64 key, RBNode **out_node)
 	return found;
 }
 
-static inline void RBTreeTransplant(RBTree *tree, RBNode *node, RBNode *placed_node)
+static inline void 
+RBTreeTransplant(RBTree *tree, RBNode *node, RBNode *placed_node)
 {
 	if (node->parent == tree->nil)
 		tree->root = placed_node;
@@ -367,7 +382,8 @@ static inline void RBTreeTransplant(RBTree *tree, RBNode *node, RBNode *placed_n
 	placed_node->parent = node->parent;
 }
 
-static void RBTreeRotate(RBTree *tree, RBNode *node, RBNodeDir dir)
+static void 
+RBTreeRotate(RBTree *tree, RBNode *node, RBNodeDir dir)
 {
 	RBNode *p = node->parent;
 	RBNode *root = node->child[1 - dir];
@@ -388,7 +404,8 @@ static void RBTreeRotate(RBTree *tree, RBNode *node, RBNodeDir dir)
 		tree->root = root;
 }
 
-static void RBTreeLeftRotate(RBTree *tree, RBNode *node)
+static void 
+RBTreeLeftRotate(RBTree *tree, RBNode *node)
 {
 	RBNode *right = node->right;
 	if (right->left != tree->nil)
@@ -406,7 +423,8 @@ static void RBTreeLeftRotate(RBTree *tree, RBNode *node)
 	node->parent = right;
 }
 
-static void RBTreeRightRotate(RBTree *tree, RBNode *node)
+static void 
+RBTreeRightRotate(RBTree *tree, RBNode *node)
 {
 	RBNode *left = node->left;
 	if (left->right != tree->nil)
@@ -430,7 +448,8 @@ static void RBTreeRightRotate(RBTree *tree, RBNode *node)
 
 // ::DataStructures::HashTable::Functions::Start::
 
-static void HashTableInit(HashTable *table, u32 init_size)
+static void 
+HashTableInit(HashTable *table, u32 init_size)
 {
 	table->cap = init_size;
 	table->count = 0;
@@ -445,12 +464,14 @@ static void HashTableInit(HashTable *table, u32 init_size)
 	}
 }
 
-static void HashTableConcatInPlace(HashList *list, HashList *to_concat)
+static void 
+HashTableConcatInPlace(HashList *list, HashList *to_concat)
 {
 	SLLConcatInPlaceNoCount(list, to_concat);
 }
 
-static void HashTableClear(HashTable *table)
+static void 
+HashTableClear(HashTable *table)
 {
 	table->count = 0;
 	for (u32 i = 0; i < table->count; i++)
@@ -459,14 +480,16 @@ static void HashTableClear(HashTable *table)
 	}
 }
 
-static HashNode *HashListPop(HashList *list)
+static HashNode *
+HashListPop(HashList *list)
 {
 	HashNode *result = list->first;
 	HTQueuePop(list->first, list->last);
 	return result;
 }
 
-static HashNode *HashTablePush(HashTable *table, u64 hash, KeyValuePair value)
+static HashNode *
+HashTablePush(HashTable *table, u64 hash, KeyValuePair value)
 {
 	HashNode *node = NULL;
 	if (table->free_lists.first != P_HT_NIL)
@@ -484,43 +507,50 @@ static HashNode *HashTablePush(HashTable *table, u64 hash, KeyValuePair value)
 	return node;
 }
 
-static HashNode *HashTablePushU64U32(HashTable *table, u64 key, u32 value)
+static HashNode *
+HashTablePushU64U32(HashTable *table, u64 key, u32 value)
 {
 	u64 hash = HashFromString(String8Struct(&key));
 	return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_u32 = value });
 }
 
-static HashNode *HashTablePushU64U64(HashTable *table, u64 key, u64 value)
+static HashNode *
+HashTablePushU64U64(HashTable *table, u64 key, u64 value)
 {
 	u64 hash = HashFromString(String8Struct(&key));
 	return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_u64 = value });
 }
 
-static HashNode *HashTablePushU64String8(HashTable *table, u64 key, String8 value)
+static HashNode *
+HashTablePushU64String8(HashTable *table, u64 key, String8 value)
 {
 	u64 hash = HashFromString(String8Struct(&key));
 	return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_string = value });
 }
 
-static HashNode *HashTablePushU64Rawptr(HashTable *table, u64 key, rawptr value)
+static HashNode *
+HashTablePushU64Rawptr(HashTable *table, u64 key, rawptr value)
 {
 	u64 hash = HashFromString(String8Struct(&key));
 	return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_rawptr = value });
 }
 
-static HashNode *HashTablePushU64U64Split(HashTable *table, u64 key, u32 upper, u32 lower)
+static HashNode *
+HashTablePushU64U64Split(HashTable *table, u64 key, u32 upper, u32 lower)
 {
 	u64 hash = HashFromString(String8Struct(&key));
 	return HashTablePush(table, hash, (KeyValuePair){ .key_u64 = key, .value_u64_split = { .upper = upper, .lower = lower }});
 }
 
-static HashNode *HashTablePushRawptrU64(HashTable *table, rawptr key, u64 value)
+static HashNode *
+HashTablePushRawptrU64(HashTable *table, rawptr key, u64 value)
 {
 	u64 hash = HashFromString(String8Struct(&key));
 	return HashTablePush(table, hash, (KeyValuePair){ .key_rawptr = key, .value_u64 = value });
 }
 
-static KeyValuePair *HashTableSearchU64(HashTable *table, u64 key)
+static KeyValuePair *
+HashTableSearchU64(HashTable *table, u64 key)
 {
 	KeyValuePair *result = NULL;
 
@@ -539,7 +569,8 @@ static KeyValuePair *HashTableSearchU64(HashTable *table, u64 key)
 	return result;
 }
 
-static KeyValuePair *HashTableSearchRawptr(HashTable *table, rawptr key)
+static KeyValuePair *
+HashTableSearchRawptr(HashTable *table, rawptr key)
 {
 	KeyValuePair *result = NULL;
 
@@ -558,7 +589,8 @@ static KeyValuePair *HashTableSearchRawptr(HashTable *table, rawptr key)
 	return result;
 }
 
-static void HashTableDeleteU64(HashTable *table, u64 key)
+static void 
+HashTableDeleteU64(HashTable *table, u64 key)
 {
 	u64 hash = HashFromString(String8Struct(&key));
 	u64 index = hash % table->cap;
@@ -579,7 +611,8 @@ static void HashTableDeleteU64(HashTable *table, u64 key)
 	}
 }
 
-static rawptr HashTableDeleteU64Rawptr(HashTable *table, u64 key)
+static rawptr 
+HashTableDeleteU64Rawptr(HashTable *table, u64 key)
 {
 	rawptr value = NULL;
 
@@ -606,7 +639,8 @@ static rawptr HashTableDeleteU64Rawptr(HashTable *table, u64 key)
 	return value;
 }
 
-static U64Split HashTableDeleteU64U64Split(HashTable *table, u64 key)
+static U64Split 
+HashTableDeleteU64U64Split(HashTable *table, u64 key)
 {
 	U64Split value = { .upper = UINT32_MAX };
 
diff --git a/src/entry_linux.c b/src/entry_linux.c
index 12f45be..3e896ff 100644
--- a/src/entry_linux.c
+++ b/src/entry_linux.c
@@ -24,9 +24,10 @@ int PROGRAM_FAILED = false;
 # include "tests.c"
 #endif
 
-static_assert(__COUNTER__ < Len(GLOBAL_PROFILER.anchors));
+static_assert(__COUNTER__ < Len(g_Global_Profiler.anchors));
 
-void TraverseNode(RBTree *tree, RBNode *node, RBNodeDir *dir)
+void 
+TraverseNode(RBTree *tree, RBNode *node, RBNodeDir *dir)
 {
 	char *dir_str = dir == NULL ? "Root" : *dir == RB_RIGHT ? "Right" : "Left";
 	Printfln("Color: %s Value: %d Dir: %s", node->color == RB_RED ? "Red" : "Black", node->key, dir_str);
@@ -42,12 +43,14 @@ void TraverseNode(RBTree *tree, RBNode *node, RBNodeDir *dir)
 	}
 }
 
-void Traverse(RBTree *tree)
+void 
+Traverse(RBTree *tree)
 {
 	TraverseNode(tree, tree->root, NULL);
 }
 
-int main(int argc, char **argv) 
+int 
+main(int argc, char **argv) 
 {
 #ifdef BUILD_TEST
 {
@@ -70,7 +73,7 @@ int main(int argc, char **argv)
 
 	gInit(&ctx);
 
-	while (!global_quit)
+	while (!g_Global_Quit)
 	{
 		pWindowEventsGet(inputs, &i_count);
 		gRunCycle(&ctx, inputs, i_count);
diff --git a/src/entry_windows.c b/src/entry_windows.c
index dbbd6c3..e25f80b 100644
--- a/src/entry_windows.c
+++ b/src/entry_windows.c
@@ -15,9 +15,10 @@
 #include "renderer.c"
 #include "game.c"
 
-int CALLBACK WinMain(HINSTANCE instance, HINSTANCE prev_instance, LPSTR cmd_line, int show_code)
+int CALLBACK 
+WinMain(HINSTANCE instance, HINSTANCE prev_instance, LPSTR cmd_line, int show_code)
 {
-	win32_instance = instance;
+	g_Win32_Instance = instance;
 
 #ifdef BUILD_DEBUG
 	{
@@ -44,7 +45,7 @@ int CALLBACK WinMain(HINSTANCE instance, HINSTANCE prev_instance, LPSTR cmd_line
 	
 	gInit(&ctx);
 
-	while (!global_quit)
+	while (!g_Global_Quit)
 	{
 		pWindowEventsGet();
 		gRunCycle(&ctx, inputs, i_count);
diff --git a/src/game.c b/src/game.c
index 01c2c6a..017e7c1 100644
--- a/src/game.c
+++ b/src/game.c
@@ -2,13 +2,20 @@
 
 // TEMP
 
-u32 selected_rect = 0;
-b8 mouse_pressed = false;
-b8 mouse_clicked = false;
-i16 mouse_prev_pos_x = 0;
-i16 mouse_prev_pos_y = 0;
-i16 mouse_pos_x = 0;
-i16 mouse_pos_y = 0;
+u32 
+selected_rect = 0;
+b8 
+mouse_pressed = false;
+b8 
+mouse_clicked = false;
+i16 
+mouse_prev_pos_x = 0;
+i16 
+mouse_prev_pos_y = 0;
+i16 
+mouse_pos_x = 0;
+i16 
+mouse_pos_y = 0;
 
 // ::Game::Globals::End::
 
@@ -16,7 +23,8 @@ i16 mouse_pos_y = 0;
 
 // ::Game::Init::Functions::Start::
 
-static void gInit(gGameCtx *ctx) 
+static void 
+gInit(gGameCtx *ctx) 
 {
   Assert(rInit(), "Failed to initialize the renderer");
 
@@ -35,7 +43,8 @@ static void gInit(gGameCtx *ctx)
 	ctx->btn_len = 0;
 }
 
-static void gDestroy()
+static void 
+gDestroy()
 {
 	rDestroy();
 }
@@ -46,12 +55,14 @@ static void gDestroy()
 
 // ::Game::GameLoop::Functions::Start::
 
-static void gFrameStartNew()
+static void 
+gFrameStartNew()
 {
 	
 }
 
-static void gRunCycle(gGameCtx *ctx, pGameInput *inputs, u32 i_count)
+static void 
+gRunCycle(gGameCtx *ctx, pGameInput *inputs, u32 i_count)
 {
 	ArenaFree(vFrameArena());
 
@@ -65,10 +76,10 @@ static void gRunCycle(gGameCtx *ctx, pGameInput *inputs, u32 i_count)
 
 	u64 index = vFrameIndex();
 	
+	/*
 	rDescHandle yoder = rMeshLoad(MODEL_YODA);
 	ctx->pc.mesh_index = yoder.desc_index;
-
-	ModelMeta model_meta = apGetModelMeta(MODEL_YODA);
+	*/
 	
 	rViewportSize(&ctx->pc.res);
 	ctx->pc.time = (f32)pCPUTimerRead();
@@ -89,9 +100,9 @@ static void gRunCycle(gGameCtx *ctx, pGameInput *inputs, u32 i_count)
 	//rBufferBindGUIVertex();
 	//rBufferBindGUIIndex();
 
-	rBufferBindMesh(&ctx->pc, yoder);
+	//rBufferBindMesh(&ctx->pc, yoder);
 
-	rDrawIndexed(model_meta.i_count, 1);
+	//rDrawIndexed(model_meta.i_count, 1);
 
 	rFrameFinish();
 
@@ -107,7 +118,8 @@ static void gRunCycle(gGameCtx *ctx, pGameInput *inputs, u32 i_count)
 
 // ::Game::Inputs::Functions::Start::
 
-static void gHandleInputs(pGameInput *inputs, u32 count)
+static void 
+gHandleInputs(pGameInput *inputs, u32 count)
 {
 	mouse_clicked = false;
 
@@ -161,12 +173,14 @@ static void gHandleInputs(pGameInput *inputs, u32 count)
 
 // ::Game::GUI::Functions::Start::
 
-static inline void gPrepareGUICtx(gGameCtx *ctx)
+static inline void 
+gPrepareGUICtx(gGameCtx *ctx)
 {
 	ctx->gui.has_grabbed = false;
 }
 
-static b32 gButton(gGameCtx *ctx, char *label, f32 x0, f32 y0, f32 x1, f32 y1)
+static b32 
+gButton(gGameCtx *ctx, char *label, f32 x0, f32 y0, f32 x1, f32 y1)
 {
 	gButtonWidget *btn = NULL;
 	u64 id = HashFromString(String8CStr(label));
@@ -226,7 +240,8 @@ static b32 gButton(gGameCtx *ctx, char *label, f32 x0, f32 y0, f32 x1, f32 y1)
 	return btn->pressed;
 }
 
-static b32 gWindow(gGameCtx *ctx, char *title, f32 x0, f32 y0, f32 x1, f32 y1, rDescHandle handle)
+static b32 
+gWindow(gGameCtx *ctx, char *title, f32 x0, f32 y0, f32 x1, f32 y1, rDescHandle handle)
 {
 	gWindowWidget *win = NULL;
 	u32 id = HashFromString(String8CStr(title));
@@ -307,7 +322,8 @@ static b32 gWindow(gGameCtx *ctx, char *title, f32 x0, f32 y0, f32 x1, f32 y1, r
 }
 
 
-static void gRect(gUICtx *ctx, Vec2 p0, Vec2 p1, Vec4 col, rDescHandle handle)
+static void 
+gRect(gUICtx *ctx, Vec2 p0, Vec2 p1, Vec4 col, rDescHandle handle)
 {
 	ctx->vertices[ctx->vertices_len].p0 = p0;
 	ctx->vertices[ctx->vertices_len].p1 = p1;
diff --git a/src/packer.c b/src/packer.c
index 36eaa5e..2c6486f 100644
--- a/src/packer.c
+++ b/src/packer.c
@@ -17,108 +17,201 @@
 # include <fcntl.h>
 #endif
 
-// ::Packer::Includes::CFiles::End::
-
-
-
-// ::Packer::Globals::Start::
-
-const FileMapping g_Shader_File_Map[] = {
-	{ .file_name = "quad.frag.spv", .ix = QUAD_FRAG_SPIRV_SHADER },
-	{ .file_name = "quad.vert.spv", .ix = QUAD_VERT_SPIRV_SHADER },
-	{ .file_name = "gui.frag.spv", .ix = GUI_FRAG_SPIRV_SHADER },
-	{ .file_name = "gui.vert.spv", .ix = GUI_VERT_SPIRV_SHADER },
-	{ .file_name = "pbr.frag.spv", .ix = PBR_FRAG_SPIRV_SHADER },
-	{ .file_name = "pbr.vert.spv", .ix = PBR_VERT_SPIRV_SHADER },
-};
-
-const FileMapping g_Texture_File_Map[] = {
-	{ .file_name = "pattermon.png", .ix = PATTERMON_OBESE },
-	{ .file_name = "patamon.png", .ix = PATTERMON_YUKATA }, 
-	{ .file_name = "purplemon.png", .ix = PATTERMON_PURPLOID },
-	{ .file_name = "hamster.png", .ix = HAMSTER },
-	{ .file_name = "ham_smoke.png", .ix = HAMSMOKER },
-	{ .file_name = "cheesoid.png", .ix = CHEESOID },
-	{ .file_name = "hog.jpg", .ix = HOG },
-};
-
-const FileMapping g_Model_File_Map[] = {
-	{ .file_name = "yoda.m3d", .ix = MODEL_YODA },
-	{ .file_name = "test_char.m3d", .ix = MODEL_BLOCK_CHAR },
-};
-
-c8 *g_Shader_File_Names[SHADER_ASSET_MAX] = {0};
-c8 *g_Texture_File_Names[TEXTURE_ASSET_MAX] = {0};
-c8 *g_Model_File_Names[MODEL_ASSET_MAX] = {0};
-
-// ::Packer::Globals::End::
-
-
-
 // ::Packer::Packing::Functions::Start::
 
-void SetArrayLookups()
+#ifdef BUILD_ASSET_CODEGEN
+
+u64
+WriteArrayToFile(Arena *arena, pFile file, String8 array_name, rawptr elements, u32 count, String8 type, u64 offset)
 {
-	for (i32 i = 0; i < Len(g_Shader_File_Map); i++)
+	b32 is_string = StrEq(type.value, "c8 *");
+	c8 *decl = MakeArray(arena, c8, 2048);
+	i32 decl_len = SPrintf(decl, 2048, "static %s\n%s[] = \n{\n\t", type.value, array_name.value);
+	String8 result = {
+		.value = decl,
+		.len = u64(decl_len),
+	};
+
+	if (is_string)
 	{
-		FileMapping file_mapping = g_Shader_File_Map[i];
-		g_Shader_File_Names[file_mapping.ix] = file_mapping.file_name;
+		String8 *strs = (String8 *)elements;
+		for (u32 i = 0; i < count; i += 1)
+		{
+			c8 *f = i == count-1 ? "\"%s\"," : "\"%s\",\n\t";
+			c8 buf[512];
+			decl_len = SPrintf(buf, 512, f, strs[i].value);
+			result = String8Concat(arena, result, MakeString8(buf, decl_len));
+		}
+	}
+	else
+	{
+		u64 *ints = (u64 *)elements;
+		for (u32 i = 0; i < count; i += 1)
+		{
+			c8 *f = i == count-1 ? "%lluU," : "%lluU,\n\t";
+			c8 buf[512];
+			decl_len = SPrintf(buf, 512, f, ints[i]);
+			result = String8Concat(arena, result, MakeString8(buf, decl_len));
+		}
 	}
 
-	for (int i = 0; i < SHADER_ASSET_MAX; i++)
-	{
-		Assert(g_Shader_File_Names[i] != NULL, "Spirv shader file name is null");
-	}
+	result = String8Concat(arena, result, String8CStr("\n};\n\n"));
 
-	for (i32 i = 0; i < Len(g_Texture_File_Map); i++)
-	{
-		FileMapping file_mapping = g_Texture_File_Map[i];
-		g_Texture_File_Names[file_mapping.ix] = file_mapping.file_name;
-	}
-
-	for (int i = 0; i < TEXTURE_ASSET_MAX; i++)
-	{
-		Assert(g_Texture_File_Names[i] != NULL, "Texture file name is null");
-	}
-
-	for (i32 i = 0; i < Len(g_Model_File_Map); i++)
-	{
-		FileMapping file_mapping = g_Model_File_Map[i];
-		g_Model_File_Names[file_mapping.ix] = file_mapping.file_name;
-	}
-
-	for (int i = 0; i < MODEL_ASSET_MAX; i++)
-	{
-		Assert(g_Model_File_Names[i] != NULL, "Model file name is null");
-	}
+	return pFileWrite(file, offset, result.value, result.len);
 }
 
-i32 WriteHeader(pFile file, FileHeader *header)
+static String8 *
+ConvertCStrs(Arena *arena, c8 **strs, u32 count)
+{
+	String8 *str8s = MakeArray(arena, String8, count);
+
+	for (u32 i = 0; i < count; i += 1)
+	{
+		str8s[i].value = strs[i];
+		str8s[i].len = StrLen(strs[i]);
+	}
+
+	return str8s;
+}
+
+void
+CodeGenAssetLookups(Arena *arena)
+{
+	pFile file = pFileOpen("../src/codegen_assets.h", pFS_WRITE | pFS_CREATE | pFS_TRUNC);
+	Assert(file > 0, "CodeGenAssetLookups failure: unable to open/create file");
+
+	Assert(pDirNavigate("../assets") == 0, "Unable to navigate to asset directory");
+
+	struct AssetDirInfo {
+		c8 *prefix, *struct_name, *hash_struct_name, *dir, *define;
+	};
+
+	struct AssetDirInfo dirs[] = {
+		{
+			.prefix = "shaders/",
+			.struct_name = "g_Shader_Asset_Names",
+			.hash_struct_name = "g_Shader_Asset_Hashes",
+			.dir = "shaders",
+			.define = "SHADER_ASSET",
+		},
+		{
+			.prefix = "models/",
+			.struct_name = "g_Model_Asset_Names",
+			.hash_struct_name = "g_Model_Asset_Hashes",
+			.dir = "models",
+			.define = "MODEL_ASSET",
+		},
+		{
+			.prefix = "textures/",
+			.struct_name = "g_Texture_Asset_Names",
+			.hash_struct_name = "g_Texture_Asset_Hashes",
+			.dir = "textures",
+			.define = "TEXTURE_ASSET",
+		},
+	};
+
+	u64 offset = 0;
+	u32 dir_count = sizeof(dirs) / sizeof(struct AssetDirInfo);
+	for (u32 i = 0; i < dir_count; i += 1)
+	{
+		Assert(pDirNavigate(dirs[i].dir) == 0, "Unable to navigate to asset sub directory.");
+
+		u32 count = 0;
+		c8 **cstrs = pDirGetFileNames(arena, &count);
+		u64 *hashes = MakeArray(arena, u64, count);
+		String8 *strs = ConvertCStrs(arena, cstrs, count);
+
+		for (u32 j = 0; j < count; j += 1)
+		{
+			strs[j] = String8Concat(arena, String8CStr(dirs[i].prefix), strs[j]);
+			i64 offset = String8FindLast(strs[j], '.');
+			hashes[j] = XXH3_64bits_withSeed(strs[j].value, strs[j].len - offset, HASH_SEED);
+		}
+
+		offset += WriteArrayToFile(
+			arena, 
+			file, 
+			String8CStr(dirs[i].struct_name), 
+			strs,
+			count,
+			String8CStr("c8 *"),
+			offset
+		);
+
+		offset += WriteArrayToFile(
+			arena,
+			file,
+			String8CStr(dirs[i].hash_struct_name),
+			hashes,
+			count,
+			String8CStr("u64"),
+			offset
+		);
+
+		c8 buf[128];
+		i32 decl_len = SPrintf(buf, 128, "#define %s_MAX %llu\n\n#define %s %llu\n\n", dirs[i].define, count, dirs[i].define, i);
+
+		offset += pFileWrite(file, offset, buf, decl_len);
+
+		Assert(pDirNavigate("..") == 0, "CodeGenAssetLookups failure: unable to move back to build directory");
+	}
+
+	pFileClose(file);
+}
+
+int
+main(int argc, c8 **argv)
+{
+	#ifdef _WIN32
+	{
+		_set_fmode(_O_BINARY);
+	}
+	#endif
+
+	if (pDirIsVisible("build"))
+	{
+		Assert(pDirNavigate("./build") == 0, "Unable to change to build directory");
+	}
+
+	void *mem = pMemAllocZeroed(GB(1));
+	Arena *arena = ArenaInitDebug(mem, GB(1), __LINE__);
+
+	CodeGenAssetLookups(arena);
+}
+
+#else
+
+i32 
+WriteHeader(pFile file, FileHeader *header)
 {
 	i32 offset = 0;
 	
 	return offset;
 }
 
-void MoveToShaderDir(c8 **return_dir)
+void 
+MoveToShaderDir(c8 **return_dir)
 {
 	Assert(pDirNavigate("../assets/shaders") == 0, "Unable to change to shader directory");
 	*return_dir = "../../build";
 }
 
-void MoveToTextureDir(c8 **return_dir)
+void 
+MoveToTextureDir(c8 **return_dir)
 {
 	Assert(pDirNavigate("../assets/textures") == 0, "Unable to change to assets directory");
 	*return_dir = "../../build";
 }
 
-void MoveToModelDir(c8 **return_dir)
+void 
+MoveToModelDir(c8 **return_dir)
 {
 	Assert(pDirNavigate("../assets/models") == 0, "Unable to change to assets directory");
 	*return_dir = "../../build";
 }
 
-void InitHeader(FileHeader *header)
+void 
+InitHeader(FileHeader *header)
 {
 	Assert(header != NULL, "File header is null");
 
@@ -126,29 +219,14 @@ void InitHeader(FileHeader *header)
 	header->version = FILE_VERSION;
 
 	header->asset_counts[SHADER_ASSET] = SHADER_ASSET_MAX;
-	header->tag_counts[SHADER_ASSET] = 0;
-
 	header->asset_counts[TEXTURE_ASSET] = TEXTURE_ASSET_MAX;
-	header->tag_counts[TEXTURE_ASSET] = TEXTURE_ASSET_TAG_MAX;
-
 	header->asset_counts[SOUND_ASSET] = SOUND_ASSET_MAX;
-	header->tag_counts[SOUND_ASSET] = SOUND_ASSET_TAG_MAX;
-
 	header->asset_counts[MODEL_ASSET] = MODEL_ASSET_MAX;
-	header->tag_counts[MODEL_ASSET] = MODEL_ASSET_TAG_MAX;
 
 	u64 offset = sizeof(FileHeader);
 
 	for (u32 i = 0; i < ASSET_TYPE_MAX; i++)
 	{
-		if (header->tag_counts[i] > 0)
-		{
-			header->tag_offsets[i] = offset;
-			offset += sizeof(AssetTag) * header->tag_counts[i];
-		}
-		else
-			header->tag_offsets[i] = 0;
-
 		if (header->asset_counts[i] > 0)
 		{
 			header->asset_offsets[i] = offset;
@@ -159,7 +237,8 @@ void InitHeader(FileHeader *header)
 	}
 }
 
-void PackFiles(Arena *arena, FileHeader *header)
+void 
+PackFiles(Arena *arena, FileHeader *header)
 {
 	pFile file = pFileOpen("assets.sgp", pFS_WRITE | pFS_TRUNC);
 
@@ -168,10 +247,6 @@ void PackFiles(Arena *arena, FileHeader *header)
 	u64 data_offset = 0;
 	for (u32 i = 0; i < ASSET_TYPE_MAX; i++)
 	{
-		u64 tag_offset = header->tag_offsets[i] + (header->tag_counts[i] * sizeof(AssetTag));
-		if (tag_offset > data_offset)
-			data_offset = tag_offset;
-
 		u64 asset_offset = header->asset_offsets[i] + (header->asset_counts[i] * sizeof(AssetFile));
 		if (asset_offset > data_offset)
 			data_offset = asset_offset;
@@ -184,7 +259,7 @@ void PackFiles(Arena *arena, FileHeader *header)
 	AssetFile *shader_assets = MakeArray(arena, AssetFile, SHADER_ASSET_MAX);
 	for (u32 i = 0; i < SHADER_ASSET_MAX; i++)
 	{
-		c8 *asset_name = g_Shader_File_Names[i];
+		c8 *asset_name = g_Shader_Asset_Names[i];
 
 		Printfln("Packing file: %s...", asset_name);
 
@@ -211,7 +286,7 @@ void PackFiles(Arena *arena, FileHeader *header)
 	AssetFile *texture_assets = MakeArray(arena, AssetFile, TEXTURE_ASSET_MAX);
 	for (u32 i = 0; i < TEXTURE_ASSET_MAX; i++)
 	{
-		c8 *asset_name = g_Texture_File_Names[i];
+		c8 *asset_name = g_Texture_Asset_Names[i];
 
 		Printfln("Packing file: %s...", asset_name);
 
@@ -254,7 +329,7 @@ void PackFiles(Arena *arena, FileHeader *header)
 	AssetFile *model_assets = MakeArray(arena, AssetFile, MODEL_ASSET_MAX);
 	for (u32 i = 0; i < MODEL_ASSET_MAX; i++)
 	{
-		c8 *asset_name = g_Model_File_Names[i];
+		c8 *asset_name = g_Model_Asset_Names[i];
 
 		Printfln("Packing file: %s...", asset_name);
 
@@ -288,7 +363,8 @@ void PackFiles(Arena *arena, FileHeader *header)
 
 // ::Packer::Tests::Functions::Start::
 
-static inline void TestAssetIsCorrect(Arena *arena, c8 *file_name, AssetFile *file_info, AssetType type, pFile file)
+static inline void 
+TestAssetIsCorrect(Arena *arena, c8 *file_name, AssetFile *file_info, AssetType type, pFile file)
 {
 	pFile asset_file = pFileOpen(file_name, pFS_READ);
 	u64 size = pFileLength(asset_file);
@@ -331,7 +407,8 @@ static inline void TestAssetIsCorrect(Arena *arena, c8 *file_name, AssetFile *fi
 	pFileClose(asset_file);
 }
 
-void TestAssetPack(Arena *arena)
+void 
+TestAssetPack(Arena *arena)
 {
 	pFile file = pFileOpen("assets.sgp", pFS_READ);
 
@@ -341,16 +418,9 @@ void TestAssetPack(Arena *arena)
 	Assert(header.magic_num == CreateMagicValue('s', 't', 'e', 'g'), "Magic number is incorrect");
 	Assert(header.version == FILE_VERSION, "File version is incorrect");
 
-	Assert(header.tag_counts[SHADER_ASSET] == 0, "Shader tag count incorrect");
 	Assert(header.asset_counts[SHADER_ASSET] == SHADER_ASSET_MAX, "Shader count incorrect");
-
-	Assert(header.tag_counts[TEXTURE_ASSET] == TEXTURE_ASSET_TAG_MAX, "Texture tag count incorrect");
 	Assert(header.asset_counts[TEXTURE_ASSET] == TEXTURE_ASSET_MAX, "Texture count incorrect");
-
-	Assert(header.tag_counts[SOUND_ASSET] == SOUND_ASSET_TAG_MAX, "Sound tag count incorrect");
 	Assert(header.asset_counts[SOUND_ASSET] == SOUND_ASSET_MAX, "Sound count incorrect");
-	
-	Assert(header.tag_counts[MODEL_ASSET] == MODEL_ASSET_TAG_MAX, "Model tag count incorrect");
 	Assert(header.asset_counts[MODEL_ASSET] == MODEL_ASSET_MAX, "Model count incorrect");
 
 	AssetTag *tags[ASSET_TYPE_MAX];
@@ -358,12 +428,6 @@ void TestAssetPack(Arena *arena)
 
 	for (u32 i = 0; i < ASSET_TYPE_MAX; i++)
 	{
-		if (header.tag_counts[i] > 0)
-		{
-			tags[i] = MakeArray(arena, AssetTag, header.tag_counts[i]);
-			pFileRead(file, header.tag_offsets[i], tags[i], sizeof(AssetTag)*header.tag_counts[i]);
-		}
-
 		if (header.asset_counts[i] > 0)
 		{
 			files[i] = MakeArray(arena, AssetFile, header.asset_counts[i]);
@@ -376,7 +440,7 @@ void TestAssetPack(Arena *arena)
 	
 	for (u32 i = 0; i < SHADER_ASSET_MAX; i++)
 	{
-		TestAssetIsCorrect(arena, g_Shader_File_Names[i], &files[SHADER_ASSET][i], SHADER_ASSET, file);
+		TestAssetIsCorrect(arena, g_Shader_Asset_Names[i], &files[SHADER_ASSET][i], SHADER_ASSET, file);
 	}
 
 	pDirNavigate(return_dir);
@@ -384,7 +448,7 @@ void TestAssetPack(Arena *arena)
 
 	for (u32 i = 0; i < TEXTURE_ASSET_MAX; i++)
 	{
-		TestAssetIsCorrect(arena, g_Texture_File_Names[i], &files[TEXTURE_ASSET][i], TEXTURE_ASSET, file);
+		TestAssetIsCorrect(arena, g_Texture_Asset_Names[i], &files[TEXTURE_ASSET][i], TEXTURE_ASSET, file);
 	}
 
 	pDirNavigate(return_dir);
@@ -392,7 +456,7 @@ void TestAssetPack(Arena *arena)
 
 	for (u32 i = 0; i < MODEL_ASSET_MAX; i++)
 	{
-		TestAssetIsCorrect(arena, g_Model_File_Names[i], &files[MODEL_ASSET][i], MODEL_ASSET, file);
+		TestAssetIsCorrect(arena, g_Model_Asset_Names[i], &files[MODEL_ASSET][i], MODEL_ASSET, file);
 	}
 }
 
@@ -402,7 +466,8 @@ void TestAssetPack(Arena *arena)
 
 // ::Packer::Main::Functions::Start::
 
-int main(int argc, c8 **argv)
+int 
+main(int argc, c8 **argv)
 {
 	#ifdef _WIN32
 	{
@@ -415,8 +480,6 @@ int main(int argc, c8 **argv)
 		Assert(pDirNavigate("./build") == 0, "Unable to change to build directory");
 	}
 
-	SetArrayLookups();
-
 	void *mem = pMemAllocZeroed(GB(1));
 	Arena *arena = ArenaInitDebug(mem, GB(1), __LINE__);
 
@@ -433,4 +496,8 @@ int main(int argc, c8 **argv)
 	TestAssetPack(arena);
 }
 
+#endif // BUILD_ASSET_CODEGEN
+
+
+
 // ::Packer::Main::Functions::End::
diff --git a/src/packer.h b/src/packer.h
index 9259b28..0c81613 100644
--- a/src/packer.h
+++ b/src/packer.h
@@ -51,6 +51,7 @@ typedef struct FileMapping
 // ::Packer::Packing::Functions::Header::
 
 void SetArrayLookups();
+void CodeGenAssetLookups(Arena *arena);
 void InitHeader(FileHeader *header);
 i32 WriteHeader(pFile file, FileHeader *header);
 void PackFiles(Arena *arena, FileHeader *header);
diff --git a/src/platform/platform_linux.c b/src/platform/platform_linux.c
index ca6972b..bce55dc 100644
--- a/src/platform/platform_linux.c
+++ b/src/platform/platform_linux.c
@@ -1,41 +1,49 @@
 // ::Platform::Linux::Globals::Start::
 
-static pPlatformWindow linux_window = {
+static pPlatformWindow 
+linux_window = 
+{
 	.w = 1920,
 	.h = 1080,
 };
 
-b32 global_quit = false;
+b32 
+g_Global_Quit = false;
 
 // ::Platform::Linux::Globals::End::
 
 // ::Platform::Linux::Print::Functions::Start::
 
-i32 pWriteStdOut(rawptr buf, i32 len)
+i32 
+pWriteStdOut(rawptr buf, i32 len)
 {
 	return (i32)write(STDOUT, buf, len);
 }
 
-i32 pWriteStdErr(rawptr buf, i32 len)
+i32 
+pWriteStdErr(rawptr buf, i32 len)
 {
 	return (i32)write(STDERR, buf, len);
 }
 
 // ::Platform::Linux::Window::Functions::Start::
 
-void pWindowEventsGet(pGameInput *inputs, u32 *i_count)
+void 
+pWindowEventsGet(pGameInput *inputs, u32 *i_count)
 {
 	pWindowEventHandle(inputs, i_count, false);
 }
 
-b32 pWindowEventWaitFor(pGameInput *input)
+b32 
+pWindowEventWaitFor(pGameInput *input)
 {
 	u32 i_count;
 	pWindowEventHandle(input, &i_count, true);
 	return i_count > 0;
 }
 
-void pWindowEventHandle(pGameInput *inputs, u32 *i_count, b32 wait_for_event)
+void 
+pWindowEventHandle(pGameInput *inputs, u32 *i_count, b32 wait_for_event)
 {
 	b32 has_max_inputs = false;
 	*i_count = 0;
@@ -60,7 +68,7 @@ void pWindowEventHandle(pGameInput *inputs, u32 *i_count, b32 wait_for_event)
 							break;
 
 						if (msg->data.data32[0] == linux_window.close_event)
-							global_quit = true;
+							g_Global_Quit = true;
 					} break;
 				case XCB_CONFIGURE_NOTIFY:
 					{
@@ -145,7 +153,8 @@ void pWindowEventHandle(pGameInput *inputs, u32 *i_count, b32 wait_for_event)
 	} while(!wait_for_event && !has_max_inputs);
 }
 
-pKeyboardInput pInputEventConvert(u32 x_key)
+pKeyboardInput 
+pInputEventConvert(u32 x_key)
 {
 	switch (x_key)
 	{
@@ -287,7 +296,8 @@ pKeyboardInput pInputEventConvert(u32 x_key)
 
 // ::Platform::Linux::Utils::Functions::Start::
 
-b32 pSyscallErrCheck(void *ptr) 
+b32 
+pSyscallErrCheck(void *ptr) 
 {
 	return (isize)ptr == SYS_ERR ? true : false;
 }
@@ -298,7 +308,8 @@ b32 pSyscallErrCheck(void *ptr)
 
 // ::Platform::Linux::Async::Start::
 
-static pThread pThreadInit(rawptr proc, rawptr param)
+static pThread 
+pThreadInit(rawptr proc, rawptr param)
 {
 	pThread thread = {0};
 	Assert(pthread_mutex_init(&thread.mut, NULL) == 0, "pthread_mutex_init failure");
@@ -308,19 +319,22 @@ static pThread pThreadInit(rawptr proc, rawptr param)
 	return thread;
 }
 
-static void pThreadSuspend(pThread *thread)
+static void 
+pThreadSuspend(pThread *thread)
 {
 	pthread_mutex_lock(&thread->mut);
 	pthread_cond_wait(&thread->cond, &thread->mut);
 	pthread_mutex_unlock(&thread->mut);
 }
 
-static void pThreadWake(pThread *thread)
+static void 
+pThreadWake(pThread *thread)
 {
 	pthread_cond_signal(&thread->cond);
 }
 
-static void pThreadKill()
+static void 
+pThreadKill()
 {
 	pthread_exit(NULL);
 }
diff --git a/src/platform/platform_linux_public.c b/src/platform/platform_linux_public.c
index 24c5a5f..41d51cc 100644
--- a/src/platform/platform_linux_public.c
+++ b/src/platform/platform_linux_public.c
@@ -1,6 +1,7 @@
 // ::Platform::Functions::pLibrary::Start::
 
-b32 pLibraryLoad(const char *name, pLibrary *out_lib) 
+b32 
+pLibraryLoad(const char *name, pLibrary *out_lib) 
 {
 	if (!name) {
 		return false;
@@ -14,7 +15,8 @@ b32 pLibraryLoad(const char *name, pLibrary *out_lib)
 	return true;
 }
 
-b32 pFunctionLoad(const char *name, pLibrary *lib, pFunction *out_fn) 
+b32 
+pFunctionLoad(const char *name, pLibrary *lib, pFunction *out_fn) 
 {
 	if (!name) {
 		return false;
@@ -42,7 +44,8 @@ b32 pFunctionLoad(const char *name, pLibrary *lib, pFunction *out_fn)
 
 // ::Platform::Functions::Memory::Start::
 
-rawptr pMemAlloc(usize size) 
+rawptr 
+pMemAlloc(usize size) 
 {
 	rawptr addr = mmap(
 		NULL, 
@@ -58,14 +61,16 @@ rawptr pMemAlloc(usize size)
 	return addr;
 }
 
-rawptr pMemAllocZeroed(usize size)
+rawptr 
+pMemAllocZeroed(usize size)
 {
 	rawptr ptr = pMemAlloc(size);
 	MemZero(ptr, size);
 	return ptr;
 }
 
-rawptr pMemRealloc(rawptr ptr, usize old_size, usize new_size)
+rawptr 
+pMemRealloc(rawptr ptr, usize old_size, usize new_size)
 {
 	rawptr addr = mremap(
 		ptr,
@@ -79,12 +84,14 @@ rawptr pMemRealloc(rawptr ptr, usize old_size, usize new_size)
 	return addr;
 }
 
-void pMemFree(rawptr ptr, usize size)
+void 
+pMemFree(rawptr ptr, usize size)
 {
 	Assert(munmap(ptr, size) == 0, "munmap failed");
 }
 
-usize pPageSize()
+usize 
+pPageSize()
 {
 	return (usize)sysconf(_SC_PAGESIZE);
 }
@@ -95,7 +102,8 @@ usize pPageSize()
 
 // ::Platform::Functions::Window::Start::
 
-b32 pWindowInit(const char *window_name) 
+b32 
+pWindowInit(const char *window_name) 
 {
 	pPlatformWindow *window = &linux_window;
 
@@ -203,7 +211,8 @@ b32 pWindowInit(const char *window_name)
 	return true;
 }
 
-pWindowSize pWindowGetSize()
+pWindowSize 
+pWindowGetSize()
 {
 	return (pWindowSize) {
 		.w = linux_window.w,
@@ -211,12 +220,14 @@ pWindowSize pWindowGetSize()
 	};
 }
 
-pPlatformWindow *pWindowGet() 
+pPlatformWindow 
+*pWindowGet() 
 {
 	return &linux_window;
 }
 
-b32 pWindowShouldQuit()
+b32 
+pWindowShouldQuit()
 {
 	return false;
 }
@@ -227,12 +238,14 @@ b32 pWindowShouldQuit()
 
 // ::Platform::FileSystem::Functions::Start::
 
-b32 pDirNavigate(c8 *dir)
+b32 
+pDirNavigate(c8 *dir)
 {
 	return chdir(dir);
 }
 
-static pFile pFileOpen(c8 *file_name, pFSAccess acc)
+static pFile 
+pFileOpen(c8 *file_name, pFSAccess acc)
 {
 	int flags = 0;
 	if (BitEq(acc, pFS_READ) && BitEq(acc, pFS_WRITE))
@@ -255,30 +268,35 @@ static pFile pFileOpen(c8 *file_name, pFSAccess acc)
 	return open(file_name, flags, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP);
 }
 
-static void pFileClose(pFile file)
+static void 
+pFileClose(pFile file)
 {
 	close(file);
 }
 
 // TODO: make these more resilient
-static u64 pFileRead(pFile file, u64 offset, rawptr buf, u64 len)
+static u64 
+pFileRead(pFile file, u64 offset, rawptr buf, u64 len)
 {
 	lseek(file, (isize)offset, SEEK_SET);
 	return read(file, buf, (usize)len);
 }
 
-static u64 pFileWrite(pFile file, u64 offset, rawptr buf, u64 len)
+static u64 
+pFileWrite(pFile file, u64 offset, rawptr buf, u64 len)
 {
 	lseek(file, (isize)offset, SEEK_SET);
 	return write(file, buf, (usize)len);
 }
 
-static u64 pFileSeek(pFile file, u64 pos)
+static u64 
+pFileSeek(pFile file, u64 pos)
 {
 	return (u64)lseek(file, (isize)pos, SEEK_SET);
 }
 
-static u64 pFileLength(pFile file)
+static u64 
+pFileLength(pFile file)
 {
 	isize offset = lseek(file, 0, SEEK_CUR);
 	isize size = lseek(file, 0, SEEK_END);
@@ -290,7 +308,8 @@ static u64 pFileLength(pFile file)
 	return (u64)size;
 }
 
-c8 **pDirGetFileNames(Arena *arena, u32 *count)
+c8 **
+pDirGetFileNames(Arena *arena, u32 *count)
 {
 	struct dirent *dir;
 
@@ -327,7 +346,8 @@ c8 **pDirGetFileNames(Arena *arena, u32 *count)
 	return (c8 **)file_names;
 }
 
-static b32 pFSIsVisible(c8 *name, b32 is_dir)
+static b32 
+pFSIsVisible(c8 *name, b32 is_dir)
 {
 	b32 found = false;
 
@@ -350,17 +370,20 @@ static b32 pFSIsVisible(c8 *name, b32 is_dir)
 	return found;
 }
 
-static b32 pDirIsVisible(c8 *dir_name)
+static b32 
+pDirIsVisible(c8 *dir_name)
 {
 	return pFSIsVisible(dir_name, true);
 }
 
-static b32 pFileIsVisible(c8 *file_name)
+static b32 
+pFileIsVisible(c8 *file_name)
 {
 	return pFSIsVisible(file_name, false);
 }
 
-static b32 pFileCanAccess(c8 *file_name, pFSAccess file_access)
+static b32 
+pFileCanAccess(c8 *file_name, pFSAccess file_access)
 {
 	int a = 0;
 	if (BitEq(file_access, pFS_READ))
@@ -377,12 +400,14 @@ static b32 pFileCanAccess(c8 *file_name, pFSAccess file_access)
 
 // ::Platform::Profiling::Functions::Start::
 
-static u64 pOSTimerFreq()
+static u64 
+pOSTimerFreq()
 {
 	return 1000000;
 }
 
-static u64 pOSTimerRead()
+static u64 
+pOSTimerRead()
 {
 	struct timeval value;
 	gettimeofday(&value, 0);
@@ -390,7 +415,8 @@ static u64 pOSTimerRead()
 	return pOSTimerFreq() * u64(value.tv_sec) + u64(value.tv_usec);
 }
 
-static inline u64 pCPUTimerRead()
+static inline u64 
+pCPUTimerRead()
 {
 	return __rdtsc();
 }
@@ -401,37 +427,44 @@ static inline u64 pCPUTimerRead()
 
 // ::Platform::Atomics::Functions::Start::
 
-static inline void pAtomicSignalFenceSeqCst()
+static inline void 
+pAtomicSignalFenceSeqCst()
 {
 	__atomic_signal_fence(__ATOMIC_SEQ_CST);
 }
 
-static inline u32 pAtomicFetchSubU32(u32 volatile *ptr, u32 count)
+static inline u32 
+pAtomicFetchSubU32(u32 volatile *ptr, u32 count)
 {
 	return __atomic_fetch_sub(ptr, count, __ATOMIC_ACQUIRE);
 }
 
-static inline u32 pAtomicFetchIncrU32(u32 volatile *ptr)
+static inline u32 
+pAtomicFetchIncrU32(u32 volatile *ptr)
 {
 	return __atomic_fetch_add(ptr, (u32)1, __ATOMIC_ACQUIRE);
 }
 
-static inline void pAtomicIncrU32(u32 volatile *ptr)
+static inline void 
+pAtomicIncrU32(u32 volatile *ptr)
 {
 	__atomic_fetch_add(ptr, (u32)1, __ATOMIC_RELEASE);
 }
 
-static inline u32 pAtomicLoadU32(u32 volatile *ptr)
+static inline u32 
+pAtomicLoadU32(u32 volatile *ptr)
 {
 	return __atomic_load_n(ptr, __ATOMIC_ACQUIRE);
 }
 
-static inline void pAtomicStoreB32(b32 volatile *ptr, b32 value)
+static inline void 
+pAtomicStoreB32(b32 volatile *ptr, b32 value)
 {
 	__atomic_store_n(ptr, value, __ATOMIC_RELEASE);
 }
 
-static inline b32 pAtomicCompareExchangeB32(b32 volatile *ptr, b32 *expected, b32 desired)
+static inline b32 
+pAtomicCompareExchangeB32(b32 volatile *ptr, b32 *expected, b32 desired)
 {
 	return __atomic_compare_exchange_n(ptr, expected, desired, true, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED); 
 }
diff --git a/src/platform/platform_windows.c b/src/platform/platform_windows.c
index 02241c3..af695bd 100644
--- a/src/platform/platform_windows.c
+++ b/src/platform/platform_windows.c
@@ -1,8 +1,16 @@
-HINSTANCE win32_instance = {0};
-pPlatformWindow win32_window = {0};
-b32 global_quit = false;
+// ::Platform::Windows::Globals::Start::
 
-LRESULT CALLBACK WindowProc(HWND window, UINT message, WPARAM w_param, LPARAM l_param)
+HINSTANCE 
+g_Win32_Instance = {0};
+pPlatformWindow 
+g_Win32_Window = {0};
+b32 
+g_Global_Quit = false;
+
+// ::Platform::Windows::Globals::End::
+
+LRESULT CALLBACK 
+WindowProc(HWND window, UINT message, WPARAM w_param, LPARAM l_param)
 {
 	LRESULT result = 0;
 
@@ -11,15 +19,15 @@ LRESULT CALLBACK WindowProc(HWND window, UINT message, WPARAM w_param, LPARAM l_
 		case WM_SIZE: 
 			{
 				Printfln("Window resizing");
-				win32_window.w = LOWORD(l_param);
-				win32_window.h = HIWORD(l_param);
-				rResolutionSet(win32_window.w, win32_window.h);
+				g_Win32_Window.w = LOWORD(l_param);
+				g_Win32_Window.h = HIWORD(l_param);
+				rResolutionSet(g_Win32_Window.w, g_Win32_Window.h);
 			}	break;
 		case WM_DESTROY: // TODO(MA): Probably handle these separately but for now, they're together
 		case WM_CLOSE:
 			{
 				Printf("quitting");
-				global_quit = true;
+				g_Global_Quit = true;
 			} break;
 		case WM_ACTIVATEAPP:
 			{
@@ -34,7 +42,8 @@ LRESULT CALLBACK WindowProc(HWND window, UINT message, WPARAM w_param, LPARAM l_
 	return result;
 }
 
-b32 pLibraryLoad(const char *name, pLibrary *out_lib)
+b32 
+pLibraryLoad(const char *name, pLibrary *out_lib)
 {
 	b32 success = true;
 
@@ -45,7 +54,8 @@ b32 pLibraryLoad(const char *name, pLibrary *out_lib)
 	return success;
 }
 
-b32 pFunctionLoad(const char *name, pLibrary *lib, pFunction *out_fn)
+b32 
+pFunctionLoad(const char *name, pLibrary *lib, pFunction *out_fn)
 {
 	b32 success = true;
 
@@ -56,26 +66,29 @@ b32 pFunctionLoad(const char *name, pLibrary *lib, pFunction *out_fn)
 	return success;
 }
 
-usize pPageSize()
+usize 
+pPageSize()
 {
 	return 0;
 }
 
-i32 _Write(void const *str, DWORD std_handle)
+i32 
+_Write(void const *str, DWORD std_handle)
 {
 	DWORD written;
 	BOOL success = WriteFile(GetStdHandle(std_handle), str, StrLen(str), &written, NULL);
 	return success ? (i32)written : -1;
 }
 
-b32 pWindowInit(const char *window_name)
+b32 
+pWindowInit(const char *window_name)
 {
 	b32 success = true;
 
 	WNDCLASS window_class = {
 		.style = CS_OWNDC|CS_HREDRAW|CS_VREDRAW,
 		.lpfnWndProc = WindowProc,
-		.hInstance = win32_instance,
+		.hInstance = g_Win32_Instance,
 		.lpszClassName = WINDOW_CLASS_NAME,
 	};
 
@@ -96,25 +109,27 @@ b32 pWindowInit(const char *window_name)
 			CW_USEDEFAULT,
 			0,
 			0,
-			win32_instance,
+			g_Win32_Instance,
 			0
 		);
 
 		if (!window_handle)
 			success = false;
 		else
-			win32_window.handle = window_handle;
+			g_Win32_Window.handle = window_handle;
 	}
 
 	return success;
 }
 
-pPlatformWindow *pWindowGet()
+pPlatformWindow *
+pWindowGet()
 {
-	return &win32_window;
+	return &g_Win32_Window;
 }
 
-void pWindowEventsGet()
+void 
+pWindowEventsGet()
 {
 	BOOL has_msg = false;
 	MSG message;
@@ -130,7 +145,8 @@ void pWindowEventsGet()
 	while (has_msg);
 }
 
-void pWindowEventWaitFor()
+void 
+pWindowEventWaitFor()
 {
 	MSG message;
 	BOOL message_result = GetMessageA(&message, 0, 0, 0);
@@ -141,14 +157,16 @@ void pWindowEventWaitFor()
 	}
 }
 
-b32 pWindowShouldQuit()
+b32 
+pWindowShouldQuit()
 {
-	return global_quit;
+	return g_Global_Quit;
 }
 
-pWindowSize pWindowGetSize()
+pWindowSize 
+pWindowGetSize()
 {
-	return (pWindowSize){ .w = win32_window.w, .h = win32_window.h };
+	return (pWindowSize){ .w = g_Win32_Window.w, .h = g_Win32_Window.h };
 }
 
 // ::Platform::Windows::Includes::CFile::
diff --git a/src/platform/platform_windows_public.c b/src/platform/platform_windows_public.c
index 9fc3c4b..eb39145 100644
--- a/src/platform/platform_windows_public.c
+++ b/src/platform/platform_windows_public.c
@@ -1,19 +1,22 @@
 
 // ::Platform::Windows::Memory::Start::
 
-rawptr pMemAlloc(usize size)
+rawptr 
+pMemAlloc(usize size)
 {
 	return (rawptr)VirtualAlloc(0, size, MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
 }
 
-rawptr pMemAllocZeroed(usize size)
+rawptr 
+pMemAllocZeroed(usize size)
 {
 	rawptr mem = pMemAlloc(size);
 	MemZero(mem, size);
 	return mem;
 }
 
-void pMemFree(rawptr ptr, usize size)
+void 
+pMemFree(rawptr ptr, usize size)
 {
 	Assert(VirtualFree(ptr, size, MEM_RELEASE), "pMemFree failure");
 }
@@ -24,12 +27,14 @@ void pMemFree(rawptr ptr, usize size)
 
 // ::Platform::Windows::Print::Start::
 
-i32 pWriteStdOut(rawptr buf, i32 len)
+i32 
+pWriteStdOut(rawptr buf, i32 len)
 {
 	return WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), buf, len, NULL, NULL);
 }
 
-i32 pWriteStdErr(rawptr buf, i32 len)
+i32 
+pWriteStdErr(rawptr buf, i32 len)
 {
 	return WriteConsole(GetStdHandle(STD_ERROR_HANDLE), buf, len, NULL, NULL);
 }
@@ -40,7 +45,8 @@ i32 pWriteStdErr(rawptr buf, i32 len)
 
 // ::Platform::Functions::Directory::Start::
 
-b32 pDirNavigate(c8 *dir)
+b32 
+pDirNavigate(c8 *dir)
 {
 	return !(b32)SetCurrentDirectory(dir);
 }
@@ -51,7 +57,8 @@ b32 pDirNavigate(c8 *dir)
 
 // ::Platform::Windows::Profiling::Functions::Start::
 
-static inline u64 pCPUTimerRead()
+static inline u64 
+pCPUTimerRead()
 {
 	return __rdtsc();
 }
@@ -62,7 +69,8 @@ static inline u64 pCPUTimerRead()
 
 // ::Platform::Windows::Async::Start::
 
-static pThread pThreadInit(rawptr proc, rawptr param)
+static pThread 
+pThreadInit(rawptr proc, rawptr param)
 {
 	pThread thread = {0};
 	CreateThread(NULL, 0, proc, param, 0, NULL);
@@ -70,17 +78,20 @@ static pThread pThreadInit(rawptr proc, rawptr param)
 	return thread;
 }
 
-static void pThreadSuspend(pThread *thread)
+static void 
+pThreadSuspend(pThread *thread)
 {
 	SuspendThread(thread->handle);
 }
 
-static void pThreadWake(pThread *thread)
+static void 
+pThreadWake(pThread *thread)
 {
 	ResumeThread(thread->handle);
 }
 
-static void pThreadKill()
+static void 
+pThreadKill()
 {
 	ExitThread(0);
 }
@@ -92,38 +103,45 @@ static void pThreadKill()
 // ::Platform::Windows::Atomics::Start::
 
 
-static inline void pAtomicSignalFenceSeqCst()
+static inline void 
+pAtomicSignalFenceSeqCst()
 {
 	_ReadWriteBarrier();
 }
 
-static inline u32 pAtomicFetchSubU32(u32 volatile *ptr, u32 count)
+static inline u32 
+pAtomicFetchSubU32(u32 volatile *ptr, u32 count)
 {
 	LONG decrement = (LONG)count;
 	return (u32)InterlockedAddAcquire((LONG volatile *)ptr, -decrement) + decrement; 
 }
 
-static inline u32 pAtomicFetchIncrU32(u32 volatile *ptr)
+static inline u32 
+pAtomicFetchIncrU32(u32 volatile *ptr)
 {
 	return (u32)InterlockedIncrementAcquire((LONG volatile *)ptr) - 1;
 }
 
-static inline void pAtomicIncrU32(u32 volatile *ptr)
+static inline void 
+pAtomicIncrU32(u32 volatile *ptr)
 {
 	InterlockedIncrementRelease((LONG volatile *)ptr);
 }
 
-static inline u32 pAtomicLoadU32(u32 volatile *ptr)
+static inline u32 
+pAtomicLoadU32(u32 volatile *ptr)
 {
 	return (u32)InterlockedOrAcquire((LONG volatile *)ptr, 0);
 }
 
-static inline void pAtomicStoreB32(b32 volatile *ptr, b32 value)
+static inline void 
+pAtomicStoreB32(b32 volatile *ptr, b32 value)
 {
 	_InterlockedExchange_HLERelease((LONG volatile *)ptr, (LONG)value);
 }
 
-static inline b32 pAtomicCompareExchangeB32(b32 volatile *ptr, b32 *expect, b32 desired)
+static inline b32 
+pAtomicCompareExchangeB32(b32 volatile *ptr, b32 *expect, b32 desired)
 {
 	return (b32)InterlockedCompareExchangeAcquire((LONG volatile *)ptr, (LONG)desired, (LONG)*expect);
 }
@@ -134,7 +152,8 @@ static inline b32 pAtomicCompareExchangeB32(b32 volatile *ptr, b32 *expect, b32
 
 // ::Platform::Windows::Files::Start::
 
-static b8 pDirIsVisible(c8 *dir_name)
+static b8 
+pDirIsVisible(c8 *dir_name)
 {
 	WIN32_FIND_DATA find_data;
 	HANDLE handle;
diff --git a/src/renderer_vulkan.c b/src/renderer_vulkan.c
index ae30a72..c2e5407 100644
--- a/src/renderer_vulkan.c
+++ b/src/renderer_vulkan.c
@@ -35,62 +35,74 @@ b32 v_rdoc_captured = false;
 
 // ::Vulkan::Util::Functions::Start::
 
-static inline u32 vFrameIndex()
+static inline u32 
+vFrameIndex()
 {
 	return v_Renderer.state.renderer.frame_count % FRAME_OVERLAP;
 }
 
-static inline u32 vFrameNextIndex()
+static inline u32 
+vFrameNextIndex()
 {
 	return (v_Renderer.state.renderer.frame_count + 1) % FRAME_OVERLAP;
 }
 
-static inline VkCommandBuffer vFrameCmdBuf()
+static inline VkCommandBuffer 
+vFrameCmdBuf()
 {
 	return v_Renderer.frame_handles[vFrameIndex()].buffer;
 }
 
-static inline VkFence vFrameRenderFence()
+static inline VkFence 
+vFrameRenderFence()
 {
 	return v_Renderer.frame_handles[vFrameIndex()].r_fence;
 }
 
-static inline VkImage vFrameImage()
+static inline VkImage 
+vFrameImage()
 {
 	return v_Renderer.images.sc.data[v_Renderer.state.vk.image_idx].image.image;
 }
 
-static inline Arena *vFrameArena()
+static inline Arena *
+vFrameArena()
 {
 	return v_Renderer.mem.frame_arenas[vFrameIndex()];
 }
 
-static inline VkSemaphore vFrameRenderSem()
+static inline VkSemaphore 
+vFrameRenderSem()
 {
 	return v_Renderer.frame_handles[vFrameIndex()].r_sem;
 }
 
-static inline VkSemaphore vFrameSwapSem()
+static inline VkSemaphore 
+vFrameSwapSem()
 {
 	return v_Renderer.frame_handles[vFrameIndex()].sc_sem;
 }
 
-static inline vBufferPtrArray *vFrameBuffers()
+static inline vBufferPtrArray *
+vFrameBuffers()
 {
 	return v_Renderer.buffers.frame_buffers + vFrameIndex();
 }
 
-static inline b8 *vFrameTexDestroyQueue()
+static inline b8 *
+vFrameTexDestroyQueue()
 {
 	return v_Renderer.buffers.tex_destroy_queue.data[vFrameIndex()];
 }
 
-static inline b8 *vFrameNextTexDestroyQueue()
+static inline b8 *
+vFrameNextTexDestroyQueue()
 {
 	return v_Renderer.buffers.tex_destroy_queue.data[vFrameNextIndex()];
 }
 
-static inline void vImageCopyToImage(VkCommandBuffer cmd, VkImage src, VkImage dst, VkExtent2D src_ext, VkExtent2D dst_ext)
+static inline void 
+vImageCopyToImage(VkCommandBuffer cmd, VkImage src, VkImage dst, VkExtent2D src_ext, VkExtent2D dst_ext)
 {
 	VkImageBlit2 blit = {
 		.sType = STYPE(IMAGE_BLIT_2),
@@ -130,7 +142,8 @@ static inline void vImageCopyToImage(VkCommandBuffer cmd, VkImage src, VkImage d
 	vkCmdBlitImage2(cmd, &blit_info);
 }
 
-static inline void vImageTransitionLayout(VkCommandBuffer cmd, VkImage img, VkImageLayout curr, VkImageLayout new)
+static inline void 
+vImageTransitionLayout(VkCommandBuffer cmd, VkImage img, VkImageLayout curr, VkImageLayout new)
 {
 	VkImageMemoryBarrier2 barrier = {
 		.sType = STYPE(IMAGE_MEMORY_BARRIER_2),
@@ -159,7 +172,8 @@ static inline void vImageTransitionLayout(VkCommandBuffer cmd, VkImage img, VkIm
 	vkCmdPipelineBarrier2(cmd, &dep_info);
 }
 
-static inline void vImageTransition(VkCommandBuffer cmd, vImage *img, VkImageLayout new)
+static inline void 
+vImageTransition(VkCommandBuffer cmd, vImage *img, VkImageLayout new)
 {
 	vImageTransitionLayout(cmd, img->image, img->layout, new);
 	img->layout = new;
@@ -171,7 +185,8 @@ static inline void vImageTransition(VkCommandBuffer cmd, vImage *img, VkImageLay
 
 // ::Vulkan::Rendering::Functions::Start::
 
-static void vRenderingBegin()
+static void 
+vRenderingBegin()
 {
 	VkCommandBuffer cmd = vFrameCmdBuf();
 	VkImage curr_img = v_Renderer.images.sc.data[v_Renderer.state.vk.image_idx].image.image;
@@ -223,7 +238,8 @@ static void vRenderingBegin()
 
 // ::Vulkan::ImmediateSubmit::Functions::Start::
 
-static b32 vImmSubmitBegin(VkDevice device, VkFence fence, VkCommandBuffer cmd)
+static b32
+vImmSubmitBegin(VkDevice device, VkFence fence, VkCommandBuffer cmd)
 {
 	b32 success = true;
 
@@ -263,7 +279,8 @@ static b32 vImmSubmitBegin(VkDevice device, VkFence fence, VkCommandBuffer cmd)
 	return success;
 }
 
-static b32 vImmSubmitFinish(VkDevice device, VkFence fence, VkCommandBuffer cmd, VkQueue queue)
+static b32 
+vImmSubmitFinish(VkDevice device, VkFence fence, VkCommandBuffer cmd, VkQueue queue)
 {
 	b32 success = true;
 	VkFence f = fence;
@@ -315,7 +332,8 @@ static b32 vImmSubmitFinish(VkDevice device, VkFence fence, VkCommandBuffer cmd,
 
 // ::Vulkan::Swapchain::Functions::Start::
 
-static void vSwapchainResize()
+static void 
+vSwapchainResize()
 {
 	vkDeviceWaitIdle(v_Renderer.handles.device);
 
@@ -337,14 +355,16 @@ static void vSwapchainResize()
 
 // ::Vulkan::Images::Functions::Start::
 
-static vImageView *vImageViewCreate(TexMeta meta)
+static vImageView *
+vImageViewCreate(TexMeta meta)
 {
 	vImageView *view = FLMemAlloc(sizeof(vImageView));
 	Assert(vImageViewInit(view, meta.w, meta.h, meta.ch), "vImageViewCreate failure: vImage");
 	return view;
 }
 
-static vTransfer *vTextureTransferInit(Arena *arena, u32 asset_id, VkImage image, rawptr bytes, TexMeta *meta)
+static vTransfer *
+vTextureTransferInit(Arena *arena, u32 asset_id, VkImage image, rawptr bytes, TexMeta *meta)
 {
 	vTransfer *transfer = MakeArray(arena, vTransfer, 1);
 
@@ -359,7 +379,8 @@ static vTransfer *vTextureTransferInit(Arena *arena, u32 asset_id, VkImage image
 	return transfer;
 }
 
-static b32 vImageViewInit(vImageView *view, u32 width, u32 height, u32 channels)
+static b32 
+vImageViewInit(vImageView *view, u32 width, u32 height, u32 channels)
 {
 	b32 success = true;
 
@@ -423,7 +444,8 @@ static b32 vImageViewInit(vImageView *view, u32 width, u32 height, u32 channels)
 	return success;
 }
 
-static void vTextureCleanUp()
+static void 
+vTextureCleanUp()
 {
 	VkDevice device = v_Renderer.handles.device;
 	VmaAllocator vma_alloc = v_Renderer.handles.vma_alloc;
@@ -453,17 +475,20 @@ static void vTextureCleanUp()
 	pAtomicSignalFenceSeqCst();
 }
 
-static void vImagePush(TextureAsset asset_id, vImageView *view)
+static void 
+vImagePush(TextureAsset asset_id, vImageView *view)
 {
 	HashTablePushU64Rawptr(&v_Renderer.buffers.images, asset_id, view);
 }
 
-static vImageView *vImagePop(TextureAsset asset_id)
+static vImageView *
+vImagePop(TextureAsset asset_id)
 {
 	return (vImageView *)HashTableDeleteU64Rawptr(&v_Renderer.buffers.images, asset_id);
 }
 
-static vImageView *vImageSearch(TextureAsset asset_id)
+static vImageView *
+vImageSearch(TextureAsset asset_id)
 {
 	vImageView *view = NULL;
 
@@ -485,20 +510,23 @@ static vImageView *vImageSearch(TextureAsset asset_id)
 // ::Vulkan::Descriptors::Functions::Start::
 
 
-static void vDescPushImageAndHandle(rDescHandle handle, vImageView *view)
+static void 
+vDescPushImageAndHandle(rDescHandle handle, vImageView *view)
 {
 	vDescHandlePush(vDT_SAMPLED_IMAGE, handle);
 	vImagePush(handle.asset_id, view);
 }
 
-static void vDescPushModelAndHandle(rDescHandle handle, vModelBuffers *buffer)
+static void 
+vDescPushModelAndHandle(rDescHandle handle, vModelBuffers *buffer)
 {
 	vDescHandlePush(vDT_MESH, handle);
 	vModelPush(handle.asset_id, buffer);
 }
 
 // TODO: batch descriptor writes
-static u32 vDescPushImageDesc(vImageView *view)
+static u32 
+vDescPushImageDesc(vImageView *view)
 {
 	u32 index = vDescIndexPop(vDT_SAMPLED_IMAGE);
 
@@ -522,7 +550,8 @@ static u32 vDescPushImageDesc(vImageView *view)
 	return index;
 }
 
-static u32 vDescPushMeshDesc(vMeshBuffer *buffer)
+static u32 
+vDescPushMeshDesc(vMeshBuffer *buffer)
 {
 	u32 index = vDescIndexPop(vDT_MESH);
 
@@ -547,7 +576,8 @@ static u32 vDescPushMeshDesc(vMeshBuffer *buffer)
 	return index;
 }
 
-static void vDescIndexPush(vDescType type, u32 index)
+static void 
+vDescIndexPush(vDescType type, u32 index)
 {
 	vDescBindings *bindings = v_Renderer.desc_bindings + type;
 
@@ -557,7 +587,8 @@ static void vDescIndexPush(vDescType type, u32 index)
 	bindings->free_count += 1;
 }
 
-static u32 vDescIndexPop(vDescType type)
+static u32 
+vDescIndexPop(vDescType type)
 {
 	vDescBindings *bindings = v_Renderer.desc_bindings + type;
 
@@ -567,7 +598,8 @@ static u32 vDescIndexPop(vDescType type)
 	return bindings->free[bindings->free_count];
 }
 
-static rDescHandle vDescHandleSearch(vDescType type, u32 asset_id)
+static rDescHandle 
+vDescHandleSearch(vDescType type, u32 asset_id)
 {
 	rDescHandle asset_info = {
 		.asset_id = UINT32_MAX,
@@ -585,13 +617,15 @@ static rDescHandle vDescHandleSearch(vDescType type, u32 asset_id)
 	return asset_info;
 }
 
-static void vDescHandlePush(vDescType type, rDescHandle handle)
+static void 
+vDescHandlePush(vDescType type, rDescHandle handle)
 {
 	HashTable *table = &v_Renderer.desc_bindings[type].lookup_table;
 	HashTablePushU64U64Split(table, handle.asset_id, handle.asset_id, handle.desc_index);
 }
 
-static rDescHandle vDescHandlePop(vDescType type, u32 asset_id)
+static rDescHandle 
+vDescHandlePop(vDescType type, u32 asset_id)
 {
 	HashTable *table = &v_Renderer.desc_bindings[type].lookup_table;
 
@@ -606,7 +640,8 @@ static rDescHandle vDescHandlePop(vDescType type, u32 asset_id)
 	return handle;
 }
 
-static void vDescHandleDelete(vDescType type, u32 asset_id)
+static void 
+vDescHandleDelete(vDescType type, u32 asset_id)
 {
 	HashTable *table = &v_Renderer.desc_bindings[type].lookup_table;
 	HashTableDeleteU64(table, asset_id);
@@ -618,7 +653,8 @@ static void vDescHandleDelete(vDescType type, u32 asset_id)
 
 // ::Vulkan::Buffers::Functions::Start::
 
-static vTransfer *vMeshTransferInit(Arena *arena, u32 asset_id, vMeshBuffer *mesh, rawptr bytes, u64 size)
+static vTransfer *
+vMeshTransferInit(Arena *arena, u32 asset_id, vMeshBuffer *mesh, rawptr bytes, u64 size)
 {
 	vTransfer *transfer = MakeArray(arena, vTransfer, 1);
 
@@ -631,7 +667,8 @@ static vTransfer *vMeshTransferInit(Arena *arena, u32 asset_id, vMeshBuffer *mes
 	return transfer;
 }
 
-static vTransfer *vBufferTransferInit(Arena *arena, u32 asset_id, vBuffer *index, rawptr bytes, u64 size)
+static vTransfer *
+vBufferTransferInit(Arena *arena, u32 asset_id, vBuffer *index, rawptr bytes, u64 size)
 {
 	vTransfer *transfer = MakeArray(arena, vTransfer, 1);
 
@@ -644,7 +681,8 @@ static vTransfer *vBufferTransferInit(Arena *arena, u32 asset_id, vBuffer *index
 	return transfer;
 }
 
-static VkResult vBufferCreate(vBuffer* buf, rRenderBufferType type, u64 size)
+static VkResult 
+vBufferCreate(vBuffer* buf, rRenderBufferType type, u64 size)
 {
 	Assert(type != rRBT_NONE, "vBufferCreate: rRenderBufferType must not be rRBT_NONE");
 
@@ -719,24 +757,28 @@ static VkResult vBufferCreate(vBuffer* buf, rRenderBufferType type, u64 size)
 	return result;
 }
 
-static rawptr vMapBuffer(VmaAllocation alloc)
+static rawptr 
+vMapBuffer(VmaAllocation alloc)
 {
 	rawptr ptr;
 	vmaMapMemory(v_Renderer.handles.vma_alloc, alloc, &ptr);
 	return ptr;
 }
 
-static void vModelPush(ModelAsset asset_id, vModelBuffers *buffer)
+static void 
+vModelPush(ModelAsset asset_id, vModelBuffers *buffer)
 {
 	HashTablePushU64Rawptr(&v_Renderer.buffers.buffers, asset_id, buffer);
 }
 
-static vModelBuffers *vModelPop(ModelAsset asset_id)
+static vModelBuffers *
+vModelPop(ModelAsset asset_id)
 {
 	return (vModelBuffers *)HashTableDeleteU64Rawptr(&v_Renderer.buffers.buffers, asset_id);
 }
 
-static vModelBuffers *vModelSearch(ModelAsset asset_id)
+static vModelBuffers *
+vModelSearch(ModelAsset asset_id)
 {
 	vModelBuffers *buffers = NULL;
 	
@@ -755,13 +797,14 @@ static vModelBuffers *vModelSearch(ModelAsset asset_id)
 
 // ::Vulkan::Init::Functions::Start::
 
-static b32 vInitInstance()
+static b32 
+vInitInstance()
 {
 	b32 success = true;
 
 	Assert(vGlobalFunctionsInit(), "Unable to load vulkan functions");
 
-	VkResult result = vkCreateInstance(&inst_info, NULL, &v_Renderer.handles.inst);
+	VkResult result = vkCreateInstance(&g_Instance_Info, NULL, &v_Renderer.handles.inst);
 	if (result != VK_SUCCESS)
 	{
 		success = false;
@@ -771,7 +814,8 @@ static b32 vInitInstance()
 	return success;
 }
 
-static b32 vRenderDocInit()
+static b32 
+vRenderDocInit()
 {
 	pLibrary lib; pFunction fn; int result = 0;
 
@@ -789,11 +833,12 @@ static b32 vRenderDocInit()
 	return result;
 }
 
-static void vEnableDebug()
+static void 
+vEnableDebug()
 {
 		if (vValidationSupported())
 		{
-			Assert(vkCreateDebugUtilsMessengerEXT(v_Renderer.handles.inst, &debug_msg_info, NULL, &v_Renderer.handles.debug) == VK_SUCCESS, 
+			Assert(vkCreateDebugUtilsMessengerEXT(v_Renderer.handles.inst, &g_Debug_Message_Info, NULL, &v_Renderer.handles.debug) == VK_SUCCESS, 
 					"Unable to initialize debug messenger");
 		}
 		else
@@ -802,7 +847,8 @@ static void vEnableDebug()
 		}
 }
 
-static void vArenasInit()
+static void 
+vArenasInit()
 {
 	v_Renderer.mem.perm_arena = ArenaCreateDebug(MB(16), __LINE__);
 
@@ -812,18 +858,19 @@ static void vArenasInit()
 	}
 }
 
-static b32 vVmaAllocatorInit() 
+static b32 
+vVmaAllocatorInit() 
 {
 	VmaVulkanFunctions vk_functions = {
 		.vkGetInstanceProcAddr = vkGetInstanceProcAddr,
 		.vkGetDeviceProcAddr = vkGetDeviceProcAddr,
 	};
-	vma_create_info.pVulkanFunctions = &vk_functions;
-	vma_create_info.physicalDevice = v_Renderer.handles.phys_device;
-	vma_create_info.device = v_Renderer.handles.device;
-	vma_create_info.instance = v_Renderer.handles.inst;
+	g_VMA_Create_Info.pVulkanFunctions = &vk_functions;
+	g_VMA_Create_Info.physicalDevice = v_Renderer.handles.phys_device;
+	g_VMA_Create_Info.device = v_Renderer.handles.device;
+	g_VMA_Create_Info.instance = v_Renderer.handles.inst;
 
-	VkResult result = vmaCreateAllocator(&vma_create_info, &v_Renderer.handles.vma_alloc);
+	VkResult result = vmaCreateAllocator(&g_VMA_Create_Info, &v_Renderer.handles.vma_alloc);
 	if (result != VK_SUCCESS) 
 	{
 		Printf("vmaCreateAllocator failure: %d", result);
@@ -832,14 +879,16 @@ static b32 vVmaAllocatorInit()
 	return result == VK_SUCCESS;
 }
 
-static b32 vQueueCheckSurfaceSupport(i32 index, VkPhysicalDevice device, VkSurfaceKHR surface) 
+static b32 
+vQueueCheckSurfaceSupport(i32 index, VkPhysicalDevice device, VkSurfaceKHR surface) 
 {
 	b32 surface_supported;
 	vkGetPhysicalDeviceSurfaceSupportKHR(device, (u32)index, surface, &surface_supported);
 	return surface_supported;
 }
 
-static vDeviceQueues vQueueCheckSupport(VkPhysicalDevice device, VkSurfaceKHR surface) 
+static vDeviceQueues 
+vQueueCheckSupport(VkPhysicalDevice device, VkSurfaceKHR surface) 
 {
 	vDeviceQueues queues = { .graphics = -1, .transfer = -1 };
 	Arena *arena = vFrameArena();
@@ -901,7 +950,8 @@ static vDeviceQueues vQueueCheckSupport(VkPhysicalDevice device, VkSurfaceKHR su
 	return queues;
 }
 
-static b32 vDeviceCheckPropertiesSupport(VkPhysicalDevice device, VkSurfaceKHR surface, b32 *discrete) 
+static b32 
+vDeviceCheckPropertiesSupport(VkPhysicalDevice device, VkSurfaceKHR surface, b32 *discrete) 
 {
 	b32 success = false;
 	Arena *arena = vFrameArena();
@@ -918,15 +968,15 @@ static b32 vDeviceCheckPropertiesSupport(VkPhysicalDevice device, VkSurfaceKHR s
 
 		i32 matched = 0;
 		for (u32 i = 0; i < ext_count; i++) {
-			for (i32 j = 0; j < Len(device_extensions); j++) {
-				if (StrEq(ext_properties[i].extensionName, device_extensions[j])) {
+			for (i32 j = 0; j < Len(g_Device_Extensions); j++) {
+				if (StrEq(ext_properties[i].extensionName, g_Device_Extensions[j])) {
 					matched++;
 					break;
 				}
 			}
 		}
 
-		if (matched == Len(device_extensions)) 
+		if (matched == Len(g_Device_Extensions)) 
 		{
 			u32 fmt_count, present_count;
 			vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &fmt_count, NULL);
@@ -941,7 +991,8 @@ static b32 vDeviceCheckPropertiesSupport(VkPhysicalDevice device, VkSurfaceKHR s
 	return success;
 }
 
-static b32 vDeviceCheckFeatureSupport(VkPhysicalDevice device) 
+static b32 
+vDeviceCheckFeatureSupport(VkPhysicalDevice device) 
 {
 	VkPhysicalDeviceFeatures2 features2 = { .sType = STYPE(PHYSICAL_DEVICE_FEATURES_2) };
 
@@ -979,7 +1030,8 @@ static b32 vDeviceCheckFeatureSupport(VkPhysicalDevice device)
 	return result;
 }
 
-static b32 vDeviceInit() 
+static b32 
+vDeviceInit() 
 {
 	VkInstance inst = v_Renderer.handles.inst;
 	VkSurfaceKHR surface = v_Renderer.handles.surface;
@@ -1041,10 +1093,10 @@ static b32 vDeviceInit()
 			count++;
 		}
 
-		device_info.queueCreateInfoCount = count;
-		device_info.pQueueCreateInfos = &queue_info[0];
+		g_Device_Info.queueCreateInfoCount = count;
+		g_Device_Info.pQueueCreateInfos = &queue_info[0];
 
-		VkResult result = vkCreateDevice(phys_device, &device_info, NULL, &v_Renderer.handles.device);
+		VkResult result = vkCreateDevice(phys_device, &g_Device_Info, NULL, &v_Renderer.handles.device);
 		if (result != VK_SUCCESS) {
 			Printf("vkCreateDevice failure: %d", result);
 		}
@@ -1079,7 +1131,8 @@ static b32 vDeviceInit()
 	return success;
 }
 
-static b32 vGlobalFunctionsInit() 
+static b32 
+vGlobalFunctionsInit() 
 {
 	b32 result = vLibraryLoad();
 	if (result) 
@@ -1092,7 +1145,8 @@ static b32 vGlobalFunctionsInit()
 	return result;
 }
 
-static b32 vInstanceFunctionsInit() 
+static b32 
+vInstanceFunctionsInit() 
 {
 	VkInstance instance = v_Renderer.handles.inst;
 
@@ -1131,7 +1185,9 @@ static b32 vInstanceFunctionsInit()
 	return true;
 }
 
-static b32 vDeviceFunctionsInit() {
+static b32 
+vDeviceFunctionsInit() 
+{
 	VkDevice device = v_Renderer.handles.device;
 
 	INIT_DEV_FN(vkCreateSwapchainKHR);
@@ -1200,7 +1256,8 @@ static b32 vDeviceFunctionsInit() {
 
 // TODO(MA): implement other platforms
 #ifdef __linux__
-static b32 vSurfaceInit() 
+static b32 
+vSurfaceInit() 
 {
 	pPlatformWindow *window = pWindowGet();
 	VkXcbSurfaceCreateInfoKHR surface_info = {
@@ -1217,7 +1274,8 @@ static b32 vSurfaceInit()
 	return result == VK_SUCCESS;
 }
 #elif _WIN32
-static b32 vSurfaceInit()
+static b32 
+vSurfaceInit()
 {
 	b32 success = true;
 
@@ -1239,7 +1297,8 @@ static b32 vSurfaceInit()
 }
 #endif
 
-static b32 vLibraryLoad() 
+static b32 
+vLibraryLoad() 
 {
 	pLibrary *lib = &v_Renderer.handles.lib;
 	b32 lib_found; pFunction fn;
@@ -1258,12 +1317,13 @@ static b32 vLibraryLoad()
 	return lib_found;
 }
 
-static b32 vFrameStructuresInit()
+static b32 
+vFrameStructuresInit()
 {
 	b32 success           = true;
 	u32 img_count         = v_Renderer.images.sc.length;
 
-	pool_create_info.queueFamilyIndex = v_Renderer.state.vk.gfx_queue_idx;
+	g_Pool_Create_Info.queueFamilyIndex = v_Renderer.state.vk.gfx_queue_idx;
 
 	for (u32 i = 0; i < FRAME_OVERLAP; i++)
 	{
@@ -1271,25 +1331,25 @@ static b32 vFrameStructuresInit()
 		VkDevice device = v_Renderer.handles.device;
 		vFrameHandles *handles = &v_Renderer.frame_handles[i];
 
-		result = vkCreateCommandPool(device, &pool_create_info, NULL, &handles->pool);
+		result = vkCreateCommandPool(device, &g_Pool_Create_Info, NULL, &handles->pool);
 		if (result != VK_SUCCESS)
 			success = false;
 
-		cmd_buf_info.commandPool = handles->pool;
+		g_Command_Buffer_Info.commandPool = handles->pool;
 		
-		result = vkAllocateCommandBuffers(device, &cmd_buf_info, &handles->buffer);
+		result = vkAllocateCommandBuffers(device, &g_Command_Buffer_Info, &handles->buffer);
 		if (result != VK_SUCCESS)
 			success = false;
 
-		result = vkCreateFence(device, &fence_create_info, NULL, &handles->r_fence);
+		result = vkCreateFence(device, &g_Fence_Create_Info, NULL, &handles->r_fence);
 		if (result != VK_SUCCESS)
 			success = false;
 
-		result = vkCreateSemaphore(device, &semaphore_create_info, NULL, &handles->r_sem);
+		result = vkCreateSemaphore(device, &g_Semaphore_Create_info, NULL, &handles->r_sem);
 		if (result != VK_SUCCESS)
 			success = false;
 
-		result = vkCreateSemaphore(device, &semaphore_create_info, NULL, &handles->sc_sem);
+		result = vkCreateSemaphore(device, &g_Semaphore_Create_info, NULL, &handles->sc_sem);
 		if (result != VK_SUCCESS)
 			success = false;
 
@@ -1299,37 +1359,40 @@ static b32 vFrameStructuresInit()
 	return success;
 }
 
-static b32 vImmediateStructuresInit()
+static b32 
+vImmediateStructuresInit()
 {
 	b32 success                       = true;
 	VkResult result;
 	VkDevice device                   = v_Renderer.handles.device;
 	vImmHandles *imm									= &v_Renderer.imm;
-	pool_create_info.queueFamilyIndex = v_Renderer.state.vk.tfer_queue_idx;
+	g_Pool_Create_Info.queueFamilyIndex = v_Renderer.state.vk.tfer_queue_idx;
 
-	result = vkCreateCommandPool(device, &pool_create_info, NULL, &imm->pool);
+	result = vkCreateCommandPool(device, &g_Pool_Create_Info, NULL, &imm->pool);
 	if (result != VK_SUCCESS)
 		success = false;
 
-	cmd_buf_info.commandPool = imm->pool;
+	g_Command_Buffer_Info.commandPool = imm->pool;
 
-	result = vkAllocateCommandBuffers(device, &cmd_buf_info, &imm->buffer);
+	result = vkAllocateCommandBuffers(device, &g_Command_Buffer_Info, &imm->buffer);
 	if (result != VK_SUCCESS)
 		success = false;
 
-	result = vkCreateFence(device, &fence_create_info, NULL, &imm->fence);
+	result = vkCreateFence(device, &g_Fence_Create_Info, NULL, &imm->fence);
 	if (result != VK_SUCCESS)
 		success = false;
 
 	return success;
 }
 
-static void vUploadQueuesInit()
+static void 
+vUploadQueuesInit()
 {
 	v_Renderer.upload.transfers = MakeArray(v_Renderer.mem.perm_arena, vTransfer *, 256);
 }
 
-static b32 vSwapchainInit()
+static b32 
+vSwapchainInit()
 {
 	b32 success = true;
 	VkPhysicalDevice phys_device = v_Renderer.handles.phys_device;
@@ -1380,16 +1443,16 @@ static b32 vSwapchainInit()
 			present_mode = VK_PRESENT_MODE_FIFO_KHR;
 	}
 
-	swapchain_create_info.minImageCount = capabilities.minImageCount + 1;
-	swapchain_create_info.surface = surface;
-	swapchain_create_info.imageFormat = format;
-	swapchain_create_info.imageColorSpace = color_space;
-	swapchain_create_info.imageExtent = extent;
-	swapchain_create_info.preTransform = capabilities.currentTransform;
-	swapchain_create_info.presentMode = present_mode;
+	g_Swap_Info.minImageCount = capabilities.minImageCount + 1;
+	g_Swap_Info.surface = surface;
+	g_Swap_Info.imageFormat = format;
+	g_Swap_Info.imageColorSpace = color_space;
+	g_Swap_Info.imageExtent = extent;
+	g_Swap_Info.preTransform = capabilities.currentTransform;
+	g_Swap_Info.presentMode = present_mode;
 
 	VkResult result;
-	result = vkCreateSwapchainKHR(device, &swapchain_create_info, NULL, &v_Renderer.handles.swapchain);
+	result = vkCreateSwapchainKHR(device, &g_Swap_Info, NULL, &v_Renderer.handles.swapchain);
 	if (result != VK_SUCCESS)
 		success = false;
 
@@ -1404,10 +1467,10 @@ static b32 vSwapchainInit()
 	for (u32 i = 0; i < image_count; i++)
 	{
 		v_Renderer.images.sc.data[i].image.image = sc_images[i];
-		sc_image_view_create_info.image = sc_images[i];
-		sc_image_view_create_info.format = format;
+		g_Swap_View_Info.image = sc_images[i];
+		g_Swap_View_Info.format = format;
 
-		result = vkCreateImageView(device, &sc_image_view_create_info, NULL, &v_Renderer.images.sc.data[i].view);
+		result = vkCreateImageView(device, &g_Swap_View_Info, NULL, &v_Renderer.images.sc.data[i].view);
 		if (result != VK_SUCCESS)
 			success = false;
 	}
@@ -1424,7 +1487,8 @@ static b32 vSwapchainInit()
 	return success;
 }
 
-static b32 vDrawImagesInit()
+static b32 
+vDrawImagesInit()
 {
 	b32 success = true;
 	VkResult result;
@@ -1439,47 +1503,48 @@ static b32 vDrawImagesInit()
 	};
 
 	// Draw vImage
-	draw_image_create_info.format = image_format;
-	draw_image_create_info.extent = extent;
+	g_Draw_Image_Info.format = image_format;
+	g_Draw_Image_Info.extent = extent;
 
-	result = vmaCreateImage(v_Renderer.handles.vma_alloc, &draw_image_create_info, 
+	result = vmaCreateImage(v_Renderer.handles.vma_alloc, &g_Draw_Image_Info, 
 												 &alloc_create_info, &v_Renderer.images.draw.image.image, &v_Renderer.images.draw.image.alloc, NULL);
 	if (result != VK_SUCCESS)
 		success = false;
 
 	// Draw vImage View
-	draw_image_view_create_info.image = v_Renderer.images.draw.image.image;
-	draw_image_view_create_info.format = image_format;
+	g_Draw_View_Info.image = v_Renderer.images.draw.image.image;
+	g_Draw_View_Info.format = image_format;
 
-	result = vkCreateImageView(device, &draw_image_view_create_info, NULL, &v_Renderer.images.draw.view);
+	result = vkCreateImageView(device, &g_Draw_View_Info, NULL, &v_Renderer.images.draw.view);
 	if (result != VK_SUCCESS)
 		success = false;
 
 	// Depth vImage
-	depth_image_create_info.extent = extent;
+	g_Depth_Image_Info.extent = extent;
 
-	result = vmaCreateImage(v_Renderer.handles.vma_alloc, &depth_image_create_info, 
+	result = vmaCreateImage(v_Renderer.handles.vma_alloc, &g_Depth_Image_Info, 
 												 &alloc_create_info, &v_Renderer.images.depth.image.image, &v_Renderer.images.depth.image.alloc, NULL);
 	if (result != VK_SUCCESS)
 		success = false;
 
 	// Depth vImage View
-	depth_image_view_create_info.image = v_Renderer.images.depth.image.image;
-	result = vkCreateImageView(device, &depth_image_view_create_info, NULL, &v_Renderer.images.depth.view);
+	g_Depth_View_Info.image = v_Renderer.images.depth.image.image;
+	result = vkCreateImageView(device, &g_Depth_View_Info, NULL, &v_Renderer.images.depth.view);
 	if (result != VK_SUCCESS)
 		success = false;
 	
 	// Setting values
 	v_Renderer.state.swapchain.extent = extent;
-	v_Renderer.images.depth.image.format = depth_image_create_info.format;
+	v_Renderer.images.depth.image.format = g_Depth_Image_Info.format;
 	v_Renderer.images.depth.image.layout = VK_IMAGE_LAYOUT_UNDEFINED;
-	v_Renderer.images.draw.image.format = draw_image_create_info.format;
+	v_Renderer.images.draw.image.format = g_Draw_Image_Info.format;
 	v_Renderer.images.draw.image.layout = VK_IMAGE_LAYOUT_UNDEFINED;
 
 	return success;
 }
 
-static VkFormat vImageFormatGet()
+static VkFormat 
+vImageFormatGet()
 {
 	VkPhysicalDevice phys_device = v_Renderer.handles.phys_device;
 	VkImageType image_type = VK_IMAGE_TYPE_2D;
@@ -1511,7 +1576,8 @@ static VkFormat vImageFormatGet()
 	return format;
 }
 
-static b32 vDescriptorsInit()
+static b32 
+vDescriptorsInit()
 {
 	b32 success = true;
 
@@ -1519,33 +1585,33 @@ static b32 vDescriptorsInit()
 	VkResult result;
 	vDescBindings *bindings = v_Renderer.desc_bindings;
 
-	result = vkCreateDescriptorPool(device, &desc_pool_info, NULL, &v_Renderer.handles.desc_pool);
+	result = vkCreateDescriptorPool(device, &g_Desc_Pool_Info, NULL, &v_Renderer.handles.desc_pool);
 	if (result != VK_SUCCESS)
 		success = false;
 
-	result = vkCreateDescriptorSetLayout(device, &shared_layout_create_info, NULL, &v_Renderer.handles.desc_layouts[vDT_SHARED]);
+	result = vkCreateDescriptorSetLayout(device, &g_Shared_Desc_Layout_Info, NULL, &v_Renderer.handles.desc_layouts[vDT_SHARED]);
 	if (result != VK_SUCCESS)
 		success = false;
 
 	for (u32 i = vDT_SAMPLED_IMAGE; i < vDT_MAX; i++)
 	{
-		bindless_layout_binding.descriptorType = desc_type_map[i];
-		result = vkCreateDescriptorSetLayout(device, &bindless_layout_create_info, NULL, &v_Renderer.handles.desc_layouts[i]);
+		g_Bindless_Desc_Binding.descriptorType = g_Desc_Type_Map[i];
+		result = vkCreateDescriptorSetLayout(device, &g_Bindless_Desc_Info, NULL, &v_Renderer.handles.desc_layouts[i]);
 		if (result != VK_SUCCESS)
 			success = false;
 	}
 
-	set_allocate_info.descriptorPool = v_Renderer.handles.desc_pool;
-	set_allocate_info.pSetLayouts = v_Renderer.handles.desc_layouts;
+	g_Descriptor_Alloc_Info.descriptorPool = v_Renderer.handles.desc_pool;
+	g_Descriptor_Alloc_Info.pSetLayouts = v_Renderer.handles.desc_layouts;
 
-	result = vkAllocateDescriptorSets(device, &set_allocate_info, v_Renderer.handles.desc_sets);
+	result = vkAllocateDescriptorSets(device, &g_Descriptor_Alloc_Info, v_Renderer.handles.desc_sets);
 	if (result != VK_SUCCESS)
 		success = false;
 
-	pipeline_layout_create_info.setLayoutCount = vDT_MAX;
-	pipeline_layout_create_info.pSetLayouts = v_Renderer.handles.desc_layouts;
+	g_Pipeline_Layout_Info.setLayoutCount = vDT_MAX;
+	g_Pipeline_Layout_Info.pSetLayouts = v_Renderer.handles.desc_layouts;
 
-	result = vkCreatePipelineLayout(device, &pipeline_layout_create_info, NULL, &v_Renderer.handles.pipeline_layout);
+	result = vkCreatePipelineLayout(device, &g_Pipeline_Layout_Info, NULL, &v_Renderer.handles.pipeline_layout);
 	if (result != VK_SUCCESS)
 		success = false;
 
@@ -1616,7 +1682,8 @@ static b32 vDescriptorsInit()
 	return success;
 }
 
-static b32 vPipelinesInit()
+static b32 
+vPipelinesInit()
 {
 	b32 success = true;
 	VkResult result;
@@ -1637,8 +1704,8 @@ static b32 vPipelinesInit()
 	 *	QUAD PIPELINE START 
 	 */
 
-	Asset quad_vert_shader = apLoadShader(QUAD_VERT_SPIRV_SHADER);
-	Asset quad_frag_shader = apLoadShader(QUAD_FRAG_SPIRV_SHADER);
+	Asset quad_vert_shader = apLoad("shaders/quad.vert");
+	Asset quad_frag_shader = apLoad("shaders/quad.frag");
 
 	VkShaderModule cube_vert, cube_frag;
 	success &= vShaderModuleInit(quad_vert_shader.bytes, quad_vert_shader.len, &cube_vert);
@@ -1659,12 +1726,12 @@ static b32 vPipelinesInit()
 		},
 	};
 
-	cube_create_info.pStages = cube_shader_stages;
-	cube_create_info.stageCount = Len(cube_shader_stages);
-	cube_create_info.layout = v_Renderer.handles.pipeline_layout;
-	cube_create_info.pNext = &pipeline_render_info;
+	g_CUBE_Create_Info.pStages = cube_shader_stages;
+	g_CUBE_Create_Info.stageCount = Len(cube_shader_stages);
+	g_CUBE_Create_Info.layout = v_Renderer.handles.pipeline_layout;
+	g_CUBE_Create_Info.pNext = &pipeline_render_info;
 
-	result = vkCreateGraphicsPipelines(device, 0, 1, &cube_create_info, NULL, &v_Renderer.handles.pipelines[rPIPELINE_CUBE]);
+	result = vkCreateGraphicsPipelines(device, 0, 1, &g_CUBE_Create_Info, NULL, &v_Renderer.handles.pipelines[rPIPELINE_CUBE]);
 	if (result != VK_SUCCESS)
 	{
 		Printf("vkCreateGraphicsPipelines failure: %s", vVkResultStr(result));
@@ -1674,15 +1741,15 @@ static b32 vPipelinesInit()
 	vkDestroyShaderModule(device, cube_vert, NULL);
 	vkDestroyShaderModule(device, cube_frag, NULL);
 
-	apUnloadShader(QUAD_VERT_SPIRV_SHADER);
-	apUnloadShader(QUAD_FRAG_SPIRV_SHADER);
+	apUnload("shaders/quad.vert");
+	apUnload("shaders/quad.frag");
 
 	/*
 	 *	GUI PIPELINE START 
 	 */
 
-	Asset gui_vert_shader = apLoadShader(GUI_VERT_SPIRV_SHADER);
-	Asset gui_frag_shader = apLoadShader(GUI_FRAG_SPIRV_SHADER);
+	Asset gui_vert_shader = apLoad("shaders/gui.vert");
+	Asset gui_frag_shader = apLoad("shaders/gui.frag");
 
 	VkShaderModule gui_vert, gui_frag;
 	success &= vShaderModuleInit(gui_vert_shader.bytes, gui_vert_shader.len, &gui_vert);
@@ -1703,12 +1770,12 @@ static b32 vPipelinesInit()
 		},
 	};
 
-	gui_create_info.pStages = gui_shader_stages;
-	gui_create_info.stageCount = Len(gui_shader_stages);
-	gui_create_info.layout = v_Renderer.handles.pipeline_layout;
-	gui_create_info.pNext = &pipeline_render_info;
+	g_GUI_Create_Info.pStages = gui_shader_stages;
+	g_GUI_Create_Info.stageCount = Len(gui_shader_stages);
+	g_GUI_Create_Info.layout = v_Renderer.handles.pipeline_layout;
+	g_GUI_Create_Info.pNext = &pipeline_render_info;
 
-	result = vkCreateGraphicsPipelines(device, 0, 1, &gui_create_info, NULL, &v_Renderer.handles.pipelines[rPIPELINE_GUI]);
+	result = vkCreateGraphicsPipelines(device, 0, 1, &g_GUI_Create_Info, NULL, &v_Renderer.handles.pipelines[rPIPELINE_GUI]);
 	if (result != VK_SUCCESS)
 	{
 		Printfln("vkCreateGraphicsPipelines failure: %s", vVkResultStr(result));
@@ -1718,15 +1785,15 @@ static b32 vPipelinesInit()
 	vkDestroyShaderModule(device, gui_vert, NULL);
 	vkDestroyShaderModule(device, gui_frag, NULL);
 
-	apUnloadShader(GUI_VERT_SPIRV_SHADER);
-	apUnloadShader(GUI_FRAG_SPIRV_SHADER);
+	apUnload("shaders/gui.vert");
+	apUnload("shaders/gui.frag");
 
 	/*
 	 *	PBR PIPELINE START 
 	 */
 
-	Asset pbr_vert_shader = apLoadShader(PBR_VERT_SPIRV_SHADER);
-	Asset pbr_frag_shader = apLoadShader(PBR_FRAG_SPIRV_SHADER);
+	Asset pbr_vert_shader = apLoad("shaders/pbr.vert");
+	Asset pbr_frag_shader = apLoad("shaders/pbr.frag");
 
 	VkShaderModule pbr_vert, pbr_frag;
 	success &= vShaderModuleInit(pbr_vert_shader.bytes, pbr_vert_shader.len, &pbr_vert);
@@ -1747,12 +1814,12 @@ static b32 vPipelinesInit()
 		},
 	};
 
-	pbr_create_info.pStages = pbr_shader_stages;
-	pbr_create_info.stageCount = Len(pbr_shader_stages);
-	pbr_create_info.layout = v_Renderer.handles.pipeline_layout;
-	pbr_create_info.pNext = &pipeline_render_info;
+	g_PBR_Create_Info.pStages = pbr_shader_stages;
+	g_PBR_Create_Info.stageCount = Len(pbr_shader_stages);
+	g_PBR_Create_Info.layout = v_Renderer.handles.pipeline_layout;
+	g_PBR_Create_Info.pNext = &pipeline_render_info;
 
-	result = vkCreateGraphicsPipelines(device, 0, 1, &pbr_create_info, NULL, &v_Renderer.handles.pipelines[rPIPELINE_PBR]);
+	result = vkCreateGraphicsPipelines(device, 0, 1, &g_PBR_Create_Info, NULL, &v_Renderer.handles.pipelines[rPIPELINE_PBR]);
 	if (result != VK_SUCCESS)
 	{
 		Printfln("vkCreateGraphicsPipelineFailure: %s", vVkResultStr(result));
@@ -1762,13 +1829,14 @@ static b32 vPipelinesInit()
 	vkDestroyShaderModule(device, pbr_vert, NULL);
 	vkDestroyShaderModule(device, pbr_frag, NULL);
 
-	apUnloadShader(PBR_VERT_SPIRV_SHADER);
-	apUnloadShader(PBR_FRAG_SPIRV_SHADER);
+	apUnload("shaders/pbr.vert");
+	apUnload("shaders/pbr.frag");
 
 	return success;
 }
 
-static b32 vShaderModuleInit(u8 *bytes, u32 len, VkShaderModule *module)
+static b32 
+vShaderModuleInit(u8 *bytes, u32 len, VkShaderModule *module)
 {
 	VkResult result;
 	b32 success = true;
@@ -1789,7 +1857,8 @@ static b32 vShaderModuleInit(u8 *bytes, u32 len, VkShaderModule *module)
 	return success;
 }
 
-static b32 vBuffersInit()
+static b32 
+vBuffersInit()
 {
 	vRBuffers *buf = &v_Renderer.buffers;
 	Arena *arena = v_Renderer.mem.perm_arena;
@@ -1844,7 +1913,8 @@ static b32 vBuffersInit()
 	return success;
 }
 
-static void vLoaderStartThreads()
+static void 
+vLoaderStartThreads()
 {
 	v_Renderer.async.thread = pThreadInit(vLoaderStart, NULL);
 }
@@ -1855,7 +1925,8 @@ static void vLoaderStartThreads()
 
 // ::Vulkan::Async::Functions::Start::
 
-static void vTransferUpload(vTransfer **transfers, u32 count)
+static void 
+vTransferUpload(vTransfer **transfers, u32 count)
 {
 	VkCommandPool pool = v_Renderer.imm.pool;
 	VkCommandBuffer buffer = v_Renderer.imm.buffer;
@@ -2029,7 +2100,8 @@ static void vTransferUpload(vTransfer **transfers, u32 count)
 
 #ifdef __linux__
 
-void *vLoaderStart(void *i)
+void *
+vLoaderStart(void *i)
 {
 	vLoader();
 	pthread_exit(NULL);
@@ -2037,7 +2109,8 @@ void *vLoaderStart(void *i)
 
 #elif _WIN32
 
-DWORD WINAPI vLoaderStart(LPVOID thread_data)
+DWORD WINAPI 
+vLoaderStart(LPVOID thread_data)
 {
 	vLoader();
 	return 0;
@@ -2045,12 +2118,14 @@ DWORD WINAPI vLoaderStart(LPVOID thread_data)
 
 #endif
 
-static void vLoaderWake()
+static void 
+vLoaderWake()
 {
 	pThreadWake(&v_Renderer.async.thread);
 }
 
-static void vLoader()
+static void 
+vLoader()
 {
 	pThread *self = &v_Renderer.async.thread;
 
@@ -2078,7 +2153,8 @@ static void vLoader()
 			for (u32 i = 0; i < job_count; i++)
 			{
 				if (transfers[i]->type == vTT_IMAGE)
-					apUnloadTexture(transfers[i]->asset_id);
+					//apUnloadTexture(transfers[i]->asset_id);
+					;
 			}
 
 			JobQueueMarkCompleted(&v_Renderer.upload.job_queue, job_count);
@@ -2106,7 +2182,8 @@ static void vLoader()
 
 // ::Vulkan::CleanUp::Functions::Start::
 
-static void vSwapchainDestroy()
+static void 
+vSwapchainDestroy()
 {
 	vImageViewArray images = v_Renderer.images.sc;
 	VkDevice device = v_Renderer.handles.device;
@@ -2120,7 +2197,8 @@ static void vSwapchainDestroy()
 	vkDestroySwapchainKHR(device, swapchain, NULL);
 }
 
-static void vDrawImagesDestroy()
+static void 
+vDrawImagesDestroy()
 {
 	vRImages *images = &v_Renderer.images;
 	VkDevice device = v_Renderer.handles.device;
@@ -2139,17 +2217,20 @@ static void vDrawImagesDestroy()
 
 // ::Vulkan::Logging::Functions::Start::
 
-void vInfo(const char *str)
+void 
+vInfo(const char *str)
 {
 	Printfln("[INFO] %s", str);
 }
 
-void vWarn(const char *str)
+void 
+vWarn(const char *str)
 {
 	Printfln("[WARN] %s", str);
 }
 
-void vError(const char *str)
+void 
+vError(const char *str)
 {
 	Printfln("[ERROR] %s", str);
 }
@@ -2160,7 +2241,8 @@ void vError(const char *str)
 
 // ::Vulkan::Debug::Functions::Start::
 
-const char *vVkResultStr(VkResult result) 
+const char *
+vVkResultStr(VkResult result) 
 { 
 	switch (result) 
 	{ 
@@ -2273,12 +2355,14 @@ const char *vVkResultStr(VkResult result)
 	} 
 }
 
-static VKAPI_ATTR VkBool32 vDebugCallback(
+static VKAPI_ATTR VkBool32 
+vDebugCallback(
 	VkDebugUtilsMessageSeverityFlagBitsEXT			message_severity,
 	VkDebugUtilsMessageTypeFlagsEXT							message_type,
 	const VkDebugUtilsMessengerCallbackDataEXT	*pCallbackData,
 	void																				*pUserData
-) {
+) 
+{
 	char *ms, *mt;
 
 	switch (message_severity) {
@@ -2331,7 +2415,8 @@ static VKAPI_ATTR VkBool32 vDebugCallback(
 	return VK_FALSE;
 }
 
-static b32 vValidationSupported() 
+static b32 
+vValidationSupported() 
 {
 	b32 success = false;
 	Arena *arena = vFrameArena();
diff --git a/src/renderer_vulkan.h b/src/renderer_vulkan.h
index 1c5f3d6..b8f8e02 100644
--- a/src/renderer_vulkan.h
+++ b/src/renderer_vulkan.h
@@ -38,9 +38,9 @@ static char *vulkan_libs[] = {
 
 #endif
 
-#define VERTEX_BUFFER_CAP MB(32)
-#define INDEX_BUFFER_CAP MB(8)
-#define TRANSFER_BUFFER_CAP MB(64)
+constexpr u64 VERTEX_BUFFER_CAP 	= MB(32);
+constexpr u64 INDEX_BUFFER_CAP 		= MB(8);
+constexpr u64 TRANSFER_BUFFER_CAP = MB(64);
 
 // ::Vulkan::Macros::Header::
 
@@ -578,9 +578,9 @@ static vTransfer *vMeshTransferInit(Arena *arena, u32 asset_id, vMeshBuffer *mes
 static vTransfer *vBufferTransferInit(Arena *arena, u32 asset_id, vBuffer *index, rawptr bytes, u64 size);
 static VkResult vBufferCreate(vBuffer* buf, rRenderBufferType type, u64 size);
 static rawptr vMapBuffer(VmaAllocation alloc);
-static void vModelPush(ModelAsset asset_id, vModelBuffers *buffer);
-static vModelBuffers *vModelPop(ModelAsset asset_id);
-static vModelBuffers *vModelSearch(ModelAsset asset_id);
+static void vModelPush(c8 *name, vModelBuffers *buffer);
+static vModelBuffers *vModelPop(c8 *name);
+static vModelBuffers *vModelSearch(c8 *name);
 
 // ::Vulkan::CleanUp::Functions::Header::
 
diff --git a/src/renderer_vulkan_public.c b/src/renderer_vulkan_public.c
index 626e006..1029b76 100644
--- a/src/renderer_vulkan_public.c
+++ b/src/renderer_vulkan_public.c
@@ -1,6 +1,7 @@
 // ::Vulkan::Renderer::Initialization::Functions::Start::
 
-b32 rInit() 
+b32 
+rInit() 
 {
 	vArenasInit();
 	vCustomizePipelines();
@@ -34,7 +35,8 @@ b32 rInit()
 	return true;
 }
 
-void rDestroy()
+void 
+rDestroy()
 {
 	VkDevice device 										= v_Renderer.handles.device;
 	VkInstance instance 								= v_Renderer.handles.inst;
@@ -119,7 +121,8 @@ void rDestroy()
 
 // ::Vulkan::Renderer::Buffers::Functions::Start::
 
-static rDescHandle rTextureLoad(TextureAsset asset_id)
+static rDescHandle 
+rTextureLoad(TextureAsset asset_id)
 {
 	rDescHandle handle = vDescHandleSearch(vDT_SAMPLED_IMAGE, asset_id);
 
@@ -152,7 +155,8 @@ static rDescHandle rTextureLoad(TextureAsset asset_id)
 	return handle;
 }
 
-static rDescHandle rMeshLoad(ModelAsset asset_id)
+static rDescHandle 
+rMeshLoad(ModelAsset asset_id)
 {
 	rDescHandle handle = vDescHandleSearch(vDT_MESH, asset_id); 
 
@@ -193,7 +197,8 @@ static rDescHandle rMeshLoad(ModelAsset asset_id)
 	return handle;
 }
 
-static void rTextureUnload(rDescHandle current_handle)
+static void 
+rTextureUnload(rDescHandle current_handle)
 {
 	rDescHandle handle = vDescHandleSearch(vDT_SAMPLED_IMAGE, current_handle.asset_id);
 
@@ -205,7 +210,8 @@ static void rTextureUnload(rDescHandle current_handle)
 	}
 }
 
-static void rBufferBindVertex(rRenderBuffer *buffer)
+static void 
+rBufferBindVertex(rRenderBuffer *buffer)
 {
 	Assert(buffer && buffer->type == rRBT_VERTEX, "rBufferBindVertex: invalid buffer provided");
 
@@ -215,7 +221,8 @@ static void rBufferBindVertex(rRenderBuffer *buffer)
 	vkCmdBindVertexBuffers(cmd, 0, 1, &buffer->buffer, &offsets);
 }
 
-static void rBufferBindIndex(rRenderBuffer *buffer)
+static void 
+rBufferBindIndex(rRenderBuffer *buffer)
 {
 	Assert(buffer && buffer->type == rRBT_INDEX, "rBufferBindIndex: invalid buffer provided");
 
@@ -224,7 +231,8 @@ static void rBufferBindIndex(rRenderBuffer *buffer)
 	vkCmdBindIndexBuffer(cmd, buffer->buffer, 0, VK_INDEX_TYPE_UINT32);
 }
 
-static void vBufferQueueWait()
+static void 
+vBufferQueueWait()
 {
 	while (!JobQueueCompleted(&v_Renderer.upload.job_queue))
 	{
@@ -233,17 +241,20 @@ static void vBufferQueueWait()
 	}
 }
 
-static rawptr rBufferGUIVertMapping()
+static rawptr 
+rBufferGUIVertMapping()
 {
 	return v_Renderer.buffers.gui_vert.ptr;
 }
 
-static rawptr rBufferGUIIdxMapping()
+static rawptr 
+rBufferGUIIdxMapping()
 {
 	return v_Renderer.buffers.gui_idx.ptr;
 }
 
-static void rBufferBindGUIVertex()
+static void 
+rBufferBindGUIVertex()
 {
 	VkCommandBuffer cmd = vFrameCmdBuf();
 	VkDeviceSize offsets = 0;
@@ -252,7 +263,8 @@ static void rBufferBindGUIVertex()
 	vkCmdBindVertexBuffers(cmd, 0, 1, &buffer, &offsets);
 }
 
-static void rBufferBindGUIIndex()
+static void 
+rBufferBindGUIIndex()
 {
 	VkCommandBuffer cmd = vFrameCmdBuf();
 	VkBuffer buffer = v_Renderer.buffers.gui_idx.alloc.buffer;
@@ -260,12 +272,12 @@ static void rBufferBindGUIIndex()
 	vkCmdBindIndexBuffer(cmd, buffer, 0, VK_INDEX_TYPE_UINT32);
 }
 
-static void rBufferBindMesh(rPushConst *pc, rDescHandle handle)
+static void 
+rBufferBindMesh(rPushConst *pc, rDescHandle handle)
 {
 	vModelBuffers *buffers = vModelSearch(handle.asset_id);
 	if (buffers != NULL)
 	{
-		Printfln("binding index buffer");
 		vkCmdBindIndexBuffer(vFrameCmdBuf(), buffers->index->buffer, 0, VK_INDEX_TYPE_UINT32);
 	}
 }
@@ -277,18 +289,21 @@ static void rBufferBindMesh(rPushConst *pc, rDescHandle handle)
 // ::Vulkan::Renderer::Uniforms::Functions::Start:: 
 // ::Vulkan::Renderer::PushConstants::Functions::Start::
 
-static void rViewportSize(Vec2 *size)
+static void 
+rViewportSize(Vec2 *size)
 {
 	size->x = (f32)v_Renderer.state.swapchain.extent.width;
 	size->y = (f32)v_Renderer.state.swapchain.extent.height;
 }
 
-static void rGlobalUniformSet(rShaderGlobals *globals)
+static void 
+rGlobalUniformSet(rShaderGlobals *globals)
 {
 	
 }
 
-static void rPushConstantsSet(rPushConst *pc)
+static void 
+rPushConstantsSet(rPushConst *pc)
 {
 	VkCommandBuffer cmd = vFrameCmdBuf();
 
@@ -307,7 +322,8 @@ static void rPushConstantsSet(rPushConst *pc)
 
 // ::Vulkan::Renderer::Config::Functions::Start::
 
-static void rResolutionSet(u32 x, u32 y)
+static void 
+rResolutionSet(u32 x, u32 y)
 {
 	v_Renderer.state.renderer.width = x;
 	v_Renderer.state.renderer.height = y;
@@ -319,7 +335,8 @@ static void rResolutionSet(u32 x, u32 y)
 
 // ::Vulkan::Renderer::Rendering::Functions::Start::
 
-b32 rFrameBegin()
+b32 
+rFrameBegin()
 {
 	b32 success = true;
 	VkResult result;
@@ -399,7 +416,8 @@ b32 rFrameBegin()
 	return success;
 }
 
-b32 rFrameFinish()
+b32 
+rFrameFinish()
 {
 	b32 success = true;
 	VkResult result;
@@ -502,14 +520,16 @@ b32 rFrameFinish()
 	return success;
 }
 
-static void rDrawIndexed(u32 index_count, u32 instance_count)
+static void 
+rDrawIndexed(u32 index_count, u32 instance_count)
 {
 	VkCommandBuffer cmd = vFrameCmdBuf();
 
 	vkCmdDrawIndexed(cmd, index_count, instance_count, 0, 0, 0);
 }
 
-static void rPipelineBind(rPipelineHandle handle, rPipelineType type)
+static void 
+rPipelineBind(rPipelineHandle handle, rPipelineType type)
 {
 	VkCommandBuffer cmd = vFrameCmdBuf();
 
diff --git a/src/shared_types.h b/src/shared_types.h
index e64985d..7c8fb93 100644
--- a/src/shared_types.h
+++ b/src/shared_types.h
@@ -50,7 +50,7 @@ typedef void * rawptr;
 
 typedef struct String8
 {
-	u8  *value;
+	c8  *value;
 	u64 len;
 } String8;
 
diff --git a/src/tests.c b/src/tests.c
index 20582d7..a66f11c 100644
--- a/src/tests.c
+++ b/src/tests.c
@@ -1,12 +1,14 @@
 // TODO: Make the tests actually decent
 
-void RunTests()
+void 
+RunTests()
 {
 	TestFreeListAlloc();
 	TestHashTable();
 }
 
-void TestFreeListAlloc()
+void 
+TestFreeListAlloc()
 {
 	Printfln("Starting free list allocator tests...");
 
@@ -51,7 +53,8 @@ void TestFreeListAlloc()
 	}
 }
 
-void TestHashTable()
+void 
+TestHashTable()
 {
 	Printfln("Starting hash table tests...");
 	HashTable table;
diff --git a/src/util.c b/src/util.c
index a41f399..9d69e12 100644
--- a/src/util.c
+++ b/src/util.c
@@ -1,6 +1,7 @@
 // ::Util::Globals::Start::
 
-static Profiler GLOBAL_PROFILER;
+static Profiler 
+g_Global_Profiler;
 
 // ::Util::Globals::End::
 
@@ -8,7 +9,9 @@ static Profiler GLOBAL_PROFILER;
 
 // ::Util::Strings::Functions::Start::
 
-static void StrConcat(c8 *str, c8 *append)
+
+static void 
+StrConcat(c8 *str, c8 *append)
 {
 	u32 len = StrLen(str);
 	u32 i = 0;
@@ -20,12 +23,22 @@ static void StrConcat(c8 *str, c8 *append)
 	str[i] = '\0';
 }
 
-b32 StrEq(const char *l, const char *r) {
+static b32 
+StrEqL(const char *l, const char *r, u64 len)
+{
+	for (u64 i = 0; *l == *r && *l && i < len; l++, r++, i++);
+	return *l == *r;
+}
+
+static b32 
+StrEq(const char *l, const char *r) 
+{
 	for (; *l == *r && *l; l++, r++);
 	return *l == '\0' && *r == '\0';
 }
 
-u32 StrLen(const char *str) 
+static u32
+StrLen(const char *str) 
 {
 	const char *start;
 	
@@ -35,23 +48,88 @@ u32 StrLen(const char *str)
 	return (u32)(str - start);
 }
 
-i32 SPrintf(char *buf, rawptr fmt, ...) 
+static i32 
+SPrintf(char *buf, int len, rawptr fmt, ...) 
 {
 	va_list arg;
 
 	va_start(arg, fmt);
-	int sprf_res = stbsp_vsnprintf(buf, sizeof(buf), fmt, arg);
+	int sprf_res = stbsp_vsnprintf(buf, len, fmt, arg);
 	va_end(arg);
 
 	return sprf_res;
 }
 
-String8 MakeString8(u8 *str, u64 len)
+static String8 
+MakeString8(c8 *str, u64 len)
 {
 	return (String8){ .len = len, .value = str };
 }
 
-String8 PreSplitString8(String8 string, String8 delimiter)
+static String8 
+String8Concat(Arena *arena, String8 string, String8 append)
+{
+	u64 str_len = string.len + append.len;
+	String8 str = {
+		.value = MakeArray(arena, c8, str_len),
+		.len = str_len,
+	};
+
+	MemCpy(str.value, string.value, string.len);
+	MemCpy(str.value+string.len, append.value, append.len);
+
+	return str;
+}
+
+static void 
+String8TrimSuffix(String8 *str, c8 delimiter)
+{
+	if (!str || str->len == 0) return;
+
+	for (i64 i = i64(str->len)-1; i > 0; i -= 1)
+	{
+		if (str->value[i] == delimiter)
+		{
+			str->value[i] = '\0';
+			str->len = i == 0 ? 0 : u64(i - 1);
+			break;
+		}
+	}
+}
+
+static i64 
+String8FindLast(String8 str, c8 delimiter)
+{
+	if (str.len == 0) return -1;
+
+	i64 result = 1;
+
+	for (i64 i = i64(str.len)-1; i >= 0; i -= 1)
+	{
+		if (str.value[i] == delimiter)
+		{
+			result = i;
+			break;
+		}
+	}
+
+	return result;
+}
+
+static b32 
+String8Eq(String8 l, String8 r)
+{
+	return StrEqL(l.value, r.value, l.len);
+}
+
+static b32
+String8StartsWith(String8 string, String8 cmp)
+{
+	return StrEqL(string.value, cmp.value, cmp.len);
+}
+
+static String8 
+PreSplitString8(String8 string, String8 delimiter)
 {
 	if (string.len == 0 || delimiter.len == 0) return string;
 
@@ -76,7 +154,8 @@ String8 PreSplitString8(String8 string, String8 delimiter)
 	return (String8){ .len = new_len, .value = string.value };
 }
 
-String8 PreSplitNewString8(Arena *arena, String8 string, String8 delimiter)
+static String8 
+PreSplitNewString8(Arena *arena, String8 string, String8 delimiter)
 {
 	String8 result = PreSplitString8(string, delimiter);
 	
@@ -96,7 +175,8 @@ String8 PreSplitNewString8(Arena *arena, String8 string, String8 delimiter)
 
 // ::Util::Memory::Functions::Start::
 
-void MemZero(void *ptr, isize size)
+void 
+MemZero(void *ptr, isize size)
 {
 	if (!size || !ptr) return;
 
@@ -129,7 +209,8 @@ void MemZero(void *ptr, isize size)
 	}
 }
 
-void MemCpy(rawptr dst, rawptr src, usize size)
+void 
+MemCpy(rawptr dst, rawptr src, usize size)
 {
 	if (size == 0) return;
 
@@ -189,9 +270,10 @@ DefMathImpl(Abs);
 
 // ::Util::Hashing::Functions::Start::
 
-u64 static inline HashFromString(String8 string)
+u64 static inline 
+HashFromString(String8 string)
 {
-	return XXH3_64bits(string.value, string.len);
+	return XXH3_64bits_withSeed(string.value, string.len, HASH_SEED);
 }
 
 // ::Util::Hashing::Functions::End::
@@ -200,7 +282,8 @@ u64 static inline HashFromString(String8 string)
 
 // ::Util::Print::Functions::Start::
 
-i32 Printf(char *fmt, ...)
+i32 
+Printf(char *fmt, ...)
 {
 	va_list arg;
 
@@ -211,7 +294,8 @@ i32 Printf(char *fmt, ...)
 	return result;
 }
 
-i32 Printfln(char *fmt, ...)
+i32 
+Printfln(char *fmt, ...)
 {
 	va_list arg;
 
@@ -222,7 +306,8 @@ i32 Printfln(char *fmt, ...)
 	return result;
 }
 
-i32 EPrintf(char *fmt, ...)
+i32 
+EPrintf(char *fmt, ...)
 {
 	va_list arg;
 
@@ -233,12 +318,14 @@ i32 EPrintf(char *fmt, ...)
 	return result;
 }
 
-i32 EPrint(void *str) 
+i32 
+EPrint(void *str) 
 {
 	return pWriteStdErr(str, (isize)StrLen(str));
 }
 
-i32 _EPrintf(char *fmt, va_list arg) 
+i32 
+_EPrintf(char *fmt, va_list arg) 
 {
 	char buffer[1024];
 
@@ -249,7 +336,8 @@ i32 _EPrintf(char *fmt, va_list arg)
 	return EPrint(&buffer);
 }
 
-i32 _Printf(char *fmt, va_list arg) 
+i32 
+_Printf(char *fmt, va_list arg) 
 {
 	char buffer[1024];
 	
@@ -264,7 +352,8 @@ i32 _Printf(char *fmt, va_list arg)
 	return pr_res;
 }
 
-i32 _Printfln(char *fmt, va_list arg)
+i32 
+_Printfln(char *fmt, va_list arg)
 {
 	char buffer[1024];
 
@@ -291,18 +380,20 @@ i32 _Printfln(char *fmt, va_list arg)
 
 // ::Util::Profiling::Functions::Start::
 
-static inline void StartProfileBlock(ProfileBlock *block, c8 *label, u32 anchor_index)
+static inline void 
+StartProfileBlock(ProfileBlock *block, c8 *label, u32 anchor_index)
 {
 	block->anchor_index = anchor_index;
 	block->label = label;
 	block->start_tsc = pCPUTimerRead();
 }
 
-static inline void EndProfileBlock(ProfileBlock *block)
+static inline void 
+EndProfileBlock(ProfileBlock *block)
 {
 	u64 elapsed = pCPUTimerRead() - block->start_tsc;
 
-	ProfileAnchor *anchor = GLOBAL_PROFILER.anchors + block->anchor_index;
+	ProfileAnchor *anchor = g_Global_Profiler.anchors + block->anchor_index;
 	anchor->tsc_elapsed += elapsed;
 	anchor->hit_count += 1;
 	anchor->label = block->label;
@@ -314,35 +405,41 @@ static inline void EndProfileBlock(ProfileBlock *block)
 
 // ::Util::Async::Functions::Start::
 
-static inline b32 MutTryLock(Mut *mut)
+static inline b32 
+MutTryLock(Mut *mut)
 {
 	b32 lock = false;
 	return pAtomicCompareExchangeB32(&mut->lock, &lock, 1);
 }
 
-static inline void MutUnlock(Mut *mut)
+static inline void 
+MutUnlock(Mut *mut)
 {
 	pAtomicStoreB32(&mut->lock, 0);
 }
 
-static inline void TicketMutInit(TicketMut *mut)
+static inline void 
+TicketMutInit(TicketMut *mut)
 {
 	mut->ticket = 0;
 	mut->next_ticket = 1;
 }
 
-static inline void TicketMutLock(TicketMut *mut)
+static inline void 
+TicketMutLock(TicketMut *mut)
 {
 	u32 ticket = pAtomicFetchIncrU32(&mut->ticket);
 	while (ticket != mut->next_ticket);
 }
 
-static inline void TicketMutUnlock(TicketMut *mut)
+static inline void 
+TicketMutUnlock(TicketMut *mut)
 {
 	pAtomicIncrU32(&mut->next_ticket);
 }
 
-static inline u32 JobQueueAdd(JobQueue *queue, u32 count)
+static inline u32 
+JobQueueAdd(JobQueue *queue, u32 count)
 {
 	u32 job_idx = pAtomicFetchIncrU32(&queue->queued);
 	pAtomicFetchIncrU32(&queue->remaining);
@@ -350,30 +447,35 @@ static inline u32 JobQueueAdd(JobQueue *queue, u32 count)
 	return job_idx;
 }
 
-static inline u32 JobQueueGetCount(JobQueue *queue)
+static inline u32 
+JobQueueGetCount(JobQueue *queue)
 {
 	return pAtomicLoadU32(&queue->queued);
 }
 
-static inline void JobQueueMarkUnqueued(JobQueue *queue, u32 count)
+static inline void 
+JobQueueMarkUnqueued(JobQueue *queue, u32 count)
 {
 	Assert(queue->queued != 0, "queue queued is 0 before trying to mark dequeued");
 	pAtomicFetchSubU32(&queue->queued, count);
 }
 
-static inline void JobQueueMarkCompleted(JobQueue *queue, u32 count)
+static inline void 
+JobQueueMarkCompleted(JobQueue *queue, u32 count)
 {
 	Assert(queue->remaining != 0, "queue remaining is 0 before trying to mark completed");
 	pAtomicFetchSubU32(&queue->remaining, count);
 }
 
-static inline void JobQueueReset(JobQueue *queue)
+static inline void 
+JobQueueReset(JobQueue *queue)
 {
 	pAtomicFetchSubU32(&queue->queued, queue->queued);
 	pAtomicFetchSubU32(&queue->remaining, queue->remaining);
 }
 
-static inline b32 JobQueueCompleted(JobQueue *queue)
+static inline b32 
+JobQueueCompleted(JobQueue *queue)
 {
 	u32 remaining = pAtomicLoadU32(&queue->remaining);
 	return remaining == 0;
diff --git a/src/util.h b/src/util.h
index 392ed4a..e4adb72 100644
--- a/src/util.h
+++ b/src/util.h
@@ -136,25 +136,30 @@ arr.cap = len
 
 // ::Util::String8::Macros::
 
-#define String8Array(v, c) MakeString8((u8 *)(v), sizeof(*(v))*(c)) 
-#define String8Struct(v) MakeString8((u8 *)(v), sizeof(*(v)))
-#define String8CStr(v) MakeString8((u8 *)v, StrLen(v))
+#define String8Array(v, c) MakeString8((c8 *)(v), sizeof(*(v))*(c)) 
+#define String8Struct(v) MakeString8((c8 *)(v), sizeof(*(v)))
+#define String8CStr(v) MakeString8((c8 *)v, StrLen(v))
 
 // ::Util::Defines::Header::
 
-#define HM_MAX_SYMBOLS 256
-#define DEFAULT_ALIGNMENT (2*sizeof(rawptr))
-#define HASH_SEED 5995
+constexpr u32 HM_MAX_SYMBOLS = 256;
+constexpr usize DEFAULT_ALIGNMENT = (2*sizeof(rawptr));
+constexpr u64 HASH_SEED = 5995;
 
 // ::Util::Strings::Functions::Header::
 
-String8 MakeString8(u8 *str, u64 len);
-u32 StrLen(const char *str);
-b32 StrEq(const char *l, const char *r);
-i32 SPrintf(char *buf, rawptr fmt, ...);
-String8 PreSplitString8(String8 string, String8 delimiter);
-String8 PreSplitNewString8(Arena *arena, String8 string, String8 delimiter);
+static b32 String8Eq(String8 l, String8 r);
+static u32 StrLen(const char *str);
+static b32 StrEqL(const char *l, const char *r, u64 len);
+static b32 StrEq(const char *l, const char *r);
+static i32 SPrintf(char *buf, int len, rawptr fmt, ...);
 static void StrConcat(c8 *str, c8 *append);
+static String8 MakeString8(c8 *str, u64 len);
+static String8 String8Concat(Arena *arena, String8 string, String8 append);
+static void String8TrimSuffix(String8 *str, c8 delimiter);
+static i64 String8FindLast(String8 str, c8 delimiter);
+static String8 PreSplitString8(String8 string, String8 delimiter);
+static String8 PreSplitNewString8(Arena *arena, String8 string, String8 delimiter);
 
 // ::Util::Memory::Functions::Header::
 
diff --git a/src/vulkan_config.c b/src/vulkan_config.c
index e72b5b8..a935606 100644
--- a/src/vulkan_config.c
+++ b/src/vulkan_config.c
@@ -1,12 +1,14 @@
 
 // VULKAN CONFIG
 
-static const VkFormat VK_IMAGE_FORMATS[] = {
+static const VkFormat 
+VK_IMAGE_FORMATS[] = {
 	VK_FORMAT_R16G16B16A16_UNORM,
 	VK_FORMAT_R8G8B8A8_UNORM,
 };
 
-static VkApplicationInfo app_info = {
+static VkApplicationInfo 
+g_App_Info = {
 	.sType = STYPE(APPLICATION_INFO),
 	.pApplicationName = "Video Game",
 	.applicationVersion = VK_MAKE_API_VERSION(0, 0, 0, 1),
@@ -15,14 +17,18 @@ static VkApplicationInfo app_info = {
 	.apiVersion = VK_API_VERSION_1_3,
 };
 
-static const char *instance_layers[] = {
+static const char *
+instance_layers[] = 
+{
 #ifdef BUILD_DEBUG
 	"VK_LAYER_KHRONOS_validation"
 #endif
 };
 
 
-static const char *instance_extensions[] = {
+static const char *
+g_Instance_Extensions[] = 
+{
 	VK_KHR_SURFACE_EXTENSION_NAME,
 
 #ifdef __linux__
@@ -36,25 +42,30 @@ static const char *instance_extensions[] = {
 #ifdef BUILD_DEBUG
 	VK_EXT_DEBUG_UTILS_EXTENSION_NAME,
 #endif
-
 };
 
-static VkInstanceCreateInfo inst_info = {
+static VkInstanceCreateInfo 
+g_Instance_Info = 
+{
 	.sType = STYPE(INSTANCE_CREATE_INFO),
-	.pApplicationInfo = &app_info,
+	.pApplicationInfo = &g_App_Info,
 	.enabledLayerCount = sizeof(instance_layers) / sizeof(char *),
 	.ppEnabledLayerNames = instance_layers,
-	.enabledExtensionCount = sizeof(instance_extensions) / sizeof(char *),
-	.ppEnabledExtensionNames = instance_extensions,
+	.enabledExtensionCount = sizeof(g_Instance_Extensions) / sizeof(char *),
+	.ppEnabledExtensionNames = g_Instance_Extensions,
 };
 
-const char *device_extensions[] = {
+const char *
+g_Device_Extensions[] = 
+{
 	VK_KHR_SWAPCHAIN_EXTENSION_NAME,
 	VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME,
 };
 
 #ifdef BUILD_DEBUG
-static VkDebugUtilsMessengerCreateInfoEXT debug_msg_info = {
+static VkDebugUtilsMessengerCreateInfoEXT 
+g_Debug_Message_Info = 
+{
 	.sType = STYPE(DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT),
 	.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT |
 										 VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT,
@@ -65,15 +76,19 @@ static VkDebugUtilsMessengerCreateInfoEXT debug_msg_info = {
 };
 #endif
 
-static VkPhysicalDeviceVulkan13Features vk_13_features = { 
+static VkPhysicalDeviceVulkan13Features 
+g_Vk_13_Features = 
+{ 
 	.sType = STYPE(PHYSICAL_DEVICE_VULKAN_1_3_FEATURES),
 	.synchronization2 = VK_TRUE,
 	.dynamicRendering = VK_TRUE
 };
 
-static VkPhysicalDeviceVulkan12Features vk_12_features = {
+static VkPhysicalDeviceVulkan12Features 
+g_Vk_12_Features = 
+{
 	.sType = STYPE(PHYSICAL_DEVICE_VULKAN_1_2_FEATURES),
-	.pNext = &vk_13_features,
+	.pNext = &g_Vk_13_Features,
 	.descriptorIndexing = VK_TRUE,
 	.bufferDeviceAddress = VK_TRUE,
 	.descriptorBindingUniformBufferUpdateAfterBind = VK_TRUE,
@@ -86,14 +101,18 @@ static VkPhysicalDeviceVulkan12Features vk_12_features = {
 	.runtimeDescriptorArray = VK_TRUE,
 };
 
-static VkPhysicalDeviceVulkan11Features vk_11_features = {
+static VkPhysicalDeviceVulkan11Features 
+g_Vk_11_Features = 
+{
 	.sType = STYPE(PHYSICAL_DEVICE_VULKAN_1_1_FEATURES),
-	.pNext = &vk_12_features
+	.pNext = &g_Vk_12_Features
 };
 
-static const VkPhysicalDeviceFeatures2 vk_features_2 = {
+static const VkPhysicalDeviceFeatures2 
+g_Vk_Features_2 = 
+{
 	.sType = STYPE(PHYSICAL_DEVICE_FEATURES_2),
-	.pNext = &vk_11_features,
+	.pNext = &g_Vk_11_Features,
 	.features = {
 		.shaderUniformBufferArrayDynamicIndexing = VK_TRUE,
 		.shaderSampledImageArrayDynamicIndexing = VK_TRUE,
@@ -103,40 +122,54 @@ static const VkPhysicalDeviceFeatures2 vk_features_2 = {
 	},
 };
 
-static VkDeviceCreateInfo device_info = {
+static VkDeviceCreateInfo 
+g_Device_Info = 
+{
 	.sType = STYPE(DEVICE_CREATE_INFO),
-	.pNext = &vk_features_2,
-	.ppEnabledExtensionNames = device_extensions,
-	.enabledExtensionCount = Len(device_extensions),
+	.pNext = &g_Vk_Features_2,
+	.ppEnabledExtensionNames = g_Device_Extensions,
+	.enabledExtensionCount = Len(g_Device_Extensions),
 	.pEnabledFeatures = NULL,
 };
 
-static VmaAllocatorCreateInfo vma_create_info = {
+static VmaAllocatorCreateInfo 
+g_VMA_Create_Info = 
+{
 	.flags = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT,
 	.vulkanApiVersion = VK_API_VERSION_1_3,
 };
 
-static VkCommandPoolCreateInfo pool_create_info = {
+static VkCommandPoolCreateInfo 
+g_Pool_Create_Info = 
+{
 	.sType = STYPE(COMMAND_POOL_CREATE_INFO),
 	.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,
 };
 
-static VkFenceCreateInfo fence_create_info = {
+static VkFenceCreateInfo 
+g_Fence_Create_Info = 
+{
 	.sType = STYPE(FENCE_CREATE_INFO),
 	.flags = VK_FENCE_CREATE_SIGNALED_BIT,
 };
 
-static VkSemaphoreCreateInfo semaphore_create_info = {
+static VkSemaphoreCreateInfo 
+g_Semaphore_Create_info = 
+{
 	.sType = STYPE(SEMAPHORE_CREATE_INFO),
 };
 
-static VkCommandBufferAllocateInfo cmd_buf_info = {
+static VkCommandBufferAllocateInfo 
+g_Command_Buffer_Info = 
+{
 	.sType = STYPE(COMMAND_BUFFER_ALLOCATE_INFO),
 	.commandBufferCount = 1,
 	.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY,
 };
 
-static VkSwapchainCreateInfoKHR swapchain_create_info = {
+static VkSwapchainCreateInfoKHR 
+g_Swap_Info = 
+{
 	.sType = STYPE(SWAPCHAIN_CREATE_INFO_KHR),
 	.imageArrayLayers = 1,
 	.imageUsage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
@@ -145,7 +178,9 @@ static VkSwapchainCreateInfoKHR swapchain_create_info = {
 	.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
 };
 
-static VkImageViewCreateInfo sc_image_view_create_info = {
+static VkImageViewCreateInfo 
+g_Swap_View_Info = 
+{
 	.sType = STYPE(IMAGE_VIEW_CREATE_INFO),
 	.viewType = VK_IMAGE_VIEW_TYPE_2D,
 	.components = {
@@ -163,7 +198,9 @@ static VkImageViewCreateInfo sc_image_view_create_info = {
 	},
 };
 
-static VkImageCreateInfo draw_image_create_info = {
+static VkImageCreateInfo 
+g_Draw_Image_Info =
+{
 	.sType = STYPE(IMAGE_CREATE_INFO),
 	.imageType = VK_IMAGE_TYPE_2D,
 	.mipLevels = 1,
@@ -173,7 +210,9 @@ static VkImageCreateInfo draw_image_create_info = {
 	.usage = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_STORAGE_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
 };
 
-static VkImageViewCreateInfo draw_image_view_create_info = {
+static VkImageViewCreateInfo 
+g_Draw_View_Info = 
+{
 	.sType = STYPE(IMAGE_VIEW_CREATE_INFO),
 	.viewType = VK_IMAGE_VIEW_TYPE_2D,
 	.subresourceRange = {
@@ -185,7 +224,9 @@ static VkImageViewCreateInfo draw_image_view_create_info = {
 	},
 };
 
-static VkImageCreateInfo depth_image_create_info = {
+static VkImageCreateInfo 
+g_Depth_Image_Info = 
+{
 	.sType = STYPE(IMAGE_CREATE_INFO),
 	.imageType = VK_IMAGE_TYPE_2D,
 	.mipLevels = 1,
@@ -196,7 +237,9 @@ static VkImageCreateInfo depth_image_create_info = {
 	.usage = VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
 };
 
-static VkImageViewCreateInfo depth_image_view_create_info = {
+static VkImageViewCreateInfo 
+g_Depth_View_Info = 
+{
 	.sType = STYPE(IMAGE_VIEW_CREATE_INFO),
 	.viewType = VK_IMAGE_VIEW_TYPE_2D,
 	.format = VK_FORMAT_D32_SFLOAT,
@@ -213,93 +256,120 @@ static VkImageViewCreateInfo depth_image_view_create_info = {
 // PIPELINES & DESCRIPTORS
 //
 
-static VkDescriptorPoolSize descriptor_pool_sizes[] = {
+static VkDescriptorPoolSize 
+g_Desc_Pool_Sizes[] =
+{
 	{ .type = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, .descriptorCount = 4096 },
 	{ .type = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .descriptorCount = 4096},
 	{ .type = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, .descriptorCount = 4096},
 	{ .type = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .descriptorCount = 4096},
 };
 
-static VkDescriptorPoolCreateInfo desc_pool_info = {
+static VkDescriptorPoolCreateInfo 
+g_Desc_Pool_Info = 
+{
 	.sType = STYPE(DESCRIPTOR_POOL_CREATE_INFO),
-	.poolSizeCount = Len(descriptor_pool_sizes),
-	.pPoolSizes = descriptor_pool_sizes,
+	.poolSizeCount = Len(g_Desc_Pool_Sizes),
+	.pPoolSizes = g_Desc_Pool_Sizes,
 	.maxSets = 12, // Not sure if this is correct
 	.flags = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
 };
 
-static VkDescriptorBindingFlags shared_desc_binding_flags[] = {	
+static VkDescriptorBindingFlags 
+g_Shared_Binding_Flags[] = 
+{	
 	VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
 	VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
 	VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
 	VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT,
 };
 
-static VkDescriptorSetLayoutBindingFlagsCreateInfo shared_layout_binding_flags_info = {
+static VkDescriptorSetLayoutBindingFlagsCreateInfo 
+g_Shared_Desc_Flag_Info = 
+{
 	.sType = STYPE(DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO),
-	.bindingCount = Len(shared_desc_binding_flags),
-	.pBindingFlags = shared_desc_binding_flags,
+	.bindingCount = Len(g_Shared_Binding_Flags),
+	.pBindingFlags = g_Shared_Binding_Flags,
 };
 
-static VkDescriptorSetLayoutBinding shared_layout_bindings[] = {
+static VkDescriptorSetLayoutBinding 
+g_Shared_Desc_Bindings[] =
+{
 	{ .binding = 0, .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .descriptorCount = 1, .stageFlags = VK_SHADER_STAGE_ALL },
 	{ .binding = 1, .descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, .descriptorCount = 1, .stageFlags = VK_SHADER_STAGE_ALL },
 	{ .binding = 2, .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE, .descriptorCount = 1, .stageFlags = VK_SHADER_STAGE_ALL },
 	{ .binding = 3, .descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER, .descriptorCount = 1, .stageFlags = VK_SHADER_STAGE_ALL },
 };
 
-static VkDescriptorSetLayoutCreateInfo shared_layout_create_info = {
+static VkDescriptorSetLayoutCreateInfo 
+g_Shared_Desc_Layout_Info = 
+{
 	.sType = STYPE(DESCRIPTOR_SET_LAYOUT_CREATE_INFO),
-	.pNext = &shared_layout_binding_flags_info,
-	.bindingCount = Len(shared_layout_bindings),
-	.pBindings = shared_layout_bindings,
+	.pNext = &g_Shared_Desc_Flag_Info,
+	.bindingCount = Len(g_Shared_Desc_Bindings),
+	.pBindings = g_Shared_Desc_Bindings,
 	.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
 };
 
-static VkDescriptorType desc_type_map[vDT_MAX] = {
+static VkDescriptorType 
+g_Desc_Type_Map[vDT_MAX] = 
+{
 	[vDT_SAMPLED_IMAGE] = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
 	[vDT_MATERIAL] = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
 	[vDT_MESH] = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
 };
 
-static VkDescriptorBindingFlags bindless_desc_binding_flags = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT | VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT;
+static VkDescriptorBindingFlags 
+g_Bindless_Binding_Flags = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT | VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT;
 
-static VkDescriptorSetLayoutBindingFlagsCreateInfo bindless_layout_flag_create_info = {
+static VkDescriptorSetLayoutBindingFlagsCreateInfo 
+g_Bindless_Desc_Flag_Info = 
+{
 	.sType = STYPE(DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO),
 	.bindingCount = 1,
-	.pBindingFlags = &bindless_desc_binding_flags,
+	.pBindingFlags = &g_Bindless_Binding_Flags,
 };
 
-static VkDescriptorSetLayoutBinding bindless_layout_binding = {
+static VkDescriptorSetLayoutBinding 
+g_Bindless_Desc_Binding = 
+{
 	.binding = 0,
 	.descriptorCount = 1024,
 	.stageFlags = VK_SHADER_STAGE_ALL,
 };
 
-static VkDescriptorSetLayoutCreateInfo bindless_layout_create_info = {
+static VkDescriptorSetLayoutCreateInfo 
+g_Bindless_Desc_Info = 
+{
 	.sType = STYPE(DESCRIPTOR_SET_LAYOUT_CREATE_INFO),
-	.pNext = &bindless_layout_flag_create_info,
+	.pNext = &g_Bindless_Desc_Flag_Info,
 	.bindingCount = 1,
-	.pBindings = &bindless_layout_binding,
+	.pBindings = &g_Bindless_Desc_Binding,
 	.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT,
 };
 
-static VkDescriptorSetAllocateInfo set_allocate_info = {
+static VkDescriptorSetAllocateInfo 
+g_Descriptor_Alloc_Info = 
+{
 	.sType = STYPE(DESCRIPTOR_SET_ALLOCATE_INFO),
 	.descriptorSetCount = vDT_MAX,
 };
 
-static VkPushConstantRange push_const_range = {
+static VkPushConstantRange 
+g_Push_Const_Range = 
+{
 	.offset = 0,
 	.size = sizeof(rPushConst),
 	.stageFlags = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_VERTEX_BIT,
 };
 
-static VkPipelineLayoutCreateInfo pipeline_layout_create_info = {
+static VkPipelineLayoutCreateInfo 
+g_Pipeline_Layout_Info = 
+{
 	.sType = STYPE(PIPELINE_LAYOUT_CREATE_INFO),
 	.setLayoutCount = vDT_MAX, 
 	.pushConstantRangeCount = 1,
-	.pPushConstantRanges = &push_const_range,
+	.pPushConstantRanges = &g_Push_Const_Range,
 };
 
 //
@@ -309,15 +379,17 @@ static VkPipelineLayoutCreateInfo pipeline_layout_create_info = {
 #define PIPELINE_DYNAMIC_STATE { VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR }
  
 
-static VkDynamicState pipeline_dynamic_state[] = PIPELINE_DYNAMIC_STATE;
+static VkDynamicState 
+g_Pipeline_Dynamic_State[] = PIPELINE_DYNAMIC_STATE;
 
 #define PIPELINE_DEFAULT_DYN_STATE_INFO { \
 	.sType = STYPE(PIPELINE_DYNAMIC_STATE_CREATE_INFO), \
-	.pDynamicStates = pipeline_dynamic_state, \
-	.dynamicStateCount = Len(pipeline_dynamic_state), \
+	.pDynamicStates = g_Pipeline_Dynamic_State, \
+	.dynamicStateCount = Len(g_Pipeline_Dynamic_State), \
 }
 
-static VkPipelineDynamicStateCreateInfo pipeline_default_dyn_state_info = PIPELINE_DEFAULT_DYN_STATE_INFO;
+static VkPipelineDynamicStateCreateInfo 
+g_Pipeline_Default_Dynamic_Info = PIPELINE_DEFAULT_DYN_STATE_INFO;
 
 #define PIPELINE_DEFAULT_ASSEMBLY_INFO { \
 	.sType = STYPE(PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO), \
@@ -325,7 +397,8 @@ static VkPipelineDynamicStateCreateInfo pipeline_default_dyn_state_info = PIPELI
 	.primitiveRestartEnable = VK_FALSE, \
 }
 
-static VkPipelineInputAssemblyStateCreateInfo pipeline_default_assembly_info = PIPELINE_DEFAULT_ASSEMBLY_INFO;
+static VkPipelineInputAssemblyStateCreateInfo 
+g_Pipeline_Default_Assembly_Info = PIPELINE_DEFAULT_ASSEMBLY_INFO;
 
 #define PIPELINE_DEFAULT_RASTERIZATION_INFO { \
 	.sType = STYPE(PIPELINE_RASTERIZATION_STATE_CREATE_INFO), \
@@ -334,7 +407,8 @@ static VkPipelineInputAssemblyStateCreateInfo pipeline_default_assembly_info = P
 	.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE, \
 }
 
-static VkPipelineRasterizationStateCreateInfo pipeline_default_rasterization_info = PIPELINE_DEFAULT_RASTERIZATION_INFO;
+static VkPipelineRasterizationStateCreateInfo 
+g_Pipeline_Default_Rasterization_Info = PIPELINE_DEFAULT_RASTERIZATION_INFO;
 
 #define PIPELINE_DEFAULT_MULTISAMPLE_INFO { \
 	.sType = STYPE(PIPELINE_MULTISAMPLE_STATE_CREATE_INFO), \
@@ -344,7 +418,8 @@ static VkPipelineRasterizationStateCreateInfo pipeline_default_rasterization_inf
 	.alphaToOneEnable = VK_FALSE, \
 }
 
-static VkPipelineMultisampleStateCreateInfo pipeline_default_multisample_info = PIPELINE_DEFAULT_MULTISAMPLE_INFO;
+static VkPipelineMultisampleStateCreateInfo 
+g_Pipeline_Default_Multisample_Info = PIPELINE_DEFAULT_MULTISAMPLE_INFO;
 
 #define PIPELINE_DEFAULT_DEPTH_INFO { \
 	.sType = STYPE(PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO), \
@@ -357,37 +432,42 @@ static VkPipelineMultisampleStateCreateInfo pipeline_default_multisample_info =
 	.maxDepthBounds = 1.0, \
 }
 
-static VkPipelineDepthStencilStateCreateInfo pipeline_default_depth_info = PIPELINE_DEFAULT_DEPTH_INFO;
+static VkPipelineDepthStencilStateCreateInfo 
+g_Pipeline_Default_Depth_Info = PIPELINE_DEFAULT_DEPTH_INFO;
 
 #define PIPELINE_DEFAULT_RENDERING_INFO { \
 	.sType = STYPE(PIPELINE_RENDERING_CREATE_INFO), \
 	.colorAttachmentCount = 1, \
 }
 
-static VkPipelineRenderingCreateInfo pipeline_default_rendering_info = PIPELINE_DEFAULT_RENDERING_INFO;
+static VkPipelineRenderingCreateInfo 
+g_Pipeline_Default_Rendering_Info = PIPELINE_DEFAULT_RENDERING_INFO;
 
 #define PIPELINE_DEFAULT_BLEND_ATTACH_STATE { \
 	.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT, \
 	.blendEnable = VK_FALSE, \
 }
 
-static VkPipelineColorBlendAttachmentState pipeline_default_blend_attach_state = PIPELINE_DEFAULT_BLEND_ATTACH_STATE;
+static VkPipelineColorBlendAttachmentState 
+g_Pipeline_Default_Blend_State = PIPELINE_DEFAULT_BLEND_ATTACH_STATE;
 
 #define PIPELINE_DEFAULT_BLEND_INFO { \
 	.sType = STYPE(PIPELINE_COLOR_BLEND_STATE_CREATE_INFO), \
 	.logicOpEnable = VK_FALSE, \
 	.logicOp = VK_LOGIC_OP_COPY, \
 	.attachmentCount = 1, \
-	.pAttachments = &pipeline_default_blend_attach_state, \
+	.pAttachments = &g_Pipeline_Default_Blend_State, \
 }
 
-static VkPipelineColorBlendStateCreateInfo pipeline_default_blend_info = PIPELINE_DEFAULT_BLEND_INFO;
+static VkPipelineColorBlendStateCreateInfo 
+g_Pipeline_Default_Blend_Info = PIPELINE_DEFAULT_BLEND_INFO;
 
 #define PIPELINE_DEFAULT_VERTEX_INFO { \
 	.sType = STYPE(PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO), \
 }
 
-static VkPipelineVertexInputStateCreateInfo pipeline_default_vertex_info = PIPELINE_DEFAULT_VERTEX_INFO;
+static VkPipelineVertexInputStateCreateInfo 
+g_Pipeline_Default_Vertex_Info = PIPELINE_DEFAULT_VERTEX_INFO;
 
 #define PIPELINE_DEFAULT_VIEWPORT_INFO { \
 	.sType = STYPE(PIPELINE_VIEWPORT_STATE_CREATE_INFO), \
@@ -395,51 +475,56 @@ static VkPipelineVertexInputStateCreateInfo pipeline_default_vertex_info = PIPEL
 	.scissorCount = 1, \
 }
 
-const static VkPipelineViewportStateCreateInfo pipeline_default_viewport_info = PIPELINE_DEFAULT_VIEWPORT_INFO;
+const static VkPipelineViewportStateCreateInfo 
+g_Pipeline_Default_Viewport_Info = PIPELINE_DEFAULT_VIEWPORT_INFO;
 
 
 #define INIT_PIPELINE_DEFAULTS(pipeline)  																																\
-VkPipelineDynamicStateCreateInfo pipeline##_default_dynamic_info = PIPELINE_DEFAULT_DYN_STATE_INFO; 				\
-VkPipelineInputAssemblyStateCreateInfo pipeline##_default_assembly_info = PIPELINE_DEFAULT_ASSEMBLY_INFO; 	\
-VkPipelineRasterizationStateCreateInfo pipeline##_default_rasterization_info = PIPELINE_DEFAULT_RASTERIZATION_INFO; \
-VkPipelineMultisampleStateCreateInfo pipeline##_default_multisample_info = PIPELINE_DEFAULT_MULTISAMPLE_INFO; \
-VkPipelineDepthStencilStateCreateInfo pipeline##_default_depth_info = PIPELINE_DEFAULT_DEPTH_INFO; \
-VkPipelineRenderingCreateInfo pipeline##_default_rendering_info = PIPELINE_DEFAULT_RENDERING_INFO; \
-VkPipelineColorBlendStateCreateInfo pipeline##_default_blend_info = PIPELINE_DEFAULT_BLEND_INFO; \
-VkPipelineVertexInputStateCreateInfo pipeline##_default_vertex_info = PIPELINE_DEFAULT_VERTEX_INFO; \
-VkPipelineViewportStateCreateInfo pipeline##_default_viewport_info = PIPELINE_DEFAULT_VIEWPORT_INFO; \
-VkGraphicsPipelineCreateInfo pipeline##_create_info = { \
+VkPipelineDynamicStateCreateInfo g_##pipeline##_Default_Dynamic_Info = PIPELINE_DEFAULT_DYN_STATE_INFO; 				\
+VkPipelineInputAssemblyStateCreateInfo g_##pipeline##_Default_Assembly_Info = PIPELINE_DEFAULT_ASSEMBLY_INFO; 	\
+VkPipelineRasterizationStateCreateInfo g_##pipeline##_Default_Rasterization_Info = PIPELINE_DEFAULT_RASTERIZATION_INFO; \
+VkPipelineMultisampleStateCreateInfo g_##pipeline##_Default_Multisample_Info = PIPELINE_DEFAULT_MULTISAMPLE_INFO; \
+VkPipelineDepthStencilStateCreateInfo g_##pipeline##_Default_Depth_Info = PIPELINE_DEFAULT_DEPTH_INFO; \
+VkPipelineRenderingCreateInfo g_##pipeline##_Default_Rendering_Info = PIPELINE_DEFAULT_RENDERING_INFO; \
+VkPipelineColorBlendStateCreateInfo g_##pipeline##_Default_Blend_Info = PIPELINE_DEFAULT_BLEND_INFO; \
+VkPipelineVertexInputStateCreateInfo g_##pipeline##_Default_Vertex_Info = PIPELINE_DEFAULT_VERTEX_INFO; \
+VkPipelineViewportStateCreateInfo g_##pipeline##_Default_Viewport_Info = PIPELINE_DEFAULT_VIEWPORT_INFO; \
+VkGraphicsPipelineCreateInfo g_##pipeline##_Create_Info = { \
 	.sType = STYPE(GRAPHICS_PIPELINE_CREATE_INFO),				\
-	.pNext = &pipeline##_default_rendering_info, 									\
-	.pVertexInputState = &pipeline##_default_vertex_info,					\
-	.pInputAssemblyState = &pipeline##_default_assembly_info,			\
-	.pViewportState = &pipeline##_default_viewport_info, 					\
-	.pRasterizationState = &pipeline##_default_rasterization_info,\
-	.pMultisampleState = &pipeline##_default_multisample_info, 		\
-	.pColorBlendState = &pipeline##_default_blend_info, 					\
-	.pDepthStencilState = &pipeline##_default_depth_info,					\
-	.pDynamicState = &pipeline##_default_dynamic_info,						\
+	.pNext = &g_##pipeline##_Default_Rendering_Info, 									\
+	.pVertexInputState = &g_##pipeline##_Default_Vertex_Info,					\
+	.pInputAssemblyState = &g_##pipeline##_Default_Assembly_Info,			\
+	.pViewportState = &g_##pipeline##_Default_Viewport_Info, 					\
+	.pRasterizationState = &g_##pipeline##_Default_Rasterization_Info,\
+	.pMultisampleState = &g_##pipeline##_Default_Multisample_Info, 		\
+	.pColorBlendState = &g_##pipeline##_Default_Blend_Info, 					\
+	.pDepthStencilState = &g_##pipeline##_Default_Depth_Info,					\
+	.pDynamicState = &g_##pipeline##_Default_Dynamic_Info,						\
 };
 
-INIT_PIPELINE_DEFAULTS(cube);
+INIT_PIPELINE_DEFAULTS(CUBE);
 
 // GUI Pipeline
-INIT_PIPELINE_DEFAULTS(gui);
+INIT_PIPELINE_DEFAULTS(GUI);
 
-VkVertexInputBindingDescription gui_input_bind_desc = {
+VkVertexInputBindingDescription 
+gui_input_bind_desc = {
 	.binding = 0,
 	.stride = sizeof(rUIVertex),
 	.inputRate = VK_VERTEX_INPUT_RATE_INSTANCE,
 };
 
-VkVertexInputAttributeDescription gui_input_descriptions[] = {
+VkVertexInputAttributeDescription 
+gui_input_descriptions[] = {
 	{ .binding = 0, .location = 0, .format = VK_FORMAT_R32G32_SFLOAT, .offset = 0 },
 	{ .binding = 0, .location = 1, .format = VK_FORMAT_R32G32_SFLOAT, .offset = offsetof(rUIVertex, p1) },
 	{ .binding = 0, .location = 2, .format = VK_FORMAT_R32G32B32A32_SFLOAT, .offset = offsetof(rUIVertex, col) },
 	{ .binding = 0, .location = 3, .format = VK_FORMAT_R32_UINT, .offset = offsetof(rUIVertex, tex_idx) },
 };
 
-VkPipelineVertexInputStateCreateInfo gui_vertex_input_info = {
+VkPipelineVertexInputStateCreateInfo 
+gui_vertex_input_info = 
+{
 	.sType = STYPE(PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO),
 	.vertexBindingDescriptionCount = 1,
 	.pVertexBindingDescriptions = &gui_input_bind_desc,
@@ -447,40 +532,49 @@ VkPipelineVertexInputStateCreateInfo gui_vertex_input_info = {
 	.pVertexAttributeDescriptions = gui_input_descriptions,
 };
 
-VkPipelineInputAssemblyStateCreateInfo gui_assembly_info = {
+VkPipelineInputAssemblyStateCreateInfo 
+gui_assembly_info = 
+{
 	.sType = STYPE(PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO),
 	.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
 	.primitiveRestartEnable = VK_FALSE,
 };
 
 // PBR Pipeline
-INIT_PIPELINE_DEFAULTS(pbr);
+INIT_PIPELINE_DEFAULTS(PBR);
 
-VkVertexInputBindingDescription pbr_input_bind_desc = {
+VkVertexInputBindingDescription 
+pbr_input_bind_desc = 
+{
 	.binding = 0,
 	.stride = sizeof(rPBRVertex),
 	.inputRate = VK_VERTEX_INPUT_RATE_VERTEX,
 };
 
-VkPipelineVertexInputStateCreateInfo pbr_vertex_input_info = {
+VkPipelineVertexInputStateCreateInfo 
+pbr_vertex_input_info = 
+{
 	.sType = STYPE(PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO),
 	.vertexBindingDescriptionCount = 1,
 	.pVertexBindingDescriptions = &pbr_input_bind_desc,
 };
 
-VkPipelineInputAssemblyStateCreateInfo pbr_assembly_info = {
+VkPipelineInputAssemblyStateCreateInfo 
+pbr_assembly_info = 
+{
 	.sType = STYPE(PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO),
 	.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
 	.primitiveRestartEnable = VK_FALSE,
 };
 
-static void vCustomizePipelines()
+static void 
+vCustomizePipelines()
 {
 	// GUI
-	gui_create_info.pVertexInputState = &gui_vertex_input_info;
-	gui_create_info.pInputAssemblyState = &gui_assembly_info;
+	g_GUI_Create_Info.pVertexInputState = &gui_vertex_input_info;
+	g_GUI_Create_Info.pInputAssemblyState = &gui_assembly_info;
 
 	// PBR
-	pbr_create_info.pVertexInputState = &pbr_vertex_input_info;
-	pbr_create_info.pInputAssemblyState = &pbr_assembly_info;
+	g_PBR_Create_Info.pVertexInputState = &pbr_vertex_input_info;
+	g_PBR_Create_Info.pInputAssemblyState = &pbr_assembly_info;
 }