diff --git a/index.html b/index.html
index 960a2cd..38627d5 100644
--- a/index.html
+++ b/index.html
@@ -61,9 +61,9 @@
 </head>
 <body>
     <label for="raylib-example-select">Choose an Example:</label>
-        <select id="raylib-example-select" onchange="startRaylib(this.value)">
+    <select id="raylib-example-select" onchange="startRaylib(this.value)">
         <!-- This is populated by js -->
-        </select>
+    </select>
     <canvas id="game"></canvas>
     <script>
         const wasmPaths = {
diff --git a/nob.c b/nob.c
index 15ef36d..c3ee1e6 100644
--- a/nob.c
+++ b/nob.c
@@ -72,6 +72,7 @@ bool build_wasm(void)
         nob_cmd_append(&cmd, "-I./include");
         nob_cmd_append(&cmd, "--no-standard-libraries");
         nob_cmd_append(&cmd, "-Wl,--export-table");
+        nob_cmd_append(&cmd, "-Wl,--export=__heap_base");
         nob_cmd_append(&cmd, "-Wl,--no-entry");
         nob_cmd_append(&cmd, "-Wl,--allow-undefined");
         nob_cmd_append(&cmd, "-Wl,--export=main");
diff --git a/raylib.js b/raylib.js
index a6a0154..c1f4f29 100644
--- a/raylib.js
+++ b/raylib.js
@@ -21,6 +21,9 @@ const LOG_ERROR   = iota++; // Error logging, used on unrecoverable failures
 const LOG_FATAL   = iota++; // Fatal logging, used to abort program: exit(EXIT_FAILURE)
 const LOG_NONE    = iota++; // Disable logging
 
+const MAX_TEXTFORMAT_BUFFERS = 4;
+const MAX_TEXT_BUFFER_LENGTH = 1024;
+
 class RaylibJs {
     // TODO: We stole the font from the website
     // (https://raylib.com/) and it's slightly different than
@@ -44,6 +47,7 @@ class RaylibJs {
         this.currentMousePosition = {x: 0, y: 0};
         this.images = [];
         this.quit = false;
+        this.textFormatBufferIndex = 0;
     }
 
     constructor() {
@@ -197,11 +201,39 @@ class RaylibJs {
         return false;
     }
 
-    TextFormat(... args){ 
-        // TODO: Implement printf style formatting for TextFormat
-        return args[0];
+    TextFormat(text_ptr, args_ptr) {
+        const buffer = this.wasm.instance.exports.memory.buffer;
+        const fmt_text = cstr_fmt_by_ptr(buffer, text_ptr, args_ptr);
+        const fmt_text_len = fmt_text.length + 1;
+
+        const heap_base = this.wasm.instance.exports.__heap_base.value;
+        // TODO: Check if the values exceeds the heap end
+        // const heap_end = this.wasm.instance.exports.__heap_end.value;
+        const heap_ptr = heap_base + this.textFormatBufferIndex * MAX_TEXT_BUFFER_LENGTH;
+
+        // Inserting "..." at the end of the string to mark as truncated
+        if (fmt_text_len >= MAX_TEXT_BUFFER_LENGTH) {
+            fmt_text = fmt_text.substring(0, MAX_TEXT_BUFFER_LENGTH - 4) + "...";
+            fmt_text_len = fmt_text.length + 1;
+        }
+
+        // TODO: Other functions still override this allocation, need to implement
+        // allocator which manages the ownership of chunks.
+        const bytes = new Uint8Array(buffer, heap_ptr, fmt_text_len);
+        for (let i = 0; i < fmt_text.length; i++) {
+            bytes[i] = fmt_text.charCodeAt(i);
+        }
+
+        // Mark end with null
+        bytes[fmt_text.length] = 0;
+
+        // Move to next buffer for next function call
+        this.textFormatBufferIndex = (this.textFormatBufferIndex + 1) % MAX_TEXTFORMAT_BUFFERS;
+
+        return heap_ptr;
     }
 
+
     TraceLog(logLevel, text_ptr, ... args) {
         // TODO: Implement printf style formatting for TraceLog
         const buffer = this.wasm.instance.exports.memory.buffer;
@@ -509,3 +541,382 @@ function getColorFromMemory(buffer, color_ptr) {
     const [r, g, b, a] = new Uint8Array(buffer, color_ptr, 4);
     return color_hex_unpacked(r, g, b, a);
 }
+
+function cstr_fmt_by_ptr(mem_buffer, fmt_ptr, arg_ptr) {
+    const fmt = cstr_by_ptr(mem_buffer, fmt_ptr);
+
+    // VarArgs Chunk
+    let args = mem_buffer.slice(arg_ptr);
+    let result = "";
+    let fmt_buffer = fmt.split("");
+    let fmt_cur = 0;
+
+    let pad_width,
+        precision,
+        pad_with_zero,
+        pad_with_space,
+        justify_right,
+        pre_with_polarity,
+        pre_with_space,
+        pre_with_format,
+        capitalize,
+        precise,
+        bit_size,
+        radix;
+
+    reset_state();
+
+    function reset_state() {
+        bit_size = 32;
+        pad_width = 0;
+        precision = 0;
+        radix = 10;
+        pad_with_zero = false;
+        pad_with_space = false;
+        justify_right = true;
+
+        pre_with_polarity = false;
+        pre_with_space = false;
+        pre_with_format = false;
+
+        capitalize = false;
+        precise = false;
+    }
+
+    function parse_num(cursor) {
+        let width_end = cursor;
+        while (fmt_buffer[width_end]) {
+            if (/\d/.test(fmt_buffer[width_end])) width_end++;
+            else break;
+        }
+        let num = fmt_buffer.splice(cursor, width_end - cursor).join("");
+        return parseInt(num);
+    }
+
+    // Grab the view of args based on specifier and shift the args
+    function shift_args(view) {
+        args = args.slice(view.BYTES_PER_ELEMENT);
+        return view.at(0);
+    }
+
+    while (fmt_cur < fmt_buffer.length) {
+        if (fmt_buffer[fmt_cur] !== "%") {
+            // Normal character, copy it to the temp string
+            const str = fmt_buffer[fmt_cur++];
+            result += str;
+            continue;
+        }
+
+        // Peek only next character and splice the modifiers.
+        // So we can always simply look one char ahead
+        const peek_idx = fmt_cur + 1;
+        const peek_char = fmt_buffer[peek_idx];
+        switch (peek_char) {
+            case undefined: {
+                fmt_cur++;
+                break;
+            }
+
+            case "%": {
+                result += "%";
+                fmt_cur += 2;
+                break;
+            }
+
+            case "+": {
+                pre_with_polarity = true;
+                fmt_buffer.splice(peek_idx, 1);
+                break;
+            }
+
+            case "-": {
+                justify_right = false;
+                fmt_buffer.splice(peek_idx, 1);
+                break;
+            }
+
+            case " ": {
+                pre_with_space = !pre_with_polarity;
+                fmt_buffer.splice(peek_idx, 1);
+                break;
+            }
+
+            case ".": {
+                precise = true;
+                fmt_buffer.splice(peek_idx, 1);
+                break;
+            }
+
+            case "#": {
+                pre_with_format = true;
+                fmt_buffer.splice(peek_idx, 1);
+                break;
+            }
+
+            case "0": {
+                if (precise) {
+                    precision = parse_num(peek_idx);
+                } else {
+                    pad_with_zero = true;
+                    pad_width = parse_num(peek_idx);
+                }
+                break;
+            }
+
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7":
+            case "8":
+            case "9": {
+                if (precise) {
+                    precision = parse_num(peek_idx);
+                } else {
+                    pad_with_space = true;
+                    pad_width = parse_num(peek_idx);
+                }
+                break;
+            }
+
+            // Modifiers
+            case "l": {
+                bit_size = bit_size === 32 ? 64 : 32;
+                fmt_buffer.splice(peek_idx, 1);
+            }
+
+            // In JS there are no number below 32 bit, so we are ignoring
+            // also clang bakes the overflown and underflown values as it is
+            case "h": {
+                fmt_buffer.splice(peek_idx, 1);
+                break;
+            }
+
+            case "c": {
+                const char_code = shift_args(new Uint32Array(args));
+                let str = String.fromCharCode(char_code);
+                let pad_char;
+
+                if (pad_with_zero || pad_with_space) pad_char = " ";
+                else pad_char = "";
+
+                if (justify_right) str = str.padStart(pad_width, pad_char);
+                else str = str.padEnd(pad_width, pad_char);
+
+                result += str;
+                fmt_cur += 2;
+                reset_state();
+                break;
+            }
+
+            case "s": {
+                const str_ptr = shift_args(new Uint32Array(args));
+                let str = cstr_by_ptr(mem_buffer, str_ptr);
+                let pad_char;
+
+                if (pad_with_zero || pad_with_space) pad_char = " ";
+                else pad_char = "";
+
+                if (justify_right) str = str.padStart(pad_width, pad_char);
+                else str = str.padEnd(pad_width, pad_char);
+
+                if (precise) str = str.substring(0, precision);
+
+                result += str;
+                fmt_cur += 2;
+                reset_state();
+                break;
+            }
+
+            case "o":
+            case "x":
+            case "X":
+            case "u": {
+                let num;
+                let pad_char, pre_char;
+
+                if (peek_char === "o") {
+                    radix = 8;
+                } else if (peek_char === "x") {
+                    radix = 16;
+                } else if (peek_char === "X") {
+                    radix = 16;
+                    capitalize = true;
+                } else {
+                    console.error("radix unreachable");
+                }
+
+                if (bit_size === 32) {
+                    num = shift_args(new Uint32Array(args));
+                } else {
+                    unaligned = args.byteLength % 8;
+                    args.slice(unaligned);
+                    num = shift_args(new BigUint64Array(args));
+                }
+
+                if (pad_with_zero) pad_char = "0";
+                else if (pad_with_space) pad_char = " ";
+                else pad_char = "";
+
+                if (pre_with_format && radix === 8) pre_char = "0";
+                else if (pre_with_format && radix === 16) pre_char = "0x";
+                else pre_char = "";
+
+                if (precise) {
+                    pad_char = " ";
+                    num = num.toString(radix).padStart(precision, "0");
+                }
+
+                if (justify_right) {
+                    num = num.toString(radix).padStart(pad_width, pad_char);
+                } else {
+                    pad_char = " ";
+                    num = num.toString(radix).padEnd(pad_width, pad_char);
+                }
+
+                num = pre_char + num;
+
+                if (capitalize) num = num.toUpperCase();
+
+                result += num;
+                fmt_cur += 2;
+                reset_state();
+                break;
+            }
+
+            case "i":
+            case "d": {
+                let num;
+                let pad_char, pre_char;
+
+                if (bit_size === 32) {
+                    num = shift_args(new Int32Array(args));
+                } else {
+                    unaligned = args.byteLength % 8;
+                    args = args.slice(unaligned);
+                    num = shift_args(new BigInt64Array(args));
+                }
+
+                if (pad_with_zero) pad_char = "0";
+                else if (pad_with_space) pad_char = " ";
+                else pad_char = "";
+
+                if (pre_with_polarity && num > 0) pre_char = "+";
+                else if (pre_with_space && num > 0) pre_char = " ";
+                else pre_char = "";
+
+                if (precise) {
+                    pad_char = " ";
+                    num = num.toString().padStart(precision, "0");
+                }
+
+                if (justify_right) {
+                    num = num.toString().padStart(pad_width, pad_char);
+                } else {
+                    pad_char = " ";
+                    num = num.toString().padEnd(pad_width, pad_char);
+                }
+
+                num = pre_char + num;
+
+                result += num;
+                fmt_cur += 2;
+                reset_state();
+                break;
+            }
+
+            case "E": {
+                capitalize = true;
+            }
+            case "e": {
+                // Align Bytes by 8
+                unaligned = args.byteLength % 8;
+                args = args.slice(unaligned);
+
+                let num = shift_args(new Float64Array(args));
+                let pad_char, pre_char;
+
+                if (pad_with_zero) pad_char = "0";
+                else if (pad_with_space) pad_char = " ";
+                else pad_char = "";
+
+                if (pre_with_polarity && num > 0) pre_char = "+";
+                else if (pre_with_space && num > 0) pre_char = " ";
+                else pre_char = "";
+
+                if (precise) num = num.toExponential(precision);
+                else num = num.toExponential(6);
+
+                if (justify_right) {
+                    num = num.toString().padStart(pad_width, pad_char);
+                } else {
+                    pad_char = " ";
+                    num = num.toString().padEnd(pad_width, pad_char);
+                }
+
+                if (capitalize) num = num.toUpperCase();
+
+                num = pre_char + num;
+
+                result += num;
+                fmt_cur += 2;
+                reset_state();
+                break;
+            }
+            case "F":
+            case "G": {
+                capitalize = true;
+            }
+            case "g":
+            case "f": {
+                // Align Bytes by 8
+                unaligned = args.byteLength % 8;
+                args = args.slice(unaligned);
+
+                let num = shift_args(new Float64Array(args));
+                let pad_char, pre_char;
+
+                if (pad_with_zero) pad_char = "0";
+                else if (pad_with_space) pad_char = " ";
+                else pad_char = "";
+
+                if (pre_with_polarity && num > 0) pre_char = "+";
+                else if (pre_with_space && num > 0) pre_char = " ";
+                else pre_char = "";
+
+                if (precise) num = num.toFixed(precision);
+                else num = num.toFixed(6);
+
+                if (justify_right) {
+                    num = num.toString().padStart(pad_width, pad_char);
+                } else {
+                    pad_char = " ";
+                    num = num.toString().padEnd(pad_width, pad_char);
+                }
+
+                if (capitalize) num = num.toUpperCase();
+
+                num = pre_char + num;
+
+                result += num;
+                fmt_cur += 2;
+                reset_state();
+                break;
+            }
+
+            // TODO: unsupported format specifiers, copy it to the temp string
+            // Flags   => *
+            // Len Mod => j z t L
+            // Specify => a A n p
+            default: {
+                const str = fmt_buffer[fmt_cur++];
+                result += str;
+                break;
+            }
+        }
+    }
+
+    return result;
+}
