diff --git a/src/arena.c b/src/arena.c
index efdd1e9..185c180 100644
--- a/src/arena.c
+++ b/src/arena.c
@@ -2,79 +2,77 @@
 #include "base_core.h"
 #include "platform.h"
 
-static INLINE U32 arena_absolute_pos(const Arena *arena)
+
+MemoryBlock *memoryblock_allocate(size_t size)
 {
-    const Arena *current = arena->current;
-    return current->base_pos + current->pos;
+    void *base = memory_allocate(size);
+    Assert(base != NULL);
+
+    MemoryBlock *block = (MemoryBlock *)base;
+    block->base      = (U8 *)base;
+    block->size      = size;
+    block->pos       = MemoryBlock_Header_Size;
+    block->base_pos  = 0;
+    block->prev      = NULL;
+
+    return block;
 }
 
-Arena *arena_alloc(const ArenaParams *params)
+void arena_init(Arena *arena, const ArenaParams *params)
 {
-    Assert(params->size > ARENA_HEADER_SZ);
-    Assert(params->size < (U32_Max -  ARENA_HEADER_SZ - 1));
+    Assert(params->size > MemoryBlock_Header_Size);
+    Assert(params->size < (U32_Max -  MemoryBlock_Header_Size - 1));
 
-    void *base;
-    base = memory_allocate(params->size);
-    Assert(base != NULL);
-    ASAN_UNPOISON_MEMORY_REGION(base, ARENA_HEADER_SZ);
+    MemoryBlock *block = memoryblock_allocate(params->size);
+    ASAN_UNPOISON_MEMORY_REGION(block, MemoryBlock_Header_Size);
 
-    Arena *arena = (Arena *)base;
-    arena->base     = (U8 *)base;
-    arena->current  = arena;
-    arena->size     = params->size;
-    arena->pos      = ARENA_HEADER_SZ;
-    arena->base_pos = 0;
-    arena->flags    = params->flags;
-    arena->prev     = NULL;
+    arena->flags            = params->flags;
     arena->checkpoint_level = 0;
+    arena->current          = block;
+    arena->requested_size   = params->size;
 
-    ASAN_POISON_MEMORY_REGION(&arena->base[arena->pos], arena_available(arena));
-    return arena;
+    ASAN_POISON_MEMORY_REGION(&block->base[block->pos], memoryblock_available(block));
 }
 
 void arena_free(Arena *arena)
 {
-    Arena *it = arena->current;
+    MemoryBlock *block = arena->current;
 
-    while (it != NULL) {
-        Arena *prev = it->prev;
-        memory_free(it->base, it->size);
-        it = prev;
+    while (block != NULL) {
+        MemoryBlock *prev = block->prev;
+        memory_free(block->base, block->size);
+        block = prev;
     }
 }
 
 void *arena_push(Arena *arena, U32 size, U32 align)
 {
-    Assert(size < (U32_Max - align - ARENA_HEADER_SZ - 1));
+    Assert(size < (U32_Max - align - MemoryBlock_Header_Size - 1));
     Assert(IsPow2(align));
 
-    Arena *current = arena->current;
-    U32 start_pos = AlignUpPow2(current->pos, align);
-    U32 available = arena_available(current);
+    MemoryBlock *block = arena->current;
+    U32 start_pos = AlignUpPow2(block->pos, align);
+    U32 available = memoryblock_available(block);
 
     if (available < size) {
-        U32 new_size = arena->size; // original user requeted size
+        U32 new_size = arena->requested_size; // original user requeted size
         if (new_size < size) {
-            new_size = AlignUpPow2(size + ARENA_HEADER_SZ,align);
+            new_size = AlignUpPow2(size + MemoryBlock_Header_Size,align);
         }
 
-        ArenaParams new_params  = {};
-        new_params.flags        = current->flags;
-        new_params.size         = new_size;
-
-        Arena *new_arena    = arena_alloc(&new_params);
-        new_arena->base_pos = current->base_pos + current->size;
-        new_arena->prev     = current;
-        arena->current      = new_arena;
-        current             = new_arena;
-        start_pos           = AlignUpPow2(current->pos, align);
+        MemoryBlock *new_block  = memoryblock_allocate(new_size);
+        new_block->base_pos     = block->base_pos + block->size;
+        new_block->prev         = block;
+        arena->current          = new_block;
+        block                   = new_block;
+        start_pos               = AlignUpPow2(block->pos, align);
     }
 
     U32 end_pos = start_pos + size;
-    Assert(end_pos <= current->size);
+    Assert(end_pos <= block->size);
 
-    U8 *mem     = &current->base[start_pos];
-    current->pos  = end_pos;
+    U8 *mem     = &block->base[start_pos];
+    block->pos  = end_pos;
 
     ASAN_UNPOISON_MEMORY_REGION(mem, size);
     return mem;
@@ -82,34 +80,35 @@ void *arena_push(Arena *arena, U32 size, U32 align)
 
 void arena_pop_to(Arena *arena, U32 abs_pos)
 {
-    Arena *current = arena->current;
-    abs_pos = Max(ARENA_HEADER_SZ, abs_pos);
-    while (current) {
-        Arena *prev = current->prev;
+    MemoryBlock *block = arena->current;
+    abs_pos = Max(MemoryBlock_Header_Size, abs_pos);
+    while (block) {
+        MemoryBlock *prev = block->prev;
 
-        if (current->base_pos >= abs_pos) {
-            ASAN_UNPOISON_MEMORY_REGION(current->base, current->size); // needed as we use malloc
-            memory_free(current->base, current->size);
+        if (block->base_pos >= abs_pos) {
+            ASAN_UNPOISON_MEMORY_REGION(block->base, block->size);
+            memory_free(block->base, block->size);
             arena->current = prev;
         } else {
-            U32 new_pos = abs_pos - current->base_pos;
+            U32 new_pos = abs_pos - block->base_pos;
+            new_pos = Max(MemoryBlock_Header_Size, new_pos);
             // Note, when doing commit/release, new_pos <= current->pos
             // is the right thing . shouldn't be able to pop to larger than what's already commited
-            Assert(new_pos <= current->size);
-            current->pos = new_pos;
-            ASAN_POISON_MEMORY_REGION(&current->base[current->pos], arena_available(arena));
+            Assert(new_pos <= block->size);
+            block->pos = new_pos;
+            ASAN_POISON_MEMORY_REGION(&block->base[block->pos], memoryblock_available(block));
             break;
         }
 
-        current = prev;
+        block = prev;
     }
 }
 
 ArenaCheckPoint arena_temp_begin(Arena *arena)
 {
     ArenaCheckPoint checkpoint = {};
-    checkpoint.arena = arena;
-    checkpoint.absolute_pos = arena_absolute_pos(arena);
+    checkpoint.arena           = arena;
+    checkpoint.absolute_pos    = arena_used(arena);
     arena->checkpoint_level++;
 
     return checkpoint;
diff --git a/src/arena.h b/src/arena.h
index 5e9e9b1..8231515 100644
--- a/src/arena.h
+++ b/src/arena.h
@@ -10,15 +10,20 @@ struct ArenaParams {
     ArenaFlags flags; // No flags defined yet
 };
 
-typedef struct Arena Arena;
-struct Arena {
-    Arena *current;
+typedef struct MemoryBlock MemoryBlock;
+struct MemoryBlock {
     U8 *base;
     U32 size;
-    U32 pos;          // start of next allocation
     U32 base_pos;     // absolute position of base relative to the first linked arena
+    U32 pos;          // start of next allocation
+    MemoryBlock *prev;
+};
+
+typedef struct Arena Arena;
+struct Arena {
+    MemoryBlock *current;
+    U32 requested_size;
     ArenaFlags flags;
-    Arena *prev;
     S32 checkpoint_level;
 };
 
@@ -28,16 +33,13 @@ struct ArenaCheckPoint {
     U32 absolute_pos;
 };
 
-StaticAssert(sizeof(Arena) <= 64);
-#define ARENA_HEADER_SZ 64u
+StaticAssert(sizeof(MemoryBlock) <= 64);
+#define MemoryBlock_Header_Size 64u
 
 
-static INLINE U32 arena_available(const Arena *arena)
-{
-    return arena->size - arena->pos;
-}
 
-Arena *arena_alloc(const ArenaParams *params);
+void arena_init(Arena *arena, const ArenaParams *params);
+
 void arena_free(Arena *arena);
 void *arena_push(Arena *arena, U32 size, U32 align);
 
@@ -48,3 +50,15 @@ ArenaCheckPoint arena_temp_begin(Arena *arena);
 void arena_temp_end(ArenaCheckPoint *checkpoint);
 void arena_pop_to(Arena *arena, U32 abs_pos);
 void arena_reset(Arena *arena);
+MemoryBlock *memoryblock_allocate(size_t size);
+
+static INLINE U32 memoryblock_available(const MemoryBlock *block)
+{
+    return block->size - block->pos;
+}
+
+static INLINE U32 arena_used(const Arena *arena)
+{
+    const MemoryBlock *block = arena->current;
+    return block->base_pos + block->pos;
+}
diff --git a/src/main.c b/src/main.c
index 7c4c3df..83ef671 100644
--- a/src/main.c
+++ b/src/main.c
@@ -5,76 +5,79 @@
 
 void arena_dump(const Arena *arena)
 {
-    arena = arena->current;
+    MemoryBlock *block = arena->current;
     puts("@@@@@@@@@@");
-    while (arena) {
+    while (block) {
         puts("-----Arena-----");
-        printf("base:        %p\n", arena->base);
-        printf("size:        %u\n", arena->size);
-        printf("pos:         %u\n", arena->pos);
-        printf("base_pos:    %u\n", arena->base_pos);
-        printf("prev: %p\n", arena->prev);
+        printf("base:        %p\n", block->base);
+        printf("size:        %u\n", block->size);
+        printf("pos:         %u\n", block->pos);
+        printf("base_pos:    %u\n", block->base_pos);
+        printf("prev: %p\n", block->prev);
         puts("-----Arena  end-");
-        arena = arena->prev;
+        block = block->prev;
     }
 }
 static void arena_test_1(void)
 {
     ArenaParams arena_params = {};
-    arena_params.size = 1024+ARENA_HEADER_SZ;
-    Arena *arena = arena_alloc(&arena_params);
-    arena_dump(arena);
-    void *ptr = arena_push(arena, 512, 1);
+    arena_params.size = 1024+MemoryBlock_Header_Size;
+    Arena arena;
+    arena_init(&arena, &arena_params);
+    arena_dump(&arena);
+    void *ptr = arena_push(&arena, 512, 1);
     MemoryZero(ptr, 512);
     printf("Allocated ptr %p\n", ptr);
-    arena_dump(arena);
-    ptr = arena_push(arena, 512, 1);
+    arena_dump(&arena);
+    ptr = arena_push(&arena, 512, 1);
     MemoryZero(ptr, 512);
     printf("Allocated ptr %p\n", ptr);
-    arena_dump(arena);
+    arena_dump(&arena);
 
-    ptr = arena_push(arena, 1, 1);
+    ptr = arena_push(&arena, 1, 1);
     MemoryZero(ptr, 1);
     printf("Allocated ptr %p\n", ptr);
-    arena_dump(arena);
-    arena_free(arena);
+    arena_dump(&arena);
+    arena_free(&arena);
 }
 static void arena_test_2(void)
 {
     ArenaParams arena_params = {};
-    arena_params.size = 1024+ARENA_HEADER_SZ;
-    Arena *arena = arena_alloc(&arena_params);
+    arena_params.size = 1024+MemoryBlock_Header_Size;
+    Arena arena;
+    arena_init(&arena, &arena_params);
 
     void *ptr;
-    ptr = arena_push(arena, 1024, 8);
+    ptr = arena_push(&arena, 1024, 8);
     MemoryZero(ptr, 1024);
     printf("Allocated ptr %p\n", ptr);
 
-    arena_dump(arena);
-    ArenaCheckPoint checkpoint = arena_temp_begin(arena);
-    ptr = arena_push(arena, 4096, 8);
+    arena_dump(&arena);
+    ArenaCheckPoint checkpoint = arena_temp_begin(&arena);
+    ptr = arena_push(&arena, 4096, 8);
     MemoryZero(ptr, 4096);
 
-    ptr = arena_push(arena, 4096, 8);
+    ptr = arena_push(&arena, 4096, 8);
     MemoryZero(ptr, 4096);
 
-    ArenaCheckPoint checkpoint2 = arena_temp_begin(arena);
-    ptr = arena_push(arena, 64, 8);
+    ArenaCheckPoint checkpoint2 = arena_temp_begin(&arena);
+    ptr = arena_push(&arena, 64, 8);
     MemoryZero(ptr, 64);
 
     arena_temp_end(&checkpoint2);
 
     arena_temp_end(&checkpoint);
-    arena_pop_to(arena, 1088);
-    arena_dump(arena);
-    ptr = arena_push(arena, 1, 1);
+    arena_pop_to(&arena, 1088);
+    arena_dump(&arena);
+    ptr = arena_push(&arena, 1, 1);
     ((U8*)ptr)[0] = 0x37;
-    ptr = arena_push(arena, 1, 1);
+    ptr = arena_push(&arena, 1, 1);
     ((U8*)ptr)[0] = 0x73;
-    arena_pop_to(arena, 1089);
-    arena_dump(arena);
+    arena_pop_to(&arena, 1089);
+    arena_dump(&arena);
+    arena_pop_to(&arena, 0);
 
-    arena_free(arena);
+    arena_free(&arena);
 }
 
 int main(int argc, char *argv[])
diff --git a/src/platform.c b/src/platform.c
index a6ae6f7..aadb494 100644
--- a/src/platform.c
+++ b/src/platform.c
@@ -10,25 +10,25 @@ U32 platform_page_size(void)
     return getpagesize();
 }
 
-static INLINE size_t AlignToPageSize(size_t sz)
+static INLINE size_t AlignToPageSize(size_t size)
 {
     U32 page_size = platform_page_size();
-    size_t aligned_sz = AlignUpPow2(sz, page_size);
+    size_t aligned_size = AlignUpPow2(size, page_size);
 
-    return aligned_sz;
+    return aligned_size;
 }
 
-static INLINE size_t AlignToPageStart(size_t sz)
+static INLINE size_t AlignToPageStart(size_t size)
 {
     U32 page_size = platform_page_size();
-    size_t aligned_sz = AlignDownPow2(sz, page_size);
+    size_t aligned_size = AlignDownPow2(size, page_size);
 
-    return aligned_sz;
+    return aligned_size;
 }
 
-void *platform_malloc(size_t sz)
+void *platform_malloc(size_t size)
 {
-    return malloc(sz);
+    return malloc(size);
 }
 
 void platform_free(void *mem)
@@ -37,53 +37,53 @@ void platform_free(void *mem)
 }
 
 
-void *memory_allocate(size_t sz)
+void *memory_allocate(size_t size)
 {
-    if (sz == 0) {
-        sz = 1;
+    if (size == 0) {
+        size = 1;
     }
 
-    size_t aligned_sz = AlignToPageSize(sz);
-    void *mem = mmap(0, aligned_sz, PROT_READ | PROT_WRITE, MAP_ANONYMOUS  | MAP_PRIVATE, -1, 0);
-    TRACEF("memory_allocate size=%zu aligned_size=%zu mem=%p\n", sz, aligned_sz, mem);
+    size_t aligned_size = AlignToPageSize(size);
+    void *mem = mmap(0, aligned_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS  | MAP_PRIVATE, -1, 0);
+    TRACEF("memory_allocate size=%zu aligned_size=%zu mem=%p\n", size, aligned_size, mem);
     if (mem == MAP_FAILED) {
         mem = NULL;
     }
     return mem;
 }
 
-void memory_free(void *mem, size_t sz)
+void memory_free(void *mem, size_t size)
 {
-    size_t aligned_sz = AlignToPageSize(sz);
-    TRACEF("        memory_free     size=%zu aligned_size=%zu mem=%p\n", sz, aligned_sz, mem);
+    size_t aligned_size = AlignToPageSize(size);
+    TRACEF("        memory_free     size=%zu aligned_size=%zu mem=%p\n", size, aligned_size, mem);
 
-    int rc = munmap(mem, aligned_sz);
+    int rc = munmap(mem, aligned_size);
 
     Assert(rc == 0);
 }
 
-void memory_commit(void *mem, size_t sz)
+void memory_commit(void *mem, size_t size)
 {
-    size_t aligned_sz = AlignToPageSize(sz);
+    size_t aligned_size = AlignToPageSize(size);
     void *aligned_mem = (void *)AlignToPageStart((uintptr_t)mem);
-    TRACEF("memory_commit size=%zu aligned_size=%zu ptr=%p aligned_mem=%p\n", sz, aligned_sz, mem, aligned_mem);
+    TRACEF("memory_commit size=%zu aligned_size=%zu ptr=%p aligned_mem=%p\n", size, aligned_size, mem, aligned_mem);
 
     int rc;
-    rc = mprotect(aligned_mem, aligned_sz, PROT_READ | PROT_WRITE);
+    rc = mprotect(aligned_mem, aligned_size, PROT_READ | PROT_WRITE);
     Assert(rc == 0);
-    rc = madvise(aligned_mem, aligned_sz, MADV_WILLNEED);
+    rc = madvise(aligned_mem, aligned_size, MADV_WILLNEED);
     Assert(rc == 0);
 }
 
-void memory_decommit(void *mem, size_t sz)
+void memory_decommit(void *mem, size_t size)
 {
-    size_t aligned_sz = AlignToPageSize(sz);
+    size_t aligned_size = AlignToPageSize(size);
     void *aligned_mem = (void *)AlignToPageStart((uintptr_t)mem);
-    TRACEF("memory_commit size=%zu aligned_size=%zu ptr=%p aligned_mem=%p\n", sz, aligned_sz, mem, aligned_mem);
+    TRACEF("memory_commit size=%zu aligned_size=%zu ptr=%p aligned_mem=%p\n", size, aligned_size, mem, aligned_mem);
 
     int rc;
-    rc = mprotect(aligned_mem, aligned_sz, PROT_NONE);
+    rc = mprotect(aligned_mem, aligned_size, PROT_NONE);
     Assert(rc == 0);
-    rc = madvise(aligned_mem, aligned_sz, MADV_DONTNEED);
+    rc = madvise(aligned_mem, aligned_size, MADV_DONTNEED);
     Assert(rc == 0);
 }
diff --git a/src/platform.h b/src/platform.h
index b693abe..574ca04 100644
--- a/src/platform.h
+++ b/src/platform.h
@@ -1,10 +1,10 @@
 #pragma once
 #include <stdlib.h>
 
-void *platform_malloc(size_t sz);
+void *platform_malloc(size_t size);
 void platform_free(void *mem);
 U32 platform_page_size(void);
 
-void *memory_allocate(size_t sz);
-void *memory_free(void *mem, size_t sz);
+void *memory_allocate(size_t size);
+void *memory_free(void *mem, size_t size);