diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5feca07..1cffde7 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -33,7 +33,7 @@ include(FetchContent)
 FetchContent_Declare(
     snlogger
     GIT_REPOSITORY https://github.com/kshku/SnLogger.git
-    GIT_TAG v0.1.0
+    GIT_TAG v0.2.0
 )
 FetchContent_MakeAvailable(snlogger)
 
@@ -47,10 +47,17 @@ FetchContent_MakeAvailable(snfile)
 FetchContent_Declare(
     snmemory
     GIT_REPOSITORY https://github.com/kshku/SnMemory.git
+    GIT_TAG v0.2.0
+)
+
+FetchContent_Declare(
+    sncontainer
+    GIT_REPOSITORY https://github.com/kshku/SnContainer.git
     GIT_TAG v0.1.0
 )
+FetchContent_MakeAvailable(sncontainer)
 
-target_link_libraries(snuk_configs INTERFACE snlogger snfile snmemory)
+target_link_libraries(snuk_configs INTERFACE snlogger snfile snmemory sncontainer)
 
 add_subdirectory(docs)
 add_subdirectory(src)
diff --git a/include/snuk/darray.h b/include/snuk/darray.h
deleted file mode 100644
index eb9f7c9..0000000
--- a/include/snuk/darray.h
+++ /dev/null
@@ -1,144 +0,0 @@
-#pragma once
-
-#include "defines.h"
-#include "memory.h"
-
-#define SNUK_DARRAY_DEFAULT_CAPACITY 5
-#define SNUK_DARRAY_RESIZE_FACTOR 2
-
-SNUK_STATIC_ASSERT(sizeof(uint64_t) == sizeof(void *), "size of pointer != size of uint64_t");
-
-typedef enum SnukDArrayHeader {
-    SNUK_DARRAY_CAPACITY,
-    SNUK_DARRAY_SIZE,
-    SNUK_DARRAY_STRIDE,
-    SNUK_DARRAY_ALIGN,
-    SNUK_DARRAY_ALLOCATOR,
-
-    SNUK_DARRAY_MAX_FIELDS,
-} SnukDArrayHeader;
-
-SNUK_API void *
-    impl_snuk_darray_create(uint64_t capacity, uint64_t stride, uint64_t align, SnukAllocator *allocator);
-
-SNUK_API void impl_snuk_darray_destroy(void *arr);
-
-SNUK_API void impl_snuk_darray_resize(void **parr, uint64_t capacity);
-
-SNUK_API uint64_t impl_snuk_darray_header(void *arr, SnukDArrayHeader header);
-
-SNUK_API void impl_snuk_darray_push(void **parr, void *element);
-
-SNUK_API void impl_snuk_darray_push_at(void **parr, uint64_t index, void *element);
-
-SNUK_API void impl_snuk_darray_pop(void **parr, void *element);
-
-SNUK_API void impl_snuk_darray_pop_at(void **parr, uint64_t index, void *element);
-
-SNUK_API void impl_snuk_darray_clear(void **parr);
-
-/**
- * @brief Create darray with given type and capacity.
- *
- * @param capacity The initial capacity of the array
- * @param type Type of the element
- * @param allocator The allocator to use (if NULL snuk_global allocator is used)
- *
- * @return The array or NULL on failure.
- */
-#define snuk_darray_create_with_capacity(capacity, type, allocator)                   \
-    (type *)impl_snuk_darray_create(capacity, sizeof(type), alignof(type), allocator)
-
-/**
- * @brief Create a darray of given type.
- *
- * @param type Type of the elements of the array
- * @param allocator The allocator to use (if NULL snuk_global allocator is used)
- *
- * @return The array or NULL on failure.
- */
-#define snuk_darray_create(type, allocator)                                         \
-    snuk_darray_create_with_capacity(SNUK_DARRAY_DEFAULT_CAPACITY, type, allocator)
-
-/**
- * @brief Destroy the darray.
- *
- * @param parr The array
- */
-#define snuk_darray_destroy(arr) impl_snuk_darray_destroy(arr)
-
-/**
- * @brief Resize the darray to given capacity.
- *
- * @param parr Pointer to the array
- * @param capacity The new capacity (number of elements)
- */
-#define snuk_darray_resize(parr, capacity) impl_snuk_darray_resize((void **)parr, capacity)
-
-/**
- * @brief Get the length of the darray (number of elements).
- *
- * @param arr The array
- *
- * @return The length of the array.
- */
-#define snuk_darray_get_length(arr) impl_snuk_darray_header(arr, SNUK_DARRAY_SIZE)
-
-/**
- * @brief Get the current capacity of the darray.
- *
- * Returns the number of elements it can hold before resizing.
- *
- * @param arr The array
- *
- * @return The capacity of the array.
- */
-#define snuk_darray_get_capacity(arr) impl_snuk_darray_header(arr, SNUK_DARRAY_CAPACITY)
-
-/**
- * @brief Clear the darray.
- *
- * Just sets the length of the array to zero. The elements should be considered
- * garbage values.
- *
- * @param parr Pointer to the array
- */
-#define snuk_darray_clear(parr) impl_snuk_darray_clear((void **)parr)
-
-/**
- * @brief Push the given element to the end of the array.
- *
- * @param parr Pointer to the array
- * @param element The element
- * @param res Result
- */
-#define snuk_darray_push(parr, element)                                    \
-    impl_snuk_darray_push((void **)parr, (__typeof__(element)[]){element})
-
-/**
- * @brief Pop the element from the end of the array.
- *
- * @param parr Pointer to the array
- * @param element Pointer to store poped element (can be NULL)
- */
-#define snuk_darray_pop(parr, element) impl_snuk_darray_pop((void **)parr, element)
-
-/**
- * @brief Push the element to given index of the array.
- *
- * @param parr Pointer to the array
- * @param index Index to insert the element to
- * @param element The element to insert
- */
-#define snuk_darray_push_at(parr, index, element)                                    \
-    impl_snuk_darray_push_at((void **)parr, index, (__typeof__(element)[]){element})
-
-/**
- * @brief Pop the element at given index of the array.
- *
- * @param parr Pointer to the array
- * @param index Index to pop the element
- * @param element Pointer to store element (can be NULL)
- */
-#define snuk_darray_pop_at(parr, index, element)           \
-    impl_snuk_darray_pop_at((void **)parr, index, element)
diff --git a/include/snuk/interpreter/interpreter.h b/include/snuk/interpreter/interpreter.h
index 2c6433a..3d43b15 100644
--- a/include/snuk/interpreter/interpreter.h
+++ b/include/snuk/interpreter/interpreter.h
@@ -31,7 +31,7 @@ typedef struct SnukInterpreter {
     SnukValue *trash;
     SnukSignal signal;
     void *mem;
-    SnukAllocator allocator;
+    SnMemoryAllocator allocator;
     SnLinearAllocator la;
     SnukError err;
     SnukSrcLoc cur_loc;
diff --git a/include/snuk/interpreter/interpreter_helper.h b/include/snuk/interpreter/interpreter_helper.h
index d2a7c62..34fd0d5 100644
--- a/include/snuk/interpreter/interpreter_helper.h
+++ b/include/snuk/interpreter/interpreter_helper.h
@@ -1,11 +1,11 @@
 #pragma once
 
 #include "interpreter.h"
-#include "snuk/darray.h"
 #include "snuk/defines.h"
 #include "snuk/snuk_error.h"
 #include "snuk_scope.h"
 
+#include <sncontainer/darray.h>
 #include <stdarg.h>
 #include <stdio.h>
 
@@ -164,11 +164,11 @@ SNUK_INLINE SnukEnv *interpreter_lookup(
 }
 
 SNUK_INLINE void interpreter_trash(SnukInterpreter *intpret, SnukValue value) {
-    snuk_darray_push(&intpret->trash, value);
+    sn_darray_push(&intpret->trash, value);
 }
 
 SNUK_INLINE void interpreter_clear_trash(SnukInterpreter *intpret) {
-    uint64_t count = snuk_darray_get_length(intpret->trash);
+    uint64_t count = sn_darray_get_length(intpret->trash);
     for (uint64_t i = 0; i < count; ++i) snuk_value_free(intpret->trash[i]);
-    snuk_darray_clear(&intpret->trash);
+    sn_darray_clear(&intpret->trash);
 }
diff --git a/include/snuk/interpreter/snuk_env.h b/include/snuk/interpreter/snuk_env.h
index 0f8efc3..8db9ad4 100644
--- a/include/snuk/interpreter/snuk_env.h
+++ b/include/snuk/interpreter/snuk_env.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "snuk/darray.h"
 #include "snuk/defines.h"
 #include "snuk/parser/snuk_type.h"
 #include "snuk/string_view.h"
diff --git a/include/snuk/interpreter/snuk_scope.h b/include/snuk/interpreter/snuk_scope.h
index 490ffca..7088f22 100644
--- a/include/snuk/interpreter/snuk_scope.h
+++ b/include/snuk/interpreter/snuk_scope.h
@@ -1,9 +1,12 @@
 #pragma once
 
 #include "snuk/defines.h"
+#include "snuk/memory.h"
 #include "snuk/refcount.h"
 #include "snuk_env.h"
 
+#include <sncontainer/darray.h>
+
 extern uint64_t snuk_scope_seq;
 #define GET_SCOPE(rc) ((SnukScope *)snuk_ref_counter_get(rc))
 #define SCOPE_PARENT(rc) (GET_SCOPE(rc)->parent)
@@ -24,9 +27,9 @@ struct SnukScope {
 };
 
 SNUK_INLINE void snuk_scope_destroy_envs(SnukScope *scope) {
-    uint64_t count = snuk_darray_get_length(scope->vars);
+    uint64_t count = sn_darray_get_length(scope->vars);
     for (uint64_t i = 0; i < count; ++i) snuk_env_free(scope->vars[i]);
-    snuk_darray_clear(&scope->vars);
+    sn_darray_clear(&scope->vars);
 }
 
 /**
@@ -47,7 +50,7 @@ SNUK_INLINE void snuk_scope_destroy(void *data, void *ptr) {
     log_debug("scope destroyed (scope=%p)", ptr);
     snuk_scope_destroy_envs(scope);
 
-    snuk_darray_destroy(scope->vars);
+    sn_darray_destroy(scope->vars);
 
     if (scope->parent) {
         if (scope->weak_ref) snuk_ref_counter_release_weak(&scope->parent);
@@ -72,7 +75,7 @@ SNUK_INLINE SnukRefCounter *snuk_scope_create(SnukRefCounter *parent, bool weak_
     SnukScope *scope = (SnukScope *)snuk_alloc(sizeof(SnukScope), alignof(SnukScope));
     uint64_t seq = ++snuk_scope_seq;
     *scope = (SnukScope){
-        .vars = snuk_darray_create(SnukEnv *, NULL),
+        .vars = sn_darray_create(SnukEnv *, &snuk_global_allocator),
         .parent = snuk_ref_counter_move(&parent),
         .weak_ref = weak_ref,
         .locked = locked,
@@ -113,7 +116,7 @@ SNUK_INLINE void snuk_scope_set_parent(SnukRefCounter *scope_rc, SnukRefCounter
 SNUK_INLINE SnukEnv *snuk_scope_lookup(SnukRefCounter *scope_rc, SnukStringView name, bool *locked) {
     SnukScope *scope = GET_SCOPE(scope_rc);
     if (locked) *locked = scope->locked;
-    uint64_t count = snuk_darray_get_length(scope->vars);
+    uint64_t count = sn_darray_get_length(scope->vars);
     for (uint64_t i = 0; i < count; ++i)
         if (snuk_string_view_equal(scope->vars[i]->name, name)) return scope->vars[i];
 
@@ -139,17 +142,17 @@ SNUK_INLINE bool snuk_scope_add_env(SnukRefCounter *scope_rc, SnukEnv *env) {
         snuk_env_free(env);
         return false;
     }
-    snuk_darray_push(&scope->vars, env);
+    sn_darray_push(&scope->vars, env);
     return true;
 }
 
 SNUK_INLINE void snuk_scope_remove_env(SnukRefCounter *scope_rc, SnukStringView name) {
     SnukScope *scope = GET_SCOPE(scope_rc);
-    uint64_t count = snuk_darray_get_length(scope->vars);
+    uint64_t count = sn_darray_get_length(scope->vars);
     for (uint64_t i = 0; i < count; ++i) {
         if (snuk_string_view_equal(scope->vars[i]->name, name)) {
             SnukEnv *env = NULL;
-            snuk_darray_pop_at(&scope->vars, i, &env);
+            sn_darray_pop_at(&scope->vars, i, &env);
             snuk_env_free(env);
             return;
         }
diff --git a/include/snuk/memory.h b/include/snuk/memory.h
index 2553bc5..a744695 100644
--- a/include/snuk/memory.h
+++ b/include/snuk/memory.h
@@ -8,13 +8,6 @@
 #define MIB(x) (KIB((x) * 1024))
 #define GIB(x) (MIB((x) * 1024))
 
-typedef struct SnukAllocator {
-    void *data;
-    void *(*alloc)(void *data, uint64_t size, uint64_t align);
-    void *(*realloc)(void *data, void *ptr, uint64_t new_size, uint64_t align);
-    void (*free)(void *data, void *ptr);
-} SnukAllocator;
-
 /**
  * @brief Retrieves the system page size.
  *
@@ -98,4 +91,4 @@ SNUK_API void *snuk_realloc(void *ptr, uint64_t new_size, uint64_t align);
  */
 SNUK_API void snuk_free(void *ptr);
 
-extern SnukAllocator snuk_global_allocator;
+extern SnMemoryAllocator snuk_global_allocator;
diff --git a/include/snuk/parser/parser.h b/include/snuk/parser/parser.h
index 6121bec..768b65b 100644
--- a/include/snuk/parser/parser.h
+++ b/include/snuk/parser/parser.h
@@ -30,7 +30,7 @@ typedef struct SnukParser {
     SnukToken current; /**< Current token. */
     SnukToken next; /**< Next token. */
 
-    SnukAllocator *allocator;
+    SnMemoryAllocator *allocator;
 
     bool panic_mode; /**< Error and recovery state flags. */
     SnukError err;
@@ -50,7 +50,7 @@ typedef struct SnukParser {
  * @note The source text must remain valid for the lifetime of parsed nodes that
  * reference token text.
  */
-SNUK_API void snuk_parser_init(SnukParser *parser, const char *src, SnukAllocator *allocator);
+SNUK_API void snuk_parser_init(SnukParser *parser, const char *src, SnMemoryAllocator *allocator);
 
 /**
  * @brief Deinitialize a parser context.
diff --git a/include/snuk/parser/snuk_expr.h b/include/snuk/parser/snuk_expr.h
index 09d66af..a5875ef 100644
--- a/include/snuk/parser/snuk_expr.h
+++ b/include/snuk/parser/snuk_expr.h
@@ -1,10 +1,11 @@
 #pragma once
 
 #include "parser_common.h"
-#include "snuk/darray.h"
 #include "snuk/defines.h"
 #include "snuk/string_view.h"
 
+#include <sncontainer/darray.h>
+
 /**
  * @brief Parser expression node kinds.
  */
@@ -501,10 +502,10 @@ SNUK_INLINE SnukExpr *build_block_expr(SnukParser *parser, SnukExpr *expr, SnukI
         expr = parser_create_expr(parser);
         *expr = (SnukExpr){
             .type = SNUK_EXPR_BLOCK,
-            .block_items = snuk_darray_create(SnukItem *, parser->allocator),
+            .block_items = sn_darray_create(SnukItem *, parser->allocator),
         };
     }
-    if (item) snuk_darray_push(&expr->block_items, item);
+    if (item) sn_darray_push(&expr->block_items, item);
     return expr;
 }
 
diff --git a/include/snuk/parser/snuk_item.h b/include/snuk/parser/snuk_item.h
index 14d1900..39d13ed 100644
--- a/include/snuk/parser/snuk_item.h
+++ b/include/snuk/parser/snuk_item.h
@@ -1,12 +1,13 @@
 #pragma once
 
 #include "parser_common.h"
-#include "snuk/darray.h"
 #include "snuk/defines.h"
 #include "snuk/snuk_error.h"
 #include "snuk/string_view.h"
 #include "snuk_type.h"
 
+#include <sncontainer/darray.h>
+
 /**
  * @brief Parser items kinds.
  */
@@ -161,10 +162,10 @@ SNUK_INLINE SnukItem *build_print_item(SnukParser *parser, SnukItem *item, SnukE
         item = parser_create_item(parser);
         *item = (SnukItem){
             .type = SNUK_ITEM_PRINT,
-            .print_exprs = snuk_darray_create(SnukExpr *, parser->allocator),
+            .print_exprs = sn_darray_create(SnukExpr *, parser->allocator),
         };
     }
-    if (expr) snuk_darray_push(&item->print_exprs, expr);
+    if (expr) sn_darray_push(&item->print_exprs, expr);
     return item;
 }
 
@@ -182,12 +183,12 @@ SNUK_INLINE SnukItem *build_extend_item(SnukParser *parser, SnukItem *item, Snuk
         *item = (SnukItem){
             .type = SNUK_ITEM_EXTEND,
             .extend_item = {
-                .members = snuk_darray_create(SnukItem *, parser->allocator),
+                .members = sn_darray_create(SnukItem *, parser->allocator),
             },
         };
     }
     if (type) item->extend_item.type = type;
-    if (member) snuk_darray_push(&item->extend_item.members, member);
+    if (member) sn_darray_push(&item->extend_item.members, member);
     return item;
 }
 
diff --git a/include/snuk/parser/snuk_type.h b/include/snuk/parser/snuk_type.h
index 8309d65..bf539c5 100644
--- a/include/snuk/parser/snuk_type.h
+++ b/include/snuk/parser/snuk_type.h
@@ -1,10 +1,11 @@
 #pragma once
 
 #include "parser_common.h"
-#include "snuk/darray.h"
 #include "snuk/defines.h"
 #include "snuk/string_view.h"
 
+#include <sncontainer/darray.h>
+
 /**
  * @brief Parsed type.
  */
@@ -108,10 +109,10 @@ SNUK_INLINE SnukType *build_fn_type(SnukParser *parser, SnukType *type, SnukType
         type = parser_create_type(parser);
         *type = (SnukType){
             .type = TYPE_FN,
-            .fn = {.param_types = snuk_darray_create(SnukType *, parser->allocator)},
+            .fn = {.param_types = sn_darray_create(SnukType *, parser->allocator)},
         };
     }
-    if (param) snuk_darray_push(&type->fn.param_types, param);
+    if (param) sn_darray_push(&type->fn.param_types, param);
     if (ret) type->fn.return_type = ret;
     return type;
 }
@@ -121,11 +122,11 @@ SNUK_INLINE SnukType *build_interface_type(SnukParser *parser, SnukType *type, S
         type = parser_create_type(parser);
         *type = (SnukType){
             .type = TYPE_INTERFACE,
-            .members = snuk_darray_create(SnukVar *, parser->allocator),
+            .members = sn_darray_create(SnukVar *, parser->allocator),
         };
     }
 
-    if (member) snuk_darray_push(&type->members, member);
+    if (member) sn_darray_push(&type->members, member);
 
     return type;
 }
diff --git a/repl/runtime.h b/repl/runtime.h
index 96f8653..222ea84 100644
--- a/repl/runtime.h
+++ b/repl/runtime.h
@@ -12,7 +12,7 @@ typedef struct Runtime {
     void *mem;
     SnLinearAllocator la;
     SnukInterpreter interpreter;
-    SnukAllocator parser_allocator;
+    SnMemoryAllocator parser_allocator;
 } Runtime;
 
 SNUK_INLINE void *runtime_alloc_fn(void *data, uint64_t size, uint64_t align) {
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 7285b56..9f6adfc 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -16,7 +16,6 @@ set(PUBLIC_HEADERS
     io.h
     snuk_string.h
     lexer.h
-    darray.h
 )
 
 set(HEADERS
@@ -27,7 +26,6 @@ set(SRCS
     memory.c
     io.c
     lexer.c
-    darray.c
 )
 
 set(INCLUDE_BASE "${PROJECT_SOURCE_DIR}/include/snuk")
diff --git a/src/darray.c b/src/darray.c
deleted file mode 100644
index 455f0f5..0000000
--- a/src/darray.c
+++ /dev/null
@@ -1,207 +0,0 @@
-#include "snuk/darray.h"
-
-#include <stdlib.h>
-#include <string.h>
-
-#define HEADER_SIZE (sizeof(uint64_t) * SNUK_DARRAY_MAX_FIELDS)
-
-SNUK_INLINE void write_to_bytes(void *ptr, uint64_t value, bool reverse) {
-    uint8_t *p = (uint8_t *)ptr;
-    uint8_t inc = reverse ? -1 : 1;
-    do {
-        *p = value % 0x80;
-        value >>= 7;
-        if (!value) return;
-        *p |= 0x80;
-        p += inc;
-    } while (value);
-}
-
-SNUK_INLINE uint64_t read_from_bytes(void *ptr, bool reverse) {
-    uint8_t *p = (uint8_t *)ptr;
-    uint8_t inc = reverse ? -1 : 1;
-    uint64_t value = 0;
-    uint64_t i = 0;
-
-    while (*p & 0x80) {
-        value |= (uint64_t)(*p & ~0x80) << i;
-        i += 7;
-        p += inc;
-    }
-
-    value |= (uint64_t)(*p) << i;
-
-    return value;
-}
-
-#define ALIGN_BYTE(ptr) ((void *)((uint64_t)(ptr) - 1))
-#define GET_ALIGN_SHIFT(ptr) (read_from_bytes((void *)((uint64_t)(ptr) - 1), true))
-#define SET_ALIGN_SHIFT(ptr, shift) (write_to_bytes((void *)((uint64_t)(ptr) - 1), (shift), true))
-#define GET_ALIGNED_NEXT(x, align) ((((uint64_t)(x)) + (align)) & ~((align) - 1))
-
-void *impl_snuk_darray_create(uint64_t capacity, uint64_t stride, uint64_t align, SnukAllocator *allocator) {
-    if (!allocator) allocator = &snuk_global_allocator;
-    uint64_t total = (capacity * stride) + HEADER_SIZE + align;
-    uint64_t *ptr = (uint64_t *)allocator->alloc(allocator->data, total, alignof(uint64_t));
-    memset(ptr, 0, total);
-    ptr[SNUK_DARRAY_CAPACITY] = capacity;
-    ptr[SNUK_DARRAY_SIZE] = 0;
-    ptr[SNUK_DARRAY_STRIDE] = stride;
-    ptr[SNUK_DARRAY_ALIGN] = align;
-    ptr[SNUK_DARRAY_ALLOCATOR] = (uint64_t)allocator;
-
-    ptr = (uint64_t *)((uint64_t)ptr + HEADER_SIZE);
-
-    uint64_t aligned = GET_ALIGNED_NEXT(ptr, align);
-    SET_ALIGN_SHIFT(aligned, (aligned - (uint64_t)ptr));
-
-    return (void *)aligned;
-}
-
-void impl_snuk_darray_destroy(void *arr) {
-    uint64_t ptr = (uint64_t)arr;
-    ptr -= GET_ALIGN_SHIFT(ptr);
-    ptr -= HEADER_SIZE;
-    uint64_t *p = (uint64_t *)ptr;
-    SnukAllocator *allocator = (SnukAllocator *)p[SNUK_DARRAY_ALLOCATOR];
-    allocator->free(allocator->data, (void *)ptr);
-}
-
-void impl_snuk_darray_resize(void **parr, uint64_t capacity) {
-    uint64_t ptr = (uint64_t)(*parr);
-    uint64_t align_shift = GET_ALIGN_SHIFT(ptr);
-    ptr -= align_shift;
-    ptr -= HEADER_SIZE;
-
-    uint64_t *p = (uint64_t *)ptr;
-
-    SnukAllocator *allocator = (SnukAllocator *)p[SNUK_DARRAY_ALLOCATOR];
-    p = (uint64_t *)allocator->realloc(
-        allocator->data, p, (capacity * p[SNUK_DARRAY_STRIDE]) + HEADER_SIZE + p[SNUK_DARRAY_ALIGN],
-        alignof(uint64_t));
-
-    p[SNUK_DARRAY_CAPACITY] = capacity;
-
-    ptr = (uint64_t)p;
-    ptr += HEADER_SIZE;
-    ptr += align_shift;
-
-    *parr = (void *)ptr;
-}
-
-uint64_t impl_snuk_darray_header(void *arr, SnukDArrayHeader header) {
-    uint64_t ptr = (uint64_t)arr;
-    ptr -= GET_ALIGN_SHIFT(ptr);
-    ptr -= HEADER_SIZE;
-    return ((uint64_t *)ptr)[header];
-}
-
-void impl_snuk_darray_push(void **parr, void *element) {
-    uint64_t ptr = (uint64_t)(*parr);
-    uint64_t align_shift = GET_ALIGN_SHIFT(ptr);
-    ptr -= align_shift;
-    ptr -= HEADER_SIZE;
-    uint64_t *p = (uint64_t *)ptr;
-
-    if (p[SNUK_DARRAY_CAPACITY] <= p[SNUK_DARRAY_SIZE]) {
-        snuk_darray_resize(parr, p[SNUK_DARRAY_CAPACITY] * SNUK_DARRAY_RESIZE_FACTOR);
-        ptr = (uint64_t)(*parr);
-        ptr -= align_shift;
-        ptr -= HEADER_SIZE;
-        p = (uint64_t *)ptr;
-    }
-
-    void *dest = ((uint8_t *)*parr) + (p[SNUK_DARRAY_SIZE] * p[SNUK_DARRAY_STRIDE]);
-    memcpy(dest, element, p[SNUK_DARRAY_STRIDE]);
-    ++p[SNUK_DARRAY_SIZE];
-}
-
-void impl_snuk_darray_push_at(void **parr, uint64_t index, void *element) {
-    uint64_t ptr = (uint64_t)(*parr);
-    uint64_t align_shift = GET_ALIGN_SHIFT(ptr);
-    ptr -= align_shift;
-    ptr -= HEADER_SIZE;
-    uint64_t *p = (uint64_t *)ptr;
-
-    if (index > p[SNUK_DARRAY_SIZE]) {
-        if (p[SNUK_DARRAY_CAPACITY] <= index + 1) {
-            snuk_darray_resize(parr, index + 1);
-            ptr = (uint64_t)(*parr);
-            ptr -= align_shift;
-            ptr -= HEADER_SIZE;
-            p = (uint64_t *)ptr;
-        }
-
-        memset(((uint8_t *)*parr) + (p[SNUK_DARRAY_SIZE] * p[SNUK_DARRAY_STRIDE]), 0,
-               (index - p[SNUK_DARRAY_SIZE] * p[SNUK_DARRAY_STRIDE]));
-
-        void *dest = ((uint8_t *)*parr) + (index * p[SNUK_DARRAY_STRIDE]);
-        memcpy(dest, element, p[SNUK_DARRAY_STRIDE]);
-
-        p[SNUK_DARRAY_SIZE] = index + 1;
-
-        return;
-    }
-
-    if (p[SNUK_DARRAY_CAPACITY] <= p[SNUK_DARRAY_SIZE]) {
-        snuk_darray_resize(parr, p[SNUK_DARRAY_CAPACITY] * SNUK_DARRAY_RESIZE_FACTOR);
-        ptr = (uint64_t)(*parr);
-        ptr -= align_shift;
-        ptr -= HEADER_SIZE;
-        p = (uint64_t *)ptr;
-    }
-
-    void *dest = (uint8_t *)(*parr) + (p[SNUK_DARRAY_STRIDE] * (index + 1));
-    void *src = (uint8_t *)(*parr) + (p[SNUK_DARRAY_STRIDE] * (index));
-    uint64_t size = p[SNUK_DARRAY_STRIDE] * (p[SNUK_DARRAY_SIZE] - index);
-    memmove(dest, src, size);
-
-    dest = (uint8_t *)(*parr) + (index * p[SNUK_DARRAY_STRIDE]);
-    memcpy(dest, element, p[SNUK_DARRAY_STRIDE]);
-
-    ++p[SNUK_DARRAY_SIZE];
-}
-
-void impl_snuk_darray_pop(void **parr, void *element) {
-    uint64_t ptr = (uint64_t)(*parr);
-    ptr -= GET_ALIGN_SHIFT(ptr);
-    ptr -= HEADER_SIZE;
-    uint64_t *p = (uint64_t *)ptr;
-
-    if (p[SNUK_DARRAY_SIZE] == 0) return;
-
-    --p[SNUK_DARRAY_SIZE];
-
-    if (element) {
-        void *src = ((uint8_t *)*parr) + (p[SNUK_DARRAY_SIZE] * p[SNUK_DARRAY_STRIDE]);
-        memcpy(element, src, p[SNUK_DARRAY_STRIDE]);
-    }
-}
-
-void impl_snuk_darray_pop_at(void **parr, uint64_t index, void *element) {
-    uint64_t ptr = (uint64_t)(*parr);
-    uint64_t align_shift = GET_ALIGN_SHIFT(ptr);
-    ptr -= align_shift;
-    ptr -= HEADER_SIZE;
-    uint64_t *p = (uint64_t *)ptr;
-
-    SNUK_ASSERT(index < p[SNUK_DARRAY_SIZE], "index out of bound while poping element");
-
-    void *dest = ((uint8_t *)*parr) + (index * p[SNUK_DARRAY_STRIDE]);
-    void *src = ((uint8_t *)*parr) + ((index + 1) * p[SNUK_DARRAY_STRIDE]);
-    uint64_t size = (p[SNUK_DARRAY_SIZE] - index - 1) * p[SNUK_DARRAY_STRIDE];
-
-    if (element) memcpy(element, dest, p[SNUK_DARRAY_STRIDE]);
-    memmove(dest, src, size);
-
-    --p[SNUK_DARRAY_SIZE];
-}
-
-void impl_snuk_darray_clear(void **parr) {
-    uint64_t ptr = (uint64_t)(*parr);
-    ptr -= GET_ALIGN_SHIFT(ptr);
-    ptr -= HEADER_SIZE;
-    uint64_t *p = (uint64_t *)ptr;
-    p[SNUK_DARRAY_SIZE] = 0;
-}
-
diff --git a/src/interpreter/builtins/builtin_common.c b/src/interpreter/builtins/builtin_common.c
index dc2bd53..e60f320 100644
--- a/src/interpreter/builtins/builtin_common.c
+++ b/src/interpreter/builtins/builtin_common.c
@@ -43,20 +43,20 @@ SnukType str_get_type = {
 
 void snuk_builtins_init(SnukInterpreter *intpret) {
     if (!to_int_type.fn.param_types)
-        to_int_type.fn.param_types = snuk_darray_create_with_capacity(0, SnukType *, &intpret->allocator);
+        to_int_type.fn.param_types = sn_darray_create_with_capacity(0, SnukType *, &intpret->allocator);
     if (!to_float_type.fn.param_types)
-        to_float_type.fn.param_types = snuk_darray_create_with_capacity(0, SnukType *, &intpret->allocator);
+        to_float_type.fn.param_types = sn_darray_create_with_capacity(0, SnukType *, &intpret->allocator);
     if (!to_bool_type.fn.param_types)
-        to_bool_type.fn.param_types = snuk_darray_create_with_capacity(0, SnukType *, &intpret->allocator);
+        to_bool_type.fn.param_types = sn_darray_create_with_capacity(0, SnukType *, &intpret->allocator);
     if (!to_str_type.fn.param_types)
-        to_str_type.fn.param_types = snuk_darray_create_with_capacity(0, SnukType *, &intpret->allocator);
+        to_str_type.fn.param_types = sn_darray_create_with_capacity(0, SnukType *, &intpret->allocator);
 
     if (!str_length_type.fn.param_types)
-        str_length_type.fn.param_types = snuk_darray_create_with_capacity(0, SnukType *, &intpret->allocator);
+        str_length_type.fn.param_types = sn_darray_create_with_capacity(0, SnukType *, &intpret->allocator);
     if (!str_get_type.fn.param_types) {
-        str_get_type.fn.param_types = snuk_darray_create_with_capacity(2, SnukType *, &intpret->allocator);
-        snuk_darray_push(&str_get_type.fn.param_types, &int_type);
-        snuk_darray_push(&str_get_type.fn.param_types, &int_type);
+        str_get_type.fn.param_types = sn_darray_create_with_capacity(2, SnukType *, &intpret->allocator);
+        sn_darray_push(&str_get_type.fn.param_types, &int_type);
+        sn_darray_push(&str_get_type.fn.param_types, &int_type);
     }
 }
 
diff --git a/src/interpreter/builtins/builtin_common.h b/src/interpreter/builtins/builtin_common.h
index 8269106..68af1b4 100644
--- a/src/interpreter/builtins/builtin_common.h
+++ b/src/interpreter/builtins/builtin_common.h
@@ -1,12 +1,13 @@
 #pragma once
 
-#include "snuk/darray.h"
 #include "snuk/defines.h"
 #include "snuk/interpreter/builtins/snuk_builtins.h"
 #include "snuk/interpreter/native.h"
 #include "snuk/parser/snuk_type.h"
 #include "snuk/refcount.h"
 
+#include <sncontainer/darray.h>
+
 extern SnukType to_int_type;
 extern SnukType to_float_type;
 extern SnukType to_bool_type;
diff --git a/src/interpreter/interpreter.c b/src/interpreter/interpreter.c
index 9c1ebf3..53fa5fa 100644
--- a/src/interpreter/interpreter.c
+++ b/src/interpreter/interpreter.c
@@ -4,6 +4,7 @@
 #include "snuk/interpreter/interpreter_helper.h"
 #include "snuk/interpreter/snuk_scope.h"
 #include "snuk/io.h"
+#include "snuk/memory.h"
 #include "snuk/parser/snuk_var.h"
 
 #include <stdio.h>
@@ -57,7 +58,7 @@ void snuk_interpreter_init(SnukInterpreter *intpret) {
         .global = snuk_scope_create(NULL, false, false),
         .signal = SNUK_SIGNAL_NONE,
         .instance = NULL,
-        .trash = snuk_darray_create(SnukValue, NULL),
+        .trash = sn_darray_create(SnukValue, &snuk_global_allocator),
         .mem = snuk_allocate_pages(PAGES),
         .allocator = {
             .data = (void *)&intpret->la,
@@ -82,7 +83,7 @@ void snuk_interpreter_deinit(SnukInterpreter *intpret) {
     snuk_builtins_deinit(intpret);
 
     interpreter_clear_trash(intpret);
-    snuk_darray_destroy(intpret->trash);
+    sn_darray_destroy(intpret->trash);
 
     SNUK_ASSERT(!intpret->instance, "something went wrong");
 
@@ -134,7 +135,7 @@ bool snuk_interpreter_value_is_of_type(SnukInterpreter *intpret, SnukValue value
 
         if (value.type == SNUK_VALUE_TYPE || value.type == SNUK_VALUE_TYPE_INST) {
             SnukVar **members = type->members;
-            uint64_t count = snuk_darray_get_length(members);
+            uint64_t count = sn_darray_get_length(members);
             for (uint64_t i = 0; i < count; ++i) {
                 SnukEnv *member = snuk_scope_lookup(value.type_value.closure, members[i]->name, NULL);
                 if (!member && value.type_value.type_scope)
@@ -148,7 +149,7 @@ bool snuk_interpreter_value_is_of_type(SnukInterpreter *intpret, SnukValue value
         }
 
         SnukVar **members = type->members;
-        uint64_t count = snuk_darray_get_length(members);
+        uint64_t count = sn_darray_get_length(members);
         for (uint64_t i = 0; i < count; ++i) {
             SnukEnv *member = snuk_scope_lookup(value.type_value.closure, members[i]->name, NULL);
             if (!member && value.type_value.type_scope)
@@ -455,7 +456,7 @@ static void interpreter_print_type(SnukInterpreter *intpret, SnukType *type) {
 
         case TYPE_FN:
             snuk_print("fn(", NULL);
-            count = snuk_darray_get_length(type->fn.param_types);
+            count = sn_darray_get_length(type->fn.param_types);
             for (uint64_t i = 0; i < count; ++i) {
                 if (i != 0) snuk_print(", ", NULL);
                 interpreter_print_type(intpret, type->fn.param_types[i]);
@@ -466,7 +467,7 @@ static void interpreter_print_type(SnukInterpreter *intpret, SnukType *type) {
 
         case TYPE_INTERFACE:
             snuk_print("interface", NULL);
-            count = snuk_darray_get_length(type->members);
+            count = sn_darray_get_length(type->members);
             for (uint64_t i = 0; i < count; ++i) {
                 if (i != 0) snuk_print("; ", NULL);
                 snuk_print(SNUK_STRING_VIEW_FORMAT ": ", SNUK_STRING_VIEW_ARG(type->members[i]->name));
@@ -513,7 +514,7 @@ static void interpreter_print_value(SnukInterpreter *intpret, SnukValue value) {
         case SNUK_VALUE_FN:
             snuk_print("fn(", NULL);
             scope = GET_SCOPE(value.fn_value.closure);
-            len = snuk_darray_get_length(scope->vars);
+            len = sn_darray_get_length(scope->vars);
             for (uint64_t i = 0; i < len; ++i) {
                 if (i != 0) snuk_print(", ", NULL);
                 snuk_print(SNUK_STRING_VIEW_FORMAT ": ", SNUK_STRING_VIEW_ARG(scope->vars[i]->name));
@@ -526,7 +527,7 @@ static void interpreter_print_value(SnukInterpreter *intpret, SnukValue value) {
         case SNUK_VALUE_TYPE:
             snuk_print("type {", NULL);
             scope = GET_SCOPE(value.type_value.closure);
-            len = snuk_darray_get_length(scope->vars);
+            len = sn_darray_get_length(scope->vars);
             for (uint64_t i = 0; i < len; ++i) {
                 if (i != 0) snuk_print("; ", NULL);
                 SnukEnv *env = scope->vars[i];
@@ -544,7 +545,7 @@ static void interpreter_print_value(SnukInterpreter *intpret, SnukValue value) {
             interpreter_print_type(intpret, value.type_value.type);
             snuk_print(" {", NULL);
             scope = GET_SCOPE(value.type_value.closure);
-            len = snuk_darray_get_length(scope->vars);
+            len = sn_darray_get_length(scope->vars);
             for (uint64_t i = 0; i < len; ++i) {
                 SnukEnv *env = scope->vars[i];
                 if (snuk_string_view_equal_cstr(env->name, "self")) {
@@ -572,7 +573,7 @@ static void interpreter_print_value(SnukInterpreter *intpret, SnukValue value) {
 static void execute_print_item(SnukInterpreter *intpret, SnukExpr **exprs, bool weak_ref) {
     if (!exprs) return;
 
-    uint64_t count = snuk_darray_get_length(exprs);
+    uint64_t count = sn_darray_get_length(exprs);
     for (uint64_t i = 0; i < count; ++i) {
         SnukValue value = interpreter_eval_expr(intpret, exprs[i], weak_ref);
         interpreter_print_value(intpret, value);
@@ -591,7 +592,7 @@ SnukValue execute_block_expr(
     SnukInterpreter *intpret, SnukExpr *block, int capture_signals, int propogate_signals, bool weak_ref) {
     interpreter_push_scope(intpret);
 
-    uint64_t count = snuk_darray_get_length(block->block_items);
+    uint64_t count = sn_darray_get_length(block->block_items);
     SnukValue value = {.type = SNUK_VALUE_NULL};
 
     for (uint64_t j = 0; j < count; ++j) {
@@ -771,7 +772,7 @@ static SnukValue execute_type_declaration(SnukInterpreter *intpret, SnukExpr *ex
     // lock type's scope
     GET_SCOPE(value.type_value.closure)->locked = true;
 
-    uint64_t count = snuk_darray_get_length(expr->type_expr.members);
+    uint64_t count = sn_darray_get_length(expr->type_expr.members);
     for (uint64_t i = 0; i < count; ++i) {
         SnukValue val = interpreter_exec_item(intpret, expr->type_expr.members[i], true);
         snuk_value_free(val);
@@ -818,7 +819,7 @@ static SnukValue execute_inst_creation(SnukInterpreter *intpret, SnukExpr *expr,
         },
     };
 
-    uint64_t init_count = snuk_darray_get_length(expr->type_inst_expr.init);
+    uint64_t init_count = sn_darray_get_length(expr->type_inst_expr.init);
     for (uint64_t i = 0; i < init_count; ++i) {
         SnukExpr *assign = expr->type_inst_expr.init[i];
         if (assign->type != SNUK_EXPR_ASSIGN) {
@@ -932,7 +933,7 @@ static SnukValue execute_compound_binary_op(SnukInterpreter *intpret, SnukExpr *
 static SnukValue execute_fn_expr(SnukInterpreter *intpret, SnukExpr *expr, bool weak_ref) {
     interpreter_push_scope(intpret);
 
-    uint64_t param_count = snuk_darray_get_length(expr->fn_expr.params);
+    uint64_t param_count = sn_darray_get_length(expr->fn_expr.params);
     for (uint64_t i = 0; i < param_count; ++i) {
         SnukVar *param = expr->fn_expr.params[i];
         SnukValue value = (SnukValue){.type = SNUK_VALUE_UNKOWN};
@@ -986,8 +987,8 @@ static SnukValue execute_call_expr(SnukInterpreter *intpret, SnukExpr *expr, boo
 
     SnukScope *fn_scope = GET_SCOPE(fn_scope_rc);
 
-    uint64_t fn_param_count = snuk_darray_get_length(fn_scope->vars);
-    uint64_t param_count = snuk_darray_get_length(expr->call.params);
+    uint64_t fn_param_count = sn_darray_get_length(fn_scope->vars);
+    uint64_t param_count = sn_darray_get_length(expr->call.params);
 
     if (fn_param_count < param_count)
         interpreter_error_fmt(intpret, SNUK_INTERP_ERR_FUNCALL, "function expects %llu argument(s) but %llu provided",
@@ -1330,7 +1331,7 @@ static SnukValue execute_member_get(SnukInterpreter *intpret, SnukExpr *expr, bo
             .type_inst_expr = {
                 .type = NULL,
                 .name = (SnukStringView){0},
-                .init = snuk_darray_create(SnukExpr *, NULL),
+                .init = sn_darray_create(SnukExpr *, &snuk_global_allocator),
             },
         };
 
@@ -1380,11 +1381,11 @@ static SnukValue execute_member_get(SnukInterpreter *intpret, SnukExpr *expr, bo
             .assign = {.identifier = &identifier_expr, .value = &value_expr},
         };
 
-        snuk_darray_push(&inst_expr.type_inst_expr.init, &assign_expr);
+        sn_darray_push(&inst_expr.type_inst_expr.init, &assign_expr);
 
         snuk_value_free(type_or_inst);
         type_or_inst = execute_inst_creation(intpret, &inst_expr, weak_ref);
-        snuk_darray_destroy(inst_expr.type_inst_expr.init);
+        sn_darray_destroy(inst_expr.type_inst_expr.init);
         res = interpreter_get_member(intpret, type_or_inst, expr->member_access.field->identifier, NULL);
     }
 
@@ -1415,7 +1416,7 @@ static SnukValue execute_extend(SnukInterpreter *intpret, SnukItem *item, bool w
     SnukRefCounter *temp = snuk_ref_counter_move(&intpret->current);
     intpret->current = snuk_ref_counter_move(&type.type_value.closure);
 
-    uint64_t count = snuk_darray_get_length(item->extend_item.members);
+    uint64_t count = sn_darray_get_length(item->extend_item.members);
     for (uint64_t i = 0; i < count; ++i) {
         SnukValue val = interpreter_exec_item(intpret, item->extend_item.members[i], true);
         snuk_value_free(val);
@@ -1458,7 +1459,7 @@ SnukValue interpreter_copy_inst(SnukInterpreter *intpret, SnukValue inst) {
 
     SnukScope *scope = GET_SCOPE(inst.type_value.closure);
 
-    uint64_t init_count = snuk_darray_get_length(scope->vars);
+    uint64_t init_count = sn_darray_get_length(scope->vars);
     for (uint64_t i = 0; i < init_count; ++i) {
         if (snuk_string_view_equal(scope->vars[i]->name, self_str)) continue;
         SnukValue val;
diff --git a/src/interpreter/native.c b/src/interpreter/native.c
index 9235713..f5835c1 100644
--- a/src/interpreter/native.c
+++ b/src/interpreter/native.c
@@ -1,9 +1,10 @@
 #include "snuk/interpreter/native.h"
 
-#include "snuk/darray.h"
 #include "snuk/interpreter/builtins/snuk_builtins.h"
 #include "snuk/interpreter/interpreter_helper.h"
 
+#include <sncontainer/darray.h>
+
 SnukValue snuk_native_lookup(SnukInterpreter *intpret, const char *name) {
     return snuk_interpreter_get_env(intpret, snuk_string_view_create(name));
 }
@@ -68,7 +69,7 @@ SnukValue snuk_native_call_function(SnukInterpreter *intpret, SnukValue fn, Snuk
     interpreter_push_scope(intpret);
 
     SnukScope *fn_scope = GET_SCOPE(fn_scope_rc);
-    uint64_t fn_param_count = snuk_darray_get_length(fn_scope->vars);
+    uint64_t fn_param_count = sn_darray_get_length(fn_scope->vars);
 
     if (fn_param_count < count) return (SnukValue){.type = SNUK_VALUE_UNKOWN};
     for (uint64_t i = 0; i < count; ++i) {
@@ -161,7 +162,7 @@ SnukValue snuk_native_create_fn(SnukInterpreter *intpret, SnukParameter *params,
                                 SnukType *fn_type, native_function_t fn, bool weak_ref) {
     interpreter_push_scope(intpret);
 
-    uint64_t param_count = snuk_darray_get_length(fn_type->fn.param_types);
+    uint64_t param_count = sn_darray_get_length(fn_type->fn.param_types);
     if (count != param_count) return (SnukValue){.type = SNUK_VALUE_UNKOWN};
 
     for (uint64_t i = 0; i < count; ++i) {
diff --git a/src/lexer.c b/src/lexer.c
index 6cf7a0c..8112f5c 100644
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -1,10 +1,11 @@
 #include "snuk/lexer.h"
 
-#include "snuk/darray.h"
 #include "snuk/logger.h"
+#include "snuk/memory.h"
 #include "snuk/snuk_string.h"
 
 #include <errno.h>
+#include <sncontainer/darray.h>
 #include <stdlib.h>
 
 struct ScopeDepth {
@@ -13,38 +14,38 @@ struct ScopeDepth {
 };
 
 SNUK_INLINE bool scope_depth_zero(ScopeDepth *sd) {
-    uint64_t last = snuk_darray_get_length(sd) - 1;
+    uint64_t last = sn_darray_get_length(sd) - 1;
     return sd[last].paren == sd[last].bracket && sd[last].paren == 0;
 }
 
 SNUK_INLINE void scope_depth_push(ScopeDepth **sd) {
-    snuk_darray_push(sd, (ScopeDepth){0});
+    sn_darray_push(sd, (ScopeDepth){0});
 }
 
 SNUK_INLINE void scope_depth_pop(ScopeDepth **sd) {
     ScopeDepth depth;
     SNUK_ASSERT(scope_depth_zero(*sd), "scope mismatch");
-    snuk_darray_pop(sd, &depth);
+    sn_darray_pop(sd, &depth);
 }
 
 SNUK_INLINE void scope_depth_add_paren(ScopeDepth *sd) {
-    uint64_t last = snuk_darray_get_length(sd) - 1;
+    uint64_t last = sn_darray_get_length(sd) - 1;
     sd[last].paren++;
 }
 
 SNUK_INLINE void scope_depth_remove_paren(ScopeDepth *sd) {
-    uint64_t last = snuk_darray_get_length(sd) - 1;
+    uint64_t last = sn_darray_get_length(sd) - 1;
     SNUK_ASSERT(sd[last].paren > 0, "scope mismatch");
     sd[last].paren--;
 }
 
 SNUK_INLINE void scope_depth_add_bracket(ScopeDepth *sd) {
-    uint64_t last = snuk_darray_get_length(sd) - 1;
+    uint64_t last = sn_darray_get_length(sd) - 1;
     sd[last].bracket++;
 }
 
 SNUK_INLINE void scope_depth_remove_bracket(ScopeDepth *sd) {
-    uint64_t last = snuk_darray_get_length(sd) - 1;
+    uint64_t last = sn_darray_get_length(sd) - 1;
     SNUK_ASSERT(sd[last].bracket > 0, "scope mismatch");
     sd[last].bracket--;
 }
@@ -629,14 +630,14 @@ void snuk_lexer_init(SnukLexer *lexer, const char *src) {
         .line = 0,
         .col = 0,
         .previous_token_type = SNUK_TOKEN_MAX,
-        .sd = snuk_darray_create(ScopeDepth, NULL),
+        .sd = sn_darray_create(ScopeDepth, &snuk_global_allocator),
     };
     scope_depth_push(&lexer->sd);
 }
 
 void snuk_lexer_deinit(SnukLexer *lexer) {
     if (!lexer) return;
-    snuk_darray_destroy(lexer->sd);
+    sn_darray_destroy(lexer->sd);
     *lexer = (SnukLexer){0};
 }
 
diff --git a/src/memory.c b/src/memory.c
index 14d0d8a..7491917 100644
--- a/src/memory.c
+++ b/src/memory.c
@@ -153,7 +153,7 @@ SNUK_INLINE void *snuk_allocator_global_realloc(void *data, void *ptr, uint64_t
     return snuk_realloc(ptr, new_size, align);
 }
 
-SnukAllocator snuk_global_allocator = {
+SnMemoryAllocator snuk_global_allocator = {
     .data = NULL,
     .alloc = snuk_allocator_global_alloc,
     .realloc = snuk_allocator_global_realloc,
diff --git a/src/parser/parser.c b/src/parser/parser.c
index e930543..f2cb419 100644
--- a/src/parser/parser.c
+++ b/src/parser/parser.c
@@ -3,7 +3,7 @@
 #include "snuk/parser/parser_common.h"
 #include "snuk/parser/snuk_item.h"
 
-void snuk_parser_init(SnukParser *parser, const char *src, SnukAllocator *allocator) {
+void snuk_parser_init(SnukParser *parser, const char *src, SnMemoryAllocator *allocator) {
     *parser = (SnukParser){
         .allocator = allocator,
         .panic_mode = false,
diff --git a/src/parser/snuk_expr.c b/src/parser/snuk_expr.c
index b8b7620..9f19459 100644
--- a/src/parser/snuk_expr.c
+++ b/src/parser/snuk_expr.c
@@ -1,6 +1,5 @@
 #include "snuk/parser/snuk_expr.h"
 
-#include "snuk/darray.h"
 #include "snuk/parser/snuk_item.h"
 #include "snuk/parser/snuk_type.h"
 #include "snuk/parser/snuk_var.h"
@@ -553,7 +552,7 @@ static SnukExpr *parse_fn(SnukParser *parser) {
     SnukStringView name = {0};
     if (parser_match(parser, SNUK_TOKEN_IDENTIFIER)) name = parser->previous.string_literal;
 
-    SnukVar **params = snuk_darray_create(SnukVar *, parser->allocator);
+    SnukVar **params = sn_darray_create(SnukVar *, parser->allocator);
     SnukType *fn_type = build_fn_type(parser, NULL, NULL, NULL);
 
     parser_expect(parser, SNUK_TOKEN_LPAREN, "expected '('");
@@ -561,7 +560,7 @@ static SnukExpr *parse_fn(SnukParser *parser) {
         SnukVar *var = snuk_var_parse(parser, false);
 
         fn_type = build_fn_type(parser, fn_type, var->type, NULL);
-        snuk_darray_push(&params, var);
+        sn_darray_push(&params, var);
 
         if (!parser_check(parser, SNUK_TOKEN_RPAREN))
             parser_expect(parser, SNUK_TOKEN_COMMA, "expected comma");
@@ -585,10 +584,10 @@ static SnukExpr *parse_fn(SnukParser *parser) {
 }
 
 static SnukExpr *parse_call(SnukParser *parser, SnukExpr *left) {
-    SnukExpr **params = snuk_darray_create(SnukExpr *, parser->allocator);
+    SnukExpr **params = sn_darray_create(SnukExpr *, parser->allocator);
     while (!parser_match(parser, SNUK_TOKEN_RPAREN) && parser->current.type != SNUK_TOKEN_EOF) {
         SnukExpr *expr = snuk_expr_parse(parser);
-        snuk_darray_push(&params, expr);
+        sn_darray_push(&params, expr);
         if (!parser_check(parser, SNUK_TOKEN_RPAREN))
             parser_expect(parser, SNUK_TOKEN_COMMA, "expected comma");
     }
@@ -616,10 +615,10 @@ static SnukExpr *parse_comment(SnukParser *parser) {
 }
 
 static SnukExpr *parse_list(SnukParser *parser) {
-    SnukExpr **elements = snuk_darray_create(SnukExpr *, parser->allocator);
+    SnukExpr **elements = sn_darray_create(SnukExpr *, parser->allocator);
     while (!parser_match(parser, SNUK_TOKEN_RBRACKET) && parser->current.type != SNUK_TOKEN_EOF) {
         SnukExpr *expr = snuk_expr_parse(parser);
-        snuk_darray_push(&elements, expr);
+        sn_darray_push(&elements, expr);
         if (!parser_check(parser, SNUK_TOKEN_RBRACKET))
             parser_expect(parser, SNUK_TOKEN_COMMA, "expected ',' or ']' after list element");
     }
@@ -635,14 +634,14 @@ static SnukExpr *parse_list(SnukParser *parser) {
 static SnukExpr *parse_type(SnukParser *parser, SnukStringView name) {
     parser_expect(parser, SNUK_TOKEN_LBRACE, "expected '{'");
 
-    SnukItem **members = snuk_darray_create(SnukItem *, parser->allocator);
+    SnukItem **members = sn_darray_create(SnukItem *, parser->allocator);
     SnukType *type_type = build_type_type(parser);
 
     while (!parser_match(parser, SNUK_TOKEN_RBRACE) && parser->current.type != SNUK_TOKEN_EOF) {
         if (parser_check(parser, SNUK_TOKEN_VAR) || parser_check(parser, SNUK_TOKEN_CONST)
             || parser_check(parser, SNUK_TOKEN_FN) || parser_check(parser, SNUK_TOKEN_TYPE)) {
             SnukItem *item = snuk_item_parse(parser);
-            snuk_darray_push(&members, item);
+            sn_darray_push(&members, item);
         } else {
             parser_error(parser, SNUK_PARSE_ERR_UNEXPECTED_TOKEN, "unexpected token");
         }
@@ -665,7 +664,7 @@ static SnukExpr *parse_type_inst(SnukParser *parser, SnukType *type) {
 
     parser_expect(parser, SNUK_TOKEN_LBRACE, "expected '{'");
 
-    SnukExpr **init = snuk_darray_create(SnukExpr *, parser->allocator);
+    SnukExpr **init = sn_darray_create(SnukExpr *, parser->allocator);
     while (!parser_match(parser, SNUK_TOKEN_RBRACE) && parser->current.type != SNUK_TOKEN_EOF) {
         parser_expect(parser, SNUK_TOKEN_IDENTIFIER, "expected an member name");
         SnukExpr *identifier = parse_primary(parser);
@@ -673,7 +672,7 @@ static SnukExpr *parse_type_inst(SnukParser *parser, SnukType *type) {
         SnukExpr *value = snuk_expr_parse(parser);
         parser_expect_item_end(parser);
         SnukExpr *assign = build_assign_expr(parser, identifier, value);
-        snuk_darray_push(&init, assign);
+        sn_darray_push(&init, assign);
     }
 
     if (parser->previous.type != SNUK_TOKEN_RBRACE) {
@@ -854,7 +853,7 @@ void snuk_expr_log(SnukExpr *expr) {
             log_trace("fn expression:", NULL);
             if (expr->fn_expr.name.len)
                 log_trace("Name: " SNUK_STRING_VIEW_FORMAT, SNUK_STRING_VIEW_ARG(expr->fn_expr.name));
-            count = snuk_darray_get_length(expr->fn_expr.params);
+            count = sn_darray_get_length(expr->fn_expr.params);
             for (uint64_t i = 0; i < count; ++i) snuk_var_log(expr->fn_expr.params[i]);
             log_trace("body:", NULL);
             snuk_expr_log(expr->fn_expr.body);
@@ -864,18 +863,18 @@ void snuk_expr_log(SnukExpr *expr) {
             log_trace("type expression:", NULL);
             if (expr->type_expr.name.len)
                 log_trace("Name: " SNUK_STRING_VIEW_FORMAT, SNUK_STRING_VIEW_ARG(expr->type_expr.name));
-            count = snuk_darray_get_length(expr->type_expr.members);
+            count = sn_darray_get_length(expr->type_expr.members);
             for (uint64_t i = 0; i < count; ++i) snuk_item_log(expr->type_expr.members[i]);
             break;
         case SNUK_EXPR_BLOCK:
             log_trace("block expression:", NULL);
-            count = snuk_darray_get_length(expr->block_items);
+            count = sn_darray_get_length(expr->block_items);
             for (uint64_t i = 0; i < count; ++i) snuk_item_log(expr->block_items[i]);
             break;
         case SNUK_EXPR_CALL:
             // TODO:
             snuk_expr_log(expr->call.fn);
-            count = snuk_darray_get_length(expr->call.params);
+            count = sn_darray_get_length(expr->call.params);
             for (uint64_t i = 0; i < count; ++i) snuk_expr_log(expr->call.params[i]);
             break;
         case SNUK_EXPR_MEMBER:
@@ -892,7 +891,7 @@ void snuk_expr_log(SnukExpr *expr) {
             break;
         case SNUK_EXPR_LIST: {
             log_trace("List:", NULL);
-            uint64_t len = snuk_darray_get_length(expr->list.elements);
+            uint64_t len = sn_darray_get_length(expr->list.elements);
             for (uint64_t i = 0; i < len; ++i) {
                 snuk_expr_log(expr->list.elements[i]);
             }
diff --git a/src/parser/snuk_item.c b/src/parser/snuk_item.c
index 5d6e73f..a837ee2 100644
--- a/src/parser/snuk_item.c
+++ b/src/parser/snuk_item.c
@@ -217,12 +217,12 @@ void snuk_item_log(SnukItem *item) {
         case SNUK_ITEM_EXTEND:
             log_trace("extend", NULL);
             snuk_expr_log(item->extend_item.type);
-            count = snuk_darray_get_length(item->extend_item.members);
+            count = sn_darray_get_length(item->extend_item.members);
             for (uint64_t i = 0; i < count; ++i) snuk_item_log(item->extend_item.members[i]);
             break;
         case SNUK_ITEM_PRINT:
             log_trace("print:", NULL);
-            count = snuk_darray_get_length(item->print_exprs);
+            count = sn_darray_get_length(item->print_exprs);
             for (uint64_t i = 0; i < count; ++i) snuk_expr_log(item->print_exprs[i]);
             break;
         default:
diff --git a/src/parser/snuk_type.c b/src/parser/snuk_type.c
index 1039714..6239772 100644
--- a/src/parser/snuk_type.c
+++ b/src/parser/snuk_type.c
@@ -87,7 +87,7 @@ void snuk_type_log(SnukType *type) {
         case TYPE_FN:
             log_trace("type type: %s", SNUK_STRINGIFY(TYPE_FN));
             log_trace("param types:", NULL);
-            count = snuk_darray_get_length(type->fn.param_types);
+            count = sn_darray_get_length(type->fn.param_types);
             for (uint64_t i = 0; i < count; ++i) snuk_type_log(type->fn.param_types[i]);
             log_trace("return type:", NULL);
             snuk_type_log(type->fn.return_type);
@@ -114,8 +114,8 @@ bool snuk_type_equal(SnukType *type1, SnukType *type2) {
         case TYPE_FN:
             if (!snuk_type_equal(type1->fn.return_type, type2->fn.return_type)) return false;
 
-            count1 = snuk_darray_get_length(type1->fn.param_types);
-            count2 = snuk_darray_get_length(type2->fn.param_types);
+            count1 = sn_darray_get_length(type1->fn.param_types);
+            count2 = sn_darray_get_length(type2->fn.param_types);
             if (count1 != count2) return false;
 
             for (uint64_t i = 0; i < count1; ++i)
@@ -124,8 +124,8 @@ bool snuk_type_equal(SnukType *type1, SnukType *type2) {
             return true;
 
         case TYPE_INTERFACE:
-            count1 = snuk_darray_get_length(type1->members);
-            count2 = snuk_darray_get_length(type2->members);
+            count1 = sn_darray_get_length(type1->members);
+            count2 = sn_darray_get_length(type2->members);
             if (count1 != count2) return false;
             for (uint64_t i = 0; i < count1; ++i) {
                 if (!snuk_string_view_equal(type1->members[i]->name, type2->members[i]->name))