diff --git a/axl_string.c b/axl_string.c
index ce1a73e..f5feab5 100644
--- a/axl_string.c
+++ b/axl_string.c
@@ -186,3 +186,81 @@ i8* axl_strrev(i8* str)
     
     return str;
 }
+
+/*static const char digits_lower[] = "0123456789abcdefghijklmnopqrstuvwxyz";*/
+static const char digits_upper[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+i8* axl_utoa(u64 val, i8* str, u8 base)
+{
+    if(!str)
+    {
+        return NULL;
+    }
+
+    if (base < 2 || base > 36) 
+    {
+        *str = '\0';
+        return str;
+    }
+
+    i8* head = str;
+    const i8* digits = digits_upper;
+
+
+    if (val == 0) 
+    {
+        *head++ = '0';
+        *head++ = '\0';
+        return str;
+    }
+
+    while (val != 0) 
+    {
+        *head++ = digits[val % base];
+        val /= base;
+    }
+
+    *head = '\0';
+
+    return axl_strrev(str);
+}
+
+i8* axl_itoa(i64 val, i8* str, u8 base)
+{
+    if(!str)
+    {
+        return NULL;
+    }
+
+    if (base < 2 || base > 36) 
+    {
+        *str = '\0';
+        return str;
+    }
+
+    i8* head = str;
+    u64 uval = val < 0 ? (u64)(-(val)) : (u64)val;
+
+    if (uval == 0) 
+    {
+        *head++ = '0';
+        *head++ = '\0';
+        return str;
+    }
+
+    while (uval != 0) 
+    {
+        *head++ = digits_upper[uval % base];
+        uval   /= base;
+    }
+
+    if (val < 0) 
+    {
+        *head++ = '-';
+        
+    } 
+
+    *head = '\0';
+
+    return axl_strrev(str);
+}
diff --git a/axl_string.h b/axl_string.h
index 64562d7..ffd6878 100644
--- a/axl_string.h
+++ b/axl_string.h
@@ -12,5 +12,7 @@ i32       axl_strncmp(const i8* s1, const i8* s2, u32 n);
 const i8* axl_strchr(const i8* str, i8 c);
 i8*       axl_strstr(const i8* str, const i8* substr);
 i8*       axl_strrev(i8* str);
+i8*       axl_utoa(u64 val, i8* str, u8 base);
+i8*       axl_itoa(i64 val, i8* str, u8 base);
 
 #endif // AXL_STRING
diff --git a/axl_string_test.c b/axl_string_test.c
index c36ba5d..2551d02 100644
--- a/axl_string_test.c
+++ b/axl_string_test.c
@@ -547,6 +547,231 @@ KOAN(strrev_in_place)
     ASSERT_STR_EQ("test", str);
 }
 
+KOAN(utoa_decimal_zero)
+{
+    i8 buffer[32];
+    i8* result = axl_utoa(0, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("0", buffer);
+}
+
+KOAN(utoa_decimal_small)
+{
+    i8 buffer[32];
+    i8* result = axl_utoa(42, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("42", buffer);
+}
+
+KOAN(utoa_decimal_large)
+{
+    i8 buffer[32];
+    i8* result = axl_utoa(4294967295U, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("4294967295", buffer);
+}
+
+KOAN(utoa_binary)
+{
+    i8 buffer[32];
+    i8* result = axl_utoa(10, buffer, 2);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("1010", buffer);
+}
+
+KOAN(utoa_octal)
+{
+    i8 buffer[32];
+    i8* result = axl_utoa(255, buffer, 8);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("377", buffer);
+}
+
+KOAN(utoa_hexadecimal_lowercase)
+{
+    i8 buffer[32];
+    i8* result = axl_utoa(0xDEADBEEF, buffer, 16);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("DEADBEEF", buffer);
+}
+
+KOAN(utoa_hexadecimal_uppercase)
+{
+    i8 buffer[32];
+    i8* result = axl_utoa(0xCAFEBABE, buffer, 16);
+    ASSERT_PTR_EQ(buffer, result);
+    // Note: implementation should produce lowercase by default
+    // If uppercase is needed, we'd need a separate function
+    ASSERT_STR_EQ("CAFEBABE", buffer);
+}
+
+KOAN(utoa_base_36)
+{
+    i8 buffer[32];
+    i8* result = axl_utoa(123456789, buffer, 36);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("21I3V9", buffer);
+}
+
+KOAN(utoa_max_base)
+{
+    i8 buffer[32];
+    i8* result = axl_utoa(35, buffer, 36);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("Z", buffer);
+}
+
+KOAN(itoa_positive)
+{
+    i8 buffer[32];
+    i8* result = axl_itoa(12345, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("12345", buffer);
+}
+
+KOAN(itoa_negative)
+{
+    i8 buffer[32];
+    i8* result = axl_itoa(-12345, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("-12345", buffer);
+}
+
+KOAN(itoa_zero)
+{
+    i8 buffer[32];
+    i8* result = axl_itoa(0, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("0", buffer);
+}
+
+KOAN(itoa_min_int)
+{
+    i8 buffer[32];
+    i8* result = axl_itoa(-9223372036854775807LL - 1, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("-9223372036854775808", buffer);
+}
+
+KOAN(itoa_max_int)
+{
+    i8 buffer[32];
+    i8* result = axl_itoa(9223372036854775807LL, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("9223372036854775807", buffer);
+}
+
+KOAN(itoa_negative_binary)
+{
+    i8 buffer[32];
+    i8* result = axl_itoa(-10, buffer, 2);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("-1010", buffer);
+}
+
+KOAN(itoa_negative_hex)
+{
+    i8 buffer[32];
+    i8* result = axl_itoa(-0xDEAD, buffer, 16);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("-DEAD", buffer);
+}
+
+KOAN(itoa_positive_octal)
+{
+    i8 buffer[32];
+    i8* result = axl_itoa(511, buffer, 8);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("777", buffer);
+}
+
+KOAN(itoa_negative_octal)
+{
+    i8 buffer[32];
+    i8* result = axl_itoa(-511, buffer, 8);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("-777", buffer);
+}
+
+KOAN(itoa_base_36_positive)
+{
+    i8 buffer[32];
+    i8* result = axl_itoa(123456789, buffer, 36);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("21I3V9", buffer);
+}
+
+KOAN(itoa_base_36_negative)
+{
+    i8 buffer[32];
+    i8* result = axl_itoa(-123456789, buffer, 36);
+    ASSERT_PTR_EQ(buffer, result);
+    ASSERT_STR_EQ("-21I3V9", buffer);
+}
+
+KOAN(utoa_buffer_reuse)
+{
+    i8 buffer[32];
+    i8* result1 = axl_utoa(123, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result1);
+    ASSERT_STR_EQ("123", buffer);
+    
+    i8* result2 = axl_utoa(456, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result2);
+    ASSERT_STR_EQ("456", buffer);
+}
+
+KOAN(itoa_buffer_reuse)
+{
+    i8 buffer[32];
+    i8* result1 = axl_itoa(-123, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result1);
+    ASSERT_STR_EQ("-123", buffer);
+    
+    i8* result2 = axl_itoa(456, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result2);
+    ASSERT_STR_EQ("456", buffer);
+}
+
+KOAN(utoa_edge_cases)
+{
+    i8 buffer[32];
+    
+    // Test with base 2 (binary)
+    i8* result1 = axl_utoa(42, buffer, 2);
+    ASSERT_PTR_EQ(buffer, result1);
+    ASSERT_STR_EQ("101010", buffer);
+    
+    // Test with base 8 (octal)
+    i8* result2 = axl_utoa(777, buffer, 8);
+    ASSERT_PTR_EQ(buffer, result2);
+    ASSERT_STR_EQ("1411", buffer);
+    
+    // Test with base 16 (hex)
+    i8* result3 = axl_utoa(0xABCD, buffer, 16);
+    ASSERT_PTR_EQ(buffer, result3);
+    ASSERT_STR_EQ("ABCD", buffer);
+}
+
+KOAN(itoa_edge_cases)
+{
+    i8 buffer[32];
+    
+    // Test positive to negative transition
+    i8* result1 = axl_itoa(1, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result1);
+    ASSERT_STR_EQ("1", buffer);
+    
+    i8* result2 = axl_itoa(-1, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result2);
+    ASSERT_STR_EQ("-1", buffer);
+    
+    // Test zero stays zero
+    i8* result3 = axl_itoa(0, buffer, 10);
+    ASSERT_PTR_EQ(buffer, result3);
+    ASSERT_STR_EQ("0", buffer);
+}
+
 int main(void)
 {
     axl_init();
diff --git a/main.c b/main.c
index 612a1d2..491d242 100644
--- a/main.c
+++ b/main.c
@@ -1,4 +1,7 @@
 #include "axl.h"
+#include "axl_io.h"
+#include "axl_memory.h"
+#include "axl_string.h"
 #include "axl_vlq.h"
 #include <windows.h>
 
@@ -30,22 +33,43 @@ int _start(void)
     (void)fds;
     (void)f;
 
-
-    u32 new_len = 0;
-    u8 src[] = "Bonjour le monde!";
-    u32 src_len = axl_strlen((i8*)src);
-    for(u32 i = 0; i < src_len; i += 4)
+    for(int i = 64532; i < 64533; ++i)
     {
-        u8 buff[AXL_VLQ_MAX_LEN + 1];
+        axl_puts("{");
+        for(int base = 2; base < 17; ++base)
+        {
+            i8 buff[32];
+            axl_memset(buff, '\0', 32);
+            
+            i8 text[256];
+            axl_memset(text, '\0', 256);
 
-        u32 encoded_l = axl_vlq_encode(*((u32*)(src + i)), buff);
-        new_len += encoded_l;
-
-        buff[encoded_l] = '\0'; 
-
-        axl_puts((i8*)buff);
+            axl_strcat(text, axl_itoa(i, buff, 10));
+            axl_strcat(text, "\tof base\t");
+            axl_strcat(text, axl_itoa(base, buff, 10));
+            axl_strcat(text, "\tis\t");
+            axl_strcat(text, axl_itoa(i, buff, base));
+            axl_puts(text);
+        }
+        axl_puts("}");
     }
-    (void)new_len;
+
+
+    /*u32 new_len = 0;*/
+    /*u8 src[] = "Bonjour le monde!";*/
+    /*u32 src_len = axl_strlen((i8*)src);*/
+    /*for(u32 i = 0; i < src_len; i += 4)*/
+    /*{*/
+    /*    u8 buff[AXL_VLQ_MAX_LEN + 1];*/
+    /**/
+    /*    u32 encoded_l = axl_vlq_encode(*((u32*)(src + i)), buff);*/
+    /*    new_len += encoded_l;*/
+    /**/
+    /*    buff[encoded_l] = '\0'; */
+    /**/
+    /*    axl_puts((i8*)buff);*/
+    /*}*/
+    /*(void)new_len;*/
 
 
     return 0;