From 4af132cf6adeeeeb5d6764c378bec2d05cad042f Mon Sep 17 00:00:00 2001
From: frosty <frosty@illegalfirearms.store>
Date: Sun, 28 Dec 2025 03:26:05 -0500
Subject: Migrated from GitHub

---
 .gitignore                                   |   1 +
 LICENSE                                      |  28 +
 Makefile                                     |  56 ++
 README.md                                    |  19 +
 beaker.h                                     | 101 +++
 examples/hello-world/Makefile                |   6 +
 examples/hello-world/main.c                  |  20 +
 examples/template-demo/Makefile              |   6 +
 examples/template-demo/main.c                |  74 +++
 examples/template-demo/static/style.css      |  67 ++
 examples/template-demo/templates/header.html |   8 +
 examples/template-demo/templates/index.html  |  48 ++
 src/beaker_globals.c                         |  13 +
 src/beaker_globals.h                         |  18 +
 src/http.c                                   | 216 ++++++
 src/routing.c                                | 226 +++++++
 src/server.c                                 | 181 +++++
 src/template.c                               | 961 +++++++++++++++++++++++++++
 18 files changed, 2049 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 LICENSE
 create mode 100644 Makefile
 create mode 100644 README.md
 create mode 100644 beaker.h
 create mode 100644 examples/hello-world/Makefile
 create mode 100644 examples/hello-world/main.c
 create mode 100644 examples/template-demo/Makefile
 create mode 100644 examples/template-demo/main.c
 create mode 100644 examples/template-demo/static/style.css
 create mode 100644 examples/template-demo/templates/header.html
 create mode 100644 examples/template-demo/templates/index.html
 create mode 100644 src/beaker_globals.c
 create mode 100644 src/beaker_globals.h
 create mode 100644 src/http.c
 create mode 100644 src/routing.c
 create mode 100644 src/server.c
 create mode 100644 src/template.c

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..796b96d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+/build
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..d6eac31
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, gabrielf35
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..66e5016
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,56 @@
+CC = gcc
+AR = ar
+CFLAGS = -Wall -fPIC -I. -Isrc
+LDFLAGS = -shared
+BUILD_DIR ?= build
+OBJ_DIR = $(BUILD_DIR)/obj
+INSTALL_PREFIX ?= /usr/
+
+SRCS = $(wildcard src/*.c)
+OBJS = $(patsubst src/%.c,$(OBJ_DIR)/%.o,$(SRCS))
+
+LIB = $(BUILD_DIR)/libbeaker
+HEADER = beaker.h
+
+.PHONY: all clean install uninstall
+
+all: $(LIB).so $(LIB).a
+
+
+$(OBJ_DIR):
+	@mkdir -p $(OBJ_DIR)
+
+$(LIB).a: $(OBJS)
+	@echo "Linking shared library $@..."
+	$(AR) rcs $@ $^
+	@echo "Successfully built $@"
+
+$(LIB).so: $(OBJS)
+	@echo "Linking shared library $@..."
+	$(CC) $(LDFLAGS) $(OBJS) -o $@ -lm
+	@echo "Successfully built $@"
+
+$(OBJ_DIR)/%.o: src/%.c | $(OBJ_DIR)
+	@echo "Compiling $<..."
+	$(CC) $(CFLAGS) -c $< -o $@
+
+clean:
+	@echo "Cleaning up object files and shared library..."
+	@rm -rf $(OBJ_DIR) $(LIB)
+	@echo "Clean complete."
+
+install: all
+	@echo "Installing $(LIB) to $(INSTALL_PREFIX)/lib"
+	@cp $(LIB).so $(INSTALL_PREFIX)/lib/
+	@ldconfig
+	@echo "Installing $(HEADER) to $(INSTALL_PREFIX)/include"
+	@cp $(HEADER) $(INSTALL_PREFIX)/include
+	@echo "Installation complete."
+
+uninstall:
+	@echo "Uninstalling $(LIB) from $(INSTALL_PREFIX)/lib..."
+	@rm -f $(INSTALL_PREFIX)/lib/$(LIB)
+	@ldconfig
+	@echo "Removing $(HEADER) from $(INSTALL_PREFIX)/include"
+	@rm -f $(INSTALL_PREFIX)/include/$(HEADER)
+	@echo "Uninstallation complete."
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..998fdbf
--- /dev/null
+++ b/README.md
@@ -0,0 +1,19 @@
+# Beaker
+Beaker is a lightweight web framework written in C, designed for building simple and efficient web applications. It currently provides handling HTTP requests, routing, serving static files, rendering HTML templates and managing cookies.
+
+## Usage
+Look at the files in examples for usage
+
+## Installation
+```bash
+  git clone https://github.com/gabrielf35/beaker.git
+  cd beaker
+  sudo make install
+```
+    
+## Roadmap
+
+- Handle different types of POST requests
+- Write documentation
+- Add more robust logging
+- Write more examples
\ No newline at end of file
diff --git a/beaker.h b/beaker.h
new file mode 100644
index 0000000..d19d4c6
--- /dev/null
+++ b/beaker.h
@@ -0,0 +1,101 @@
+#ifndef BEAKER_H
+#define BEAKER_H
+
+#include <math.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define MAX_CONTEXT_VARS 32       
+#define MAX_KEY_LEN 64            
+#define MAX_VALUE_LEN 256         
+#define MAX_PATH_LEN 256          
+#define MAX_HANDLERS 32           
+#define BUFFER_SIZE 4096          
+#define MAX_URL_PARAMS 16         
+#define MAX_COOKIES 10            
+#define MAX_OUTER_ARRAY_ITEMS 100 
+#define MAX_INNER_ARRAY_ITEMS 200 
+
+#define TEMPLATES_DIR "templates/" 
+#define STATIC_DIR "static/"       
+
+typedef enum {
+  CONTEXT_TYPE_STRING,          
+  CONTEXT_TYPE_STRING_ARRAY,    
+  CONTEXT_TYPE_STRING_2D_ARRAY, 
+} ContextType;
+
+typedef struct {
+  char key[MAX_KEY_LEN]; 
+  ContextType type;      
+  union {
+    char string_val[MAX_VALUE_LEN]; 
+    struct {
+      char **values;      
+      int count;          
+    } string_array_data;
+    struct {
+      char ***values;     
+      int outer_count;    
+      int *inner_counts;  
+    } string_2d_array_data; 
+  } value;                   
+} ContextVar;
+
+typedef struct {
+  ContextVar vars[MAX_CONTEXT_VARS]; 
+  int count;                         
+} TemplateContext;
+
+typedef struct {
+  char key[MAX_KEY_LEN];   
+  char value[MAX_VALUE_LEN]; 
+} UrlParam;
+
+typedef struct {
+  UrlParam params[MAX_URL_PARAMS]; 
+  int count;                       
+} UrlParams;
+
+typedef struct {
+  char name[MAX_KEY_LEN];    
+  char value[MAX_VALUE_LEN]; 
+  char expires[MAX_VALUE_LEN]; 
+  char path[MAX_KEY_LEN];    
+  bool http_only;            
+  bool secure;               
+} Cookie;
+
+typedef int (*RequestHandler)(UrlParams *params);
+
+typedef struct {
+  char path[MAX_PATH_LEN];     
+  RequestHandler handler;      
+} RouteHandler;
+
+TemplateContext new_context();
+void context_set(TemplateContext *ctx, const char *key, const char *value);
+void context_set_string_array(TemplateContext *ctx, const char *key,
+                              char *values[], int count);
+void context_set_array_of_arrays(TemplateContext *ctx, const char *key,
+                                 char **values_2d[], int outer_count,
+                                 int inner_counts[]);
+void free_context(TemplateContext *ctx);
+char *render_template(const char *template_file, TemplateContext *ctx);
+
+void send_response(const char *html);
+void send_redirect(const char *location);
+void set_cookie(const char *name, const char *value, const char *expires,
+                const char *path, bool http_only, bool secure);
+char *get_cookie(const char *cookie_name);
+
+void set_handler(const char *path, RequestHandler handler);
+char *parse_request_url(const char *request_buffer, UrlParams *params);
+const char *get_mime_type(const char *file_path);
+bool serve_static_file(const char *request_path_relative_to_static);
+
+int beaker_run(const char *ip, int port);
+
+#endif 
diff --git a/examples/hello-world/Makefile b/examples/hello-world/Makefile
new file mode 100644
index 0000000..56813e3
--- /dev/null
+++ b/examples/hello-world/Makefile
@@ -0,0 +1,6 @@
+CC = gcc
+
+hello-world:
+	$(CC) -o hello-world main.c -lbeaker
+clean:
+	rm hello-world
\ No newline at end of file
diff --git a/examples/hello-world/main.c b/examples/hello-world/main.c
new file mode 100644
index 0000000..bf3c8b0
--- /dev/null
+++ b/examples/hello-world/main.c
@@ -0,0 +1,20 @@
+#include <beaker.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int hello_world_handler(UrlParams *params) {
+  send_response("Hello, World!");
+  return 0;
+}
+
+int main() {
+  set_handler("/", hello_world_handler);
+  int result = beaker_run("127.0.0.1", 8080);
+
+  if (result != 0) {
+    fprintf(stderr, "[APP] Error: Beaker server failed to start.\n");
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_SUCCESS;
+}
diff --git a/examples/template-demo/Makefile b/examples/template-demo/Makefile
new file mode 100644
index 0000000..ff0acd4
--- /dev/null
+++ b/examples/template-demo/Makefile
@@ -0,0 +1,6 @@
+CC = gcc
+
+template-demo:
+	$(CC) -o template-demo main.c -lbeaker
+clean:
+	rm template-demo
\ No newline at end of file
diff --git a/examples/template-demo/main.c b/examples/template-demo/main.c
new file mode 100644
index 0000000..2adbb52
--- /dev/null
+++ b/examples/template-demo/main.c
@@ -0,0 +1,74 @@
+#include <beaker.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+int templating_handler(UrlParams *params) {
+
+  TemplateContext ctx = new_context();
+
+  context_set(&ctx, "title", "Beaker Example");
+  context_set(&ctx, "page_heading", "Dynamic Content with Beaker Templates");
+  context_set(&ctx, "username", "John Doe");
+  context_set(&ctx, "favourite_colour", "blue");
+
+  time_t t = time(NULL);
+  struct tm *tm = localtime(&t);
+  char current_year_str[5];
+  snprintf(current_year_str, sizeof(current_year_str), "%d",
+           tm->tm_year + 1900);
+  context_set(&ctx, "current_year", current_year_str);
+
+  char timestamp_str[64];
+  strftime(timestamp_str, sizeof(timestamp_str), "%Y-%m-%d %H:%M:%S", tm);
+  context_set(&ctx, "timestamp", timestamp_str);
+
+  context_set(&ctx, "safe_html", "This is <b>bold</b> and <i>italic</i> HTML.");
+  context_set(&ctx, "unsafe_html", "<script>alert(0);");
+
+  char *features[] = {"Fast and Lightweight", "Simple API",
+                      "Basic Routing",        "Templating Engine",
+                      "Static File Serving",  "Cookie Management"};
+  int num_features = sizeof(features) / sizeof(features[0]);
+  context_set_string_array(&ctx, "features", features, num_features);
+
+  char *user1[] = {"Alice", "30", "New York"};
+  char *user2[] = {"Bob", "24", "Paris"};
+  char *user3[] = {"Charlie", "35", "London"};
+  char **users_2d[] = {user1, user2, user3};
+
+  int user_inner_counts[] = {3, 3, 3};
+  int num_users = sizeof(users_2d) / sizeof(users_2d[0]);
+  context_set_array_of_arrays(&ctx, "users", users_2d, num_users,
+                              user_inner_counts);
+
+  char *rendered_html = render_template("index.html", &ctx);
+  if (rendered_html == NULL) {
+    fprintf(stderr, "[APP] Error: Failed to render template.\n");
+    free_context(&ctx);
+    send_response(
+        "<h1>500 Internal Server Error</h1><p>Failed to render template.</p>");
+    return -1;
+  }
+
+  send_response(rendered_html);
+
+  free(rendered_html);
+  free_context(&ctx);
+
+  return 0;
+}
+
+int main() {
+
+  set_handler("/", templating_handler);
+
+  int result = beaker_run("127.0.0.1", 8080);
+
+  if (result != 0) {
+    fprintf(stderr, "[APP] Error: Beaker server failed to start.\n");
+    return EXIT_FAILURE;
+  }
+
+  return EXIT_SUCCESS;
+}
diff --git a/examples/template-demo/static/style.css b/examples/template-demo/static/style.css
new file mode 100644
index 0000000..1faafe4
--- /dev/null
+++ b/examples/template-demo/static/style.css
@@ -0,0 +1,67 @@
+body {
+	font-family: sans-serif;
+	margin: 20px;
+	background-color: #f4f7f6;
+	color: #333;
+	line-height: 1.6;
+}
+
+.container {
+	max-width: 800px;
+	margin: 0 auto;
+	background-color: #ffffff;
+	padding: 30px;
+	border-radius: 12px;
+	box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
+}
+
+h1,
+h2,
+h3 {
+	color: #2c3e50;
+	border-bottom: 2px solid #e0e0e0;
+	padding-bottom: 10px;
+	margin-top: 30px;
+}
+
+ul {
+	list-style-type: none;
+	padding: 0;
+}
+
+li {
+	background-color: #ecf0f1;
+	margin-bottom: 8px;
+	padding: 10px 15px;
+	border-radius: 8px;
+	display: flex;
+	align-items: center;
+}
+
+li:nth-child(odd) {
+	background-color: #e0e0e0;
+}
+
+.highlight {
+	font-weight: bold;
+	color: #2980b9;
+}
+
+.code-block {
+	background-color: #2c3e50;
+	color: #ecf0f1;
+	padding: 5px;
+	border-radius: 8px;
+	font-family: monospace;
+	overflow-x: auto;
+	margin-top: 15px;
+}
+
+.footer {
+	text-align: center;
+	margin-top: 40px;
+	padding-top: 20px;
+	border-top: 1px solid #e0e0e0;
+	color: #7f8c8d;
+	font-size: 0.9em;
+}
\ No newline at end of file
diff --git a/examples/template-demo/templates/header.html b/examples/template-demo/templates/header.html
new file mode 100644
index 0000000..746cee3
--- /dev/null
+++ b/examples/template-demo/templates/header.html
@@ -0,0 +1,8 @@
+<header style="text-align: center; padding-bottom: 20px; margin-bottom: 20px; border-bottom: 1px dashed #ccc;">
+    <h2 style="color: #34495e;">Beaker Templating Demonstration</h2>
+    <nav>
+        <a href="/" style="margin: 0 15px; text-decoration: none; color: #2980b9; font-weight: bold;">Home</a>
+        <a href="#" style="margin: 0 15px; text-decoration: none; color: #2980b9; font-weight: bold;">Nothing</a>
+
+    </nav>
+</header>
diff --git a/examples/template-demo/templates/index.html b/examples/template-demo/templates/index.html
new file mode 100644
index 0000000..837688f
--- /dev/null
+++ b/examples/template-demo/templates/index.html
@@ -0,0 +1,48 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{title}}</title>
+    <link rel="stylesheet" href="/static/style.css">
+</head>
+<body>
+    <div class="container">
+        {{include "header.html"}}
+
+        <h1>{{page_heading}}</h1>
+
+        <p>Welcome, <span class="highlight">{{username}}</span>! This page demonstrates the templating capabilities of the Beaker web framework.</p>
+
+        <h2>Simple Variable Substitution</h2>
+        <p>Your favourite colour is: <span class="highlight">{{favourite_colour}}</span></p>
+        <p>The current year is: <span class="highlight">{{current_year}}</span></p>
+        <p>This is a safe string: <span class="code-block">{{safe_html|safe}}</span></p>
+        <p>This is an unsafe string (will be escaped): <span class="code-block">{{unsafe_html}}</span></p>
+
+        <h2>List of Features (String Array)</h2>
+        <p>Here are some features:</p>
+        <ul>
+            {{for feature in features}}
+                <li>{{feature}}</li>
+            {{endfor}}
+        </ul>
+
+        <h2>User Data (Array of Arrays)</h2>
+        <p>Here's some user information:</p>
+        <ul>
+            {{for user_row in users}}
+                <li>
+                    Name: <span class="highlight">{{user_row[0]}}</span>,
+                    Age: <span class="highlight">{{user_row[1]}}</span>,
+                    City: <span class="highlight">{{user_row[2]}}</span>
+                </li>
+            {{endfor}}
+        </ul>
+
+        <div class="footer">
+            <p>Rendered at: {{timestamp}}</p>
+        </div>
+    </div>
+</body>
+</html>
diff --git a/src/beaker_globals.c b/src/beaker_globals.c
new file mode 100644
index 0000000..2ea5ab6
--- /dev/null
+++ b/src/beaker_globals.c
@@ -0,0 +1,13 @@
+#include "beaker_globals.h" 
+
+RouteHandler handlers[MAX_HANDLERS];
+
+int handler_count = 0;
+
+int current_client_socket = -1;
+
+Cookie cookies_to_set[MAX_COOKIES];
+
+int cookies_to_set_count = 0;
+
+char current_request_buffer[BUFFER_SIZE];
\ No newline at end of file
diff --git a/src/beaker_globals.h b/src/beaker_globals.h
new file mode 100644
index 0000000..94aabdf
--- /dev/null
+++ b/src/beaker_globals.h
@@ -0,0 +1,18 @@
+#ifndef BEAKER_GLOBALS_H 
+#define BEAKER_GLOBALS_H
+
+#include "../beaker.h" 
+
+extern RouteHandler handlers[MAX_HANDLERS];
+
+extern int handler_count;
+
+extern int current_client_socket;
+
+extern Cookie cookies_to_set[MAX_COOKIES];
+
+extern int cookies_to_set_count;
+
+extern char current_request_buffer[BUFFER_SIZE];
+
+#endif 
\ No newline at end of file
diff --git a/src/http.c b/src/http.c
new file mode 100644
index 0000000..349f66f
--- /dev/null
+++ b/src/http.c
@@ -0,0 +1,216 @@
+#include "../beaker.h"        
+#include "beaker_globals.h"   
+#include <stdio.h>            
+#include <stdlib.h>           
+#include <string.h>           
+#include <sys/socket.h>       
+#include <unistd.h>           
+
+static void build_cookie_headers(char *cookie_headers_buffer,
+                                 size_t buffer_size) {
+
+  cookie_headers_buffer[0] = '\0';
+
+  for (int i = 0; i < cookies_to_set_count; i++) {
+    char single_cookie_header[MAX_VALUE_LEN * 2]; 
+
+    snprintf(single_cookie_header, sizeof(single_cookie_header),
+             "Set-Cookie: %s=%s", cookies_to_set[i].name,
+             cookies_to_set[i].value);
+
+    if (strlen(cookies_to_set[i].expires) > 0) {
+      strcat(single_cookie_header, "; Expires=");
+      strcat(single_cookie_header, cookies_to_set[i].expires);
+    }
+
+    if (strlen(cookies_to_set[i].path) > 0) {
+      strcat(single_cookie_header, "; Path=");
+      strcat(single_cookie_header, cookies_to_set[i].path);
+    }
+
+    if (cookies_to_set[i].http_only) {
+      strcat(single_cookie_header, "; HttpOnly");
+    }
+
+    if (cookies_to_set[i].secure) {
+      strcat(single_cookie_header, "; Secure");
+    }
+
+    strcat(single_cookie_header, "\r\n");
+
+    strncat(cookie_headers_buffer, single_cookie_header,
+            buffer_size - strlen(cookie_headers_buffer) - 1);
+  }
+}
+
+void send_response(const char *html) {
+
+  if (current_client_socket == -1) {
+    fprintf(stderr, "[ERROR] send_response: No client socket set. Cannot send response.\n");
+    return;
+  }
+
+  char http_response_header[BUFFER_SIZE * 2]; 
+  int content_length = strlen(html);          
+  char cookie_headers[BUFFER_SIZE];           
+
+  build_cookie_headers(cookie_headers, sizeof(cookie_headers));
+
+  snprintf(http_response_header, sizeof(http_response_header),
+           "HTTP/1.1 200 OK\r\n"
+           "Content-Type: text/html; charset=UTF-8\r\n"
+           "Content-Length: %d\r\n"
+           "%s" 
+           "Connection: close\r\n" 
+           "\r\n",                
+           content_length, cookie_headers);
+
+  if (send(current_client_socket, http_response_header,
+           strlen(http_response_header), 0) < 0) {
+    perror("Error sending HTTP header");
+    fprintf(stderr, "[ERROR] send_response: Failed to send HTTP header.\n");
+    return;
+  }
+
+  if (send(current_client_socket, html, content_length, 0) < 0) {
+    perror("Error sending HTML body");
+    fprintf(stderr, "[ERROR] send_response: Failed to send HTML body.\n");
+    return;
+  }
+
+  cookies_to_set_count = 0;
+}
+
+void send_redirect(const char *location) {
+
+  if (current_client_socket == -1) {
+    fprintf(stderr, "[ERROR] send_redirect: No client socket set. Cannot send redirect.\n");
+    return;
+  }
+
+  char http_response_header[BUFFER_SIZE]; 
+
+  snprintf(http_response_header, sizeof(http_response_header),
+           "HTTP/1.1 302 Found\r\n"
+           "Location: %s\r\n"      
+           "Connection: close\r\n" 
+           "\r\n",                
+           location);
+
+  if (send(current_client_socket, http_response_header,
+           strlen(http_response_header), 0) < 0) {
+    perror("Error sending redirect header");
+    fprintf(stderr, "[ERROR] send_redirect: Failed to send redirect header.\n");
+    return;
+  }
+
+  cookies_to_set_count = 0;
+}
+
+void set_cookie(const char *name, const char *value, const char *expires,
+                const char *path, bool http_only, bool secure) {
+
+  if (cookies_to_set_count >= MAX_COOKIES) {
+    fprintf(stderr,
+            "[WARNING] set_cookie: Maximum number of cookies to set reached. Cannot set cookie '%s'.\n",
+            name);
+    return;
+  }
+
+  Cookie *new_cookie = &cookies_to_set[cookies_to_set_count];
+
+  strncpy(new_cookie->name, name, MAX_KEY_LEN - 1);
+  new_cookie->name[MAX_KEY_LEN - 1] = '\0';
+
+  strncpy(new_cookie->value, value, MAX_VALUE_LEN - 1);
+  new_cookie->value[MAX_VALUE_LEN - 1] = '\0';
+
+  if (expires && strlen(expires) > 0) {
+    strncpy(new_cookie->expires, expires, MAX_VALUE_LEN - 1);
+    new_cookie->expires[MAX_VALUE_LEN - 1] = '\0';
+  } else {
+    new_cookie->expires[0] = '\0';
+  }
+
+  if (path && strlen(path) > 0) {
+    strncpy(new_cookie->path, path, MAX_KEY_LEN - 1);
+    new_cookie->path[MAX_KEY_LEN - 1] = '\0';
+  } else {
+    new_cookie->path[0] = '\0';
+  }
+
+  new_cookie->http_only = http_only;
+  new_cookie->secure = secure;
+
+  cookies_to_set_count++;
+}
+
+char *get_cookie(const char *cookie_name) {
+
+  char *cookie_header_start = strstr(current_request_buffer, "\r\nCookie: ");
+  if (cookie_header_start == NULL) {
+    return NULL; 
+  }
+
+  cookie_header_start += strlen("\r\nCookie: ");
+
+  char *cookie_header_end = strstr(cookie_header_start, "\r\n");
+  if (cookie_header_end == NULL) {
+
+    cookie_header_end = (char *)(current_request_buffer + strlen(current_request_buffer));
+  }
+
+  size_t cookie_str_len = cookie_header_end - cookie_header_start;
+  char *cookie_str = (char *)malloc(cookie_str_len + 1);
+  if (cookie_str == NULL) {
+    perror("Failed to allocate memory for raw cookie string");
+    fprintf(stderr, "[ERROR] get_cookie: Allocation failed for cookie_str.\n");
+    return NULL;
+  }
+
+  strncpy(cookie_str, cookie_header_start, cookie_str_len);
+  cookie_str[cookie_str_len] = '\0'; 
+
+  char *cookie_str_copy = strdup(cookie_str);
+  if (cookie_str_copy == NULL) {
+    perror("Failed to duplicate cookie string for strtok_r");
+    fprintf(stderr, "[ERROR] get_cookie: Duplication failed for cookie_str_copy.\n");
+    free(cookie_str); 
+    return NULL;
+  }
+
+  char *token;          
+  char *saveptr_cookie; 
+
+  token = strtok_r(cookie_str_copy, ";", &saveptr_cookie);
+  while (token != NULL) {
+
+    while (*token == ' ') {
+      token++;
+    }
+
+    char *equals_sign = strchr(token, '=');
+    if (equals_sign != NULL) {
+      size_t name_len = equals_sign - token; 
+
+      if (name_len == strlen(cookie_name) &&
+          strncmp(token, cookie_name, name_len) == 0) {
+
+        char *cookie_value = strdup(equals_sign + 1);
+        if (cookie_value == NULL) {
+          perror("Failed to duplicate cookie value");
+          fprintf(stderr, "[ERROR] get_cookie: Allocation failed for cookie_value.\n");
+        }
+        free(cookie_str);      
+        free(cookie_str_copy); 
+        return cookie_value;   
+      }
+    }
+
+    token = strtok_r(NULL, ";", &saveptr_cookie);
+  }
+
+  free(cookie_str);      
+  free(cookie_str_copy); 
+  return NULL;
+}
\ No newline at end of file
diff --git a/src/routing.c b/src/routing.c
new file mode 100644
index 0000000..156e843
--- /dev/null
+++ b/src/routing.c
@@ -0,0 +1,226 @@
+#include "../beaker.h"        
+#include "beaker_globals.h"   
+#include <stdio.h>            
+#include <stdlib.h>           
+#include <string.h>           
+#include <sys/socket.h>       
+#include <sys/stat.h>         
+#include <unistd.h>           
+#include <errno.h>
+
+void set_handler(const char *path, RequestHandler handler) {
+
+  if (handler_count < MAX_HANDLERS) {
+
+    strncpy(handlers[handler_count].path, path, MAX_PATH_LEN - 1);
+    handlers[handler_count].path[MAX_PATH_LEN - 1] = '\0';
+
+    handlers[handler_count].handler = handler;
+
+    handler_count++;
+  } else {
+
+    fprintf(stderr,
+            "[WARNING] set_handler: Maximum number of handlers reached. Cannot register handler for '%s'.\n",
+            path);
+  }
+}
+
+char *parse_request_url(const char *request_line, UrlParams *params) {
+  char method[16];                     
+  char path_with_query_buffer[MAX_PATH_LEN]; 
+  char http_version[16];               
+
+  if (sscanf(request_line, "%15s %255s %15s", method, path_with_query_buffer,
+             http_version) != 3) {
+    fprintf(stderr, "[ERROR] parse_request_url: Malformed request line: '%s'\n",
+            request_line);
+    return NULL;
+  }
+
+  params->count = 0; 
+
+  char *working_url_copy = strdup(path_with_query_buffer);
+  if (working_url_copy == NULL) {
+    perror("Failed to allocate memory for working URL copy");
+    return NULL;
+  }
+
+  char *query_start = strchr(working_url_copy, '?'); 
+  char *path_only_for_return; 
+
+  if (query_start != NULL) {
+    *query_start = '\0'; 
+    path_only_for_return = working_url_copy; 
+    char *query_string = query_start + 1;    
+
+    char *token;          
+    char *saveptr_query;  
+
+    token = strtok_r(query_string, "&", &saveptr_query);
+    while (token != NULL && params->count < MAX_URL_PARAMS) {
+      char *equals_sign = strchr(token, '='); 
+      if (equals_sign != NULL) {
+        size_t key_len = equals_sign - token; 
+
+        strncpy(params->params[params->count].key, token, key_len);
+        params->params[params->count].key[key_len] = '\0'; 
+        strncpy(params->params[params->count].value, equals_sign + 1,
+                MAX_VALUE_LEN - 1);
+        params->params[params->count].value[MAX_VALUE_LEN - 1] = '\0'; 
+        params->count++; 
+      }
+      token = strtok_r(NULL, "&", &saveptr_query); 
+    }
+  } else {
+
+    path_only_for_return = working_url_copy;
+  }
+
+  char *final_requested_path = strdup(path_only_for_return);
+  if (final_requested_path == NULL) {
+    perror("Failed to allocate final requested path");
+    free(working_url_copy); 
+    return NULL;
+  }
+
+  char *segment;          
+  int segment_index = 0;  
+  char *saveptr_path;     
+
+  segment = strtok_r(working_url_copy, "/", &saveptr_path);
+  while (segment != NULL) {
+
+    if (segment_index > 0) {
+      if (params->count < MAX_URL_PARAMS) {
+        char param_key[MAX_KEY_LEN];
+
+        snprintf(param_key, sizeof(param_key), "param%d", segment_index - 1);
+
+        strncpy(params->params[params->count].key, param_key, MAX_KEY_LEN - 1);
+        params->params[params->count].key[MAX_KEY_LEN - 1] = '\0';
+        strncpy(params->params[params->count].value, segment,
+                MAX_VALUE_LEN - 1);
+        params->params[params->count].value[MAX_VALUE_LEN - 1] = '\0';
+        params->count++;
+      } else {
+        fprintf(stderr,
+                "[WARNING] parse_request_url: Max URL parameters reached. Skipping path segment '%s'.\n",
+                segment);
+      }
+    }
+    segment_index++;
+    segment = strtok_r(NULL, "/", &saveptr_path); 
+  }
+
+  free(working_url_copy); 
+
+  return final_requested_path; 
+}
+
+const char *get_mime_type(const char *file_path) {
+
+  const char *ext = strrchr(file_path, '.');
+  if (!ext) {
+    return "application/octet-stream"; 
+  }
+  ext++; 
+
+  if (strcmp(ext, "html") == 0 || strcmp(ext, "htm") == 0)
+    return "text/html";
+  if (strcmp(ext, "css") == 0)
+    return "text/css";
+  if (strcmp(ext, "js") == 0)
+    return "application/javascript";
+  if (strcmp(ext, "json") == 0)
+    return "application/json";
+  if (strcmp(ext, "jpg") == 0 || strcmp(ext, "jpeg") == 0)
+    return "image/jpeg";
+  if (strcmp(ext, "png") == 0)
+    return "image/png";
+  if (strcmp(ext, "gif") == 0)
+    return "image/gif";
+  if (strcmp(ext, "ico") == 0)
+    return "image/x-icon";
+  if (strcmp(ext, "svg") == 0)
+    return "image/svg+xml";
+  if (strcmp(ext, "pdf") == 0)
+    return "application/pdf";
+  if (strcmp(ext, "txt") == 0)
+    return "text/plain";
+
+  return "application/octet-stream";
+}
+
+bool serve_static_file(const char *request_path_relative_to_static) {
+  char full_static_path[MAX_PATH_LEN]; 
+
+  if (strstr(request_path_relative_to_static, "..") != NULL) {
+    fprintf(stderr, "[SECURITY] Attempted directory traversal: %s\n",
+            request_path_relative_to_static);
+
+    const char *forbidden_response =
+        "HTTP/1.1 403 Forbidden\r\nContent-Length: 0\r\n\r\n";
+    send(current_client_socket, forbidden_response, strlen(forbidden_response), 0);
+    return true; 
+  }
+
+  snprintf(full_static_path, sizeof(full_static_path), "%s%s", STATIC_DIR,
+           request_path_relative_to_static);
+
+  FILE *fp = fopen(full_static_path, "rb");
+  if (fp == NULL) {
+    fprintf(stderr,
+            "[ERROR] serve_static_file: File '%s' not found or could not be opened. %s\n",
+            full_static_path, strerror(errno)); 
+    return false; 
+  }
+
+  struct stat st; 
+
+  if (fstat(fileno(fp), &st) < 0) {
+    perror("fstat error");
+    fprintf(stderr, "[ERROR] serve_static_file: fstat failed for '%s'.\n",
+            full_static_path);
+    fclose(fp); 
+
+    const char *server_error_response =
+        "HTTP/1.1 500 Internal Server Error\r\nContent-Length: 0\r\n\r\n";
+    send(current_client_socket, server_error_response, strlen(server_error_response), 0);
+    return true; 
+  }
+
+  long file_size = st.st_size; 
+  const char *mime_type = get_mime_type(full_static_path); 
+
+  char http_header[BUFFER_SIZE]; 
+
+  snprintf(http_header, sizeof(http_header),
+           "HTTP/1.1 200 OK\r\n"
+           "Content-Type: %s\r\n"      
+           "Content-Length: %ld\r\n"   
+           "Connection: close\r\n"     
+           "\r\n",                    
+           mime_type, file_size);
+
+  if (send(current_client_socket, http_header, strlen(http_header), 0) < 0) {
+    perror("Error sending static file header");
+    fprintf(stderr, "[ERROR] serve_static_file: Failed to send header for '%s'.\n", full_static_path);
+    fclose(fp);
+    return true; 
+  }
+
+  char file_buffer[BUFFER_SIZE]; 
+  size_t bytes_read;             
+
+  while ((bytes_read = fread(file_buffer, 1, sizeof(file_buffer), fp)) > 0) {
+    if (send(current_client_socket, file_buffer, bytes_read, 0) < 0) {
+      perror("Error sending static file content");
+      fprintf(stderr, "[ERROR] serve_static_file: Failed to send content for '%s'.\n", full_static_path);
+      break; 
+    }
+  }
+
+  fclose(fp); 
+  return true; 
+}
\ No newline at end of file
diff --git a/src/server.c b/src/server.c
new file mode 100644
index 0000000..e6a460a
--- /dev/null
+++ b/src/server.c
@@ -0,0 +1,181 @@
+#include "../beaker.h"        
+#include "beaker_globals.h"   
+#include <arpa/inet.h>        
+#include <netinet/in.h>       
+#include <stdbool.h>          
+#include <stdio.h>            
+#include <string.h>           
+#include <sys/socket.h>       
+#include <unistd.h>           
+
+static int initialize_server_socket(const char *ip, int port, int *server_fd_out,
+                                    struct sockaddr_in *address_out) {
+
+  if ((*server_fd_out = socket(AF_INET, SOCK_STREAM, 0)) == 0) {
+    perror("socket failed");
+    fprintf(stderr, "[ERROR] initialize_server_socket: Failed to create socket.\n");
+    return -1;
+  }
+
+  int opt = 1;
+  if (setsockopt(*server_fd_out, SOL_SOCKET, SO_REUSEADDR | SO_REUSEPORT, &opt,
+                 sizeof(opt))) {
+    perror("setsockopt failed");
+    fprintf(stderr, "[ERROR] initialize_server_socket: Failed to set socket options.\n");
+    close(*server_fd_out);
+    return -1;
+  }
+
+  address_out->sin_family = AF_INET;           
+  address_out->sin_addr.s_addr = inet_addr(ip); 
+  address_out->sin_port = htons(port);         
+
+  if (bind(*server_fd_out, (struct sockaddr *)address_out, sizeof(*address_out)) < 0) {
+    perror("bind failed");
+    fprintf(stderr, "[ERROR] initialize_server_socket: Failed to bind socket to %s:%d.\n", ip, port);
+    close(*server_fd_out);
+    return -1;
+  }
+
+  if (listen(*server_fd_out, 10) < 0) {
+    perror("listen failed");
+    fprintf(stderr, "[ERROR] initialize_server_socket: Failed to listen on socket.\n");
+    close(*server_fd_out);
+    return -1;
+  }
+
+  printf("Beaker server listening on %s:%d\n", ip, port);
+  return 0;
+}
+
+static void handle_client_connection(int new_socket) {
+  current_client_socket = new_socket; 
+  char buffer[BUFFER_SIZE] = {0};     
+
+  ssize_t bytes_read = read(new_socket, buffer, BUFFER_SIZE - 1);
+  if (bytes_read < 0) {
+    perror("read failed");
+    fprintf(stderr, "[ERROR] handle_client_connection: Failed to read from client socket.\n");
+    close(new_socket);
+    return;
+  }
+  buffer[bytes_read] = '\0'; 
+
+  strncpy(current_request_buffer, buffer, BUFFER_SIZE - 1);
+  current_request_buffer[BUFFER_SIZE - 1] = '\0';
+
+  char request_line[MAX_PATH_LEN + 64]; 
+  char *first_line_end = strstr(buffer, "\r\n"); 
+
+  if (first_line_end == NULL) {
+    fprintf(stderr, "[ERROR] handle_client_connection: Invalid HTTP request: No CRLF found.\n");
+    const char *bad_request = "HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\n\r\n";
+    send(new_socket, bad_request, strlen(bad_request), 0);
+    close(new_socket);
+    return;
+  }
+  size_t request_line_len = first_line_end - buffer;
+  if (request_line_len >= sizeof(request_line)) {
+    fprintf(stderr, "[ERROR] handle_client_connection: Request line too long.\n");
+    const char *bad_request = "HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\n\r\n";
+    send(new_socket, bad_request, strlen(bad_request), 0);
+    close(new_socket);
+    return;
+  }
+  strncpy(request_line, buffer, request_line_len);
+  request_line[request_line_len] = '\0'; 
+
+  UrlParams request_params; 
+  char *requested_path = parse_request_url(request_line, &request_params); 
+
+  if (requested_path == NULL) {
+    fprintf(stderr, "[ERROR] handle_client_connection: Could not parse request path. Sending 400 Bad Request.\n");
+    const char *bad_request = "HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\n\r\n";
+    send(new_socket, bad_request, strlen(bad_request), 0);
+    close(new_socket);
+    return;
+  }
+  printf("Accessing: %s\n", requested_path); 
+
+  bool handled = false; 
+
+  if (strncmp(requested_path, "/static/", strlen("/static/")) == 0) {
+
+    if (serve_static_file(requested_path + strlen("/static/"))) {
+      handled = true; 
+    }
+  }
+
+  if (!handled) {
+    int best_match_handler_index = -1; 
+    size_t best_match_len = 0;         
+
+    for (int i = 0; i < handler_count; i++) {
+      size_t handler_path_len = strlen(handlers[i].path);
+
+      if (strncmp(requested_path, handlers[i].path, handler_path_len) == 0) {
+
+        if (handler_path_len == strlen(requested_path) ||
+            requested_path[handler_path_len] == '/') {
+
+          if (handler_path_len > best_match_len) {
+            best_match_len = handler_path_len;
+            best_match_handler_index = i;
+          }
+        }
+      }
+    }
+
+    if (best_match_handler_index != -1) {
+      handlers[best_match_handler_index].handler(&request_params);
+      handled = true; 
+    }
+  }
+
+  if (!handled) {
+    fprintf(stderr,
+            "[WARNING] handle_client_connection: No handler or static file found for path '%s'. Sending 404 Not Found.\n",
+            requested_path);
+    const char *not_found_html = "<h1>404 Not Found</h1><p>The requested URL "
+                                 "was not located on this server.</p>";
+    char not_found_response[BUFFER_SIZE];
+    snprintf(not_found_response, sizeof(not_found_response),
+             "HTTP/1.1 404 Not Found\r\n"
+             "Content-Type: text/html; charset=UTF-8\r\n"
+             "Content-Length: %zu\r\n"
+             "Connection: close\r\n"
+             "\r\n%s",
+             strlen(not_found_html), not_found_html);
+    send(new_socket, not_found_response, strlen(not_found_response), 0);
+  }
+
+  free(requested_path); 
+  close(new_socket);    
+  current_client_socket = -1; 
+}
+
+int beaker_run(const char *ip, int port) {
+  int server_fd;            
+  struct sockaddr_in address; 
+  int addrlen = sizeof(address); 
+
+  if (initialize_server_socket(ip, port, &server_fd, &address) != 0) {
+    return -1; 
+  }
+
+  while (true) {
+    int new_socket; 
+
+    if ((new_socket = accept(server_fd, (struct sockaddr *)&address,
+                             (socklen_t *)&addrlen)) < 0) {
+      perror("accept failed");
+      fprintf(stderr, "[ERROR] beaker_run: Failed to accept connection.\n");
+      continue; 
+    }
+
+    handle_client_connection(new_socket);
+  }
+
+  close(server_fd); 
+  return 0;
+}
\ No newline at end of file
diff --git a/src/template.c b/src/template.c
new file mode 100644
index 0000000..494b011
--- /dev/null
+++ b/src/template.c
@@ -0,0 +1,961 @@
+#include "../beaker.h"
+#include <errno.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static char *render_template_segment(const char *template_segment,
+                                     TemplateContext *ctx);
+
+static ContextVar *find_context_var(TemplateContext *ctx, const char *key) {
+  if (ctx == NULL || key == NULL) {
+    fprintf(stderr,
+            "[ERROR] find_context_var: Invalid NULL input (ctx or key).\n");
+    return NULL;
+  }
+  for (int i = 0; i < ctx->count; i++) {
+    if (strcmp(ctx->vars[i].key, key) == 0) {
+      return &ctx->vars[i];
+    }
+  }
+  return NULL;
+}
+
+static void free_string_array_var(ContextVar *var) {
+  if (var == NULL || var->value.string_array_data.values == NULL) {
+    return;
+  }
+  for (int i = 0; i < var->value.string_array_data.count; i++) {
+    if (var->value.string_array_data.values[i] != NULL) {
+      free(var->value.string_array_data.values[i]);
+      var->value.string_array_data.values[i] = NULL;
+    }
+  }
+  free(var->value.string_array_data.values);
+  var->value.string_array_data.values = NULL;
+  var->value.string_array_data.count = 0;
+}
+
+static void free_string_2d_array_var(ContextVar *var) {
+  if (var == NULL || var->value.string_2d_array_data.values == NULL) {
+    return;
+  }
+  for (int i = 0; i < var->value.string_2d_array_data.outer_count; i++) {
+    if (var->value.string_2d_array_data.values[i] != NULL) {
+      for (int j = 0; j < var->value.string_2d_array_data.inner_counts[i];
+           j++) {
+        if (var->value.string_2d_array_data.values[i][j] != NULL) {
+          free(var->value.string_2d_array_data.values[i][j]);
+          var->value.string_2d_array_data.values[i][j] = NULL;
+        }
+      }
+      free(var->value.string_2d_array_data.values[i]);
+      var->value.string_2d_array_data.values[i] = NULL;
+    }
+  }
+  free(var->value.string_2d_array_data.values);
+  var->value.string_2d_array_data.values = NULL;
+
+  if (var->value.string_2d_array_data.inner_counts != NULL) {
+    free(var->value.string_2d_array_data.inner_counts);
+    var->value.string_2d_array_data.inner_counts = NULL;
+  }
+  var->value.string_2d_array_data.outer_count = 0;
+}
+
+TemplateContext new_context() {
+  TemplateContext ctx;
+  ctx.count = 0;
+  return ctx;
+}
+
+void context_set(TemplateContext *ctx, const char *key, const char *value) {
+  if (ctx == NULL || key == NULL || value == NULL) {
+    fprintf(stderr,
+            "[ERROR] context_set: Invalid NULL input (ctx, key, or value).\n");
+    return;
+  }
+
+  ContextVar *var = find_context_var(ctx, key);
+  if (var != NULL) {
+
+    if (var->type == CONTEXT_TYPE_STRING_ARRAY) {
+      free_string_array_var(var);
+    } else if (var->type == CONTEXT_TYPE_STRING_2D_ARRAY) {
+      free_string_2d_array_var(var);
+    }
+
+    strncpy(var->value.string_val, value, MAX_VALUE_LEN - 1);
+    var->value.string_val[MAX_VALUE_LEN - 1] = '\0';
+    var->type = CONTEXT_TYPE_STRING;
+    return;
+  }
+
+  if (ctx->count < MAX_CONTEXT_VARS) {
+    ContextVar *new_var = &ctx->vars[ctx->count];
+    strncpy(new_var->key, key, MAX_KEY_LEN - 1);
+    new_var->key[MAX_KEY_LEN - 1] = '\0';
+    strncpy(new_var->value.string_val, value, MAX_VALUE_LEN - 1);
+    new_var->value.string_val[MAX_VALUE_LEN - 1] = '\0';
+    new_var->type = CONTEXT_TYPE_STRING;
+    ctx->count++;
+  } else {
+    fprintf(stderr,
+            "[WARNING] context_set: TemplateContext is full. Cannot add key "
+            "'%s'.\n",
+            key);
+  }
+}
+
+void context_set_string_array(TemplateContext *ctx, const char *key,
+                              char *values[], int count) {
+  if (ctx == NULL || key == NULL || values == NULL) {
+    fprintf(stderr, "[ERROR] context_set_string_array: Invalid NULL input "
+                    "(ctx, key, or values).\n");
+    return;
+  }
+  if (count < 0 || count > MAX_OUTER_ARRAY_ITEMS) {
+    fprintf(stderr,
+            "[ERROR] context_set_string_array: Invalid count %d for string "
+            "array context '%s'. Max %d allowed.\n",
+            count, key, MAX_OUTER_ARRAY_ITEMS);
+    return;
+  }
+
+  ContextVar *var = find_context_var(ctx, key);
+  if (var != NULL) {
+
+    if (var->type == CONTEXT_TYPE_STRING_ARRAY) {
+      free_string_array_var(var);
+    } else if (var->type == CONTEXT_TYPE_STRING_2D_ARRAY) {
+      free_string_2d_array_var(var);
+    }
+  } else {
+
+    if (ctx->count < MAX_CONTEXT_VARS) {
+      var = &ctx->vars[ctx->count];
+      strncpy(var->key, key, MAX_KEY_LEN - 1);
+      var->key[MAX_KEY_LEN - 1] = '\0';
+      ctx->count++;
+    } else {
+      fprintf(stderr,
+              "[WARNING] context_set_string_array: TemplateContext is full. "
+              "Cannot add string array key '%s'.\n",
+              key);
+      return;
+    }
+  }
+
+  var->type = CONTEXT_TYPE_STRING_ARRAY;
+  var->value.string_array_data.values = (char **)malloc(sizeof(char *) * count);
+  if (var->value.string_array_data.values == NULL) {
+    perror("Failed to allocate memory for string array pointers");
+    fprintf(stderr,
+            "[ERROR] context_set_string_array: Allocation failed for values "
+            "for key '%s'.\n",
+            key);
+    return;
+  }
+  var->value.string_array_data.count = count;
+
+  for (int i = 0; i < count; i++) {
+    if (values[i] == NULL) {
+      fprintf(stderr,
+              "[ERROR] context_set_string_array: NULL value at index %d for "
+              "key '%s'. Skipping.\n",
+              i, key);
+      var->value.string_array_data.values[i] = NULL;
+      continue;
+    }
+    var->value.string_array_data.values[i] = strdup(values[i]);
+    if (var->value.string_array_data.values[i] == NULL) {
+      perror("Failed to duplicate string for string array context");
+      fprintf(stderr,
+              "[ERROR] context_set_string_array: Failed to duplicate value for "
+              "item %d of key '%s'.\n",
+              i, key);
+
+      for (int j = 0; j < i; j++) {
+        if (var->value.string_array_data.values[j] != NULL) {
+          free(var->value.string_array_data.values[j]);
+        }
+      }
+      free(var->value.string_array_data.values);
+      var->value.string_array_data.values = NULL;
+      var->value.string_array_data.count = 0;
+      return;
+    }
+  }
+}
+
+void context_set_array_of_arrays(TemplateContext *ctx, const char *key,
+                                 char **values_2d[], int outer_count,
+                                 int inner_counts[]) {
+  if (ctx == NULL || key == NULL || values_2d == NULL || inner_counts == NULL) {
+    fprintf(stderr, "[ERROR] context_set_array_of_arrays: Invalid NULL input "
+                    "(ctx, key, values_2d, or inner_counts).\n");
+    return;
+  }
+  if (outer_count < 0 || outer_count > MAX_OUTER_ARRAY_ITEMS) {
+    fprintf(stderr,
+            "[ERROR] context_set_array_of_arrays: Invalid outer count %d for "
+            "array of arrays context '%s'. Max %d allowed.\n",
+            outer_count, key, MAX_OUTER_ARRAY_ITEMS);
+    return;
+  }
+
+  ContextVar *var = find_context_var(ctx, key);
+  if (var != NULL) {
+
+    if (var->type == CONTEXT_TYPE_STRING_ARRAY) {
+      free_string_array_var(var);
+    } else if (var->type == CONTEXT_TYPE_STRING_2D_ARRAY) {
+      free_string_2d_array_var(var);
+    }
+  } else {
+
+    if (ctx->count < MAX_CONTEXT_VARS) {
+      var = &ctx->vars[ctx->count];
+      strncpy(var->key, key, MAX_KEY_LEN - 1);
+      var->key[MAX_KEY_LEN - 1] = '\0';
+      ctx->count++;
+    } else {
+      fprintf(stderr,
+              "[WARNING] context_set_array_of_arrays: TemplateContext is full. "
+              "Cannot add array of arrays key '%s'.\n",
+              key);
+      return;
+    }
+  }
+
+  var->type = CONTEXT_TYPE_STRING_2D_ARRAY;
+  var->value.string_2d_array_data.values =
+      (char ***)malloc(sizeof(char **) * outer_count);
+  var->value.string_2d_array_data.inner_counts =
+      (int *)malloc(sizeof(int) * outer_count);
+
+  if (var->value.string_2d_array_data.values == NULL ||
+      var->value.string_2d_array_data.inner_counts == NULL) {
+    perror("Failed to allocate memory for 2D string array pointers or counts");
+    fprintf(stderr,
+            "[ERROR] context_set_array_of_arrays: Allocation failed for key "
+            "'%s'.\n",
+            key);
+    free(var->value.string_2d_array_data.values);
+    free(var->value.string_2d_array_data.inner_counts);
+    var->value.string_2d_array_data.values = NULL;
+    var->value.string_2d_array_data.inner_counts = NULL;
+    return;
+  }
+  var->value.string_2d_array_data.outer_count = outer_count;
+
+  for (int i = 0; i < outer_count; i++) {
+    int current_inner_count = inner_counts[i];
+    if (current_inner_count < 0 ||
+        current_inner_count > MAX_INNER_ARRAY_ITEMS) {
+      fprintf(stderr,
+              "[ERROR] context_set_array_of_arrays: Invalid inner count %d for "
+              "item %d in 2D array '%s'. Max %d allowed.\n",
+              current_inner_count, i, key, MAX_INNER_ARRAY_ITEMS);
+
+      for (int k = 0; k < i; k++) {
+        if (var->value.string_2d_array_data.values[k] != NULL) {
+          for (int l = 0; l < var->value.string_2d_array_data.inner_counts[k];
+               l++) {
+            if (var->value.string_2d_array_data.values[k][l] != NULL) {
+              free(var->value.string_2d_array_data.values[k][l]);
+            }
+          }
+          free(var->value.string_2d_array_data.values[k]);
+        }
+      }
+      free(var->value.string_2d_array_data.values);
+      free(var->value.string_2d_array_data.inner_counts);
+      var->value.string_2d_array_data.values = NULL;
+      var->value.string_2d_array_data.inner_counts = NULL;
+      return;
+    }
+
+    var->value.string_2d_array_data.values[i] =
+        (char **)malloc(sizeof(char *) * current_inner_count);
+    if (var->value.string_2d_array_data.values[i] == NULL) {
+      perror("Failed to allocate memory for inner string array pointers");
+      fprintf(stderr,
+              "[ERROR] context_set_array_of_arrays: Allocation failed for "
+              "inner array %d of key '%s'.\n",
+              i, key);
+
+      for (int k = 0; k < i; k++) {
+        if (var->value.string_2d_array_data.values[k] != NULL) {
+          for (int l = 0; l < var->value.string_2d_array_data.inner_counts[k];
+               l++) {
+            if (var->value.string_2d_array_data.values[k][l] != NULL) {
+              free(var->value.string_2d_array_data.values[k][l]);
+            }
+          }
+          free(var->value.string_2d_array_data.values[k]);
+        }
+      }
+      free(var->value.string_2d_array_data.values);
+      free(var->value.string_2d_array_data.inner_counts);
+      var->value.string_2d_array_data.values = NULL;
+      var->value.string_2d_array_data.inner_counts = NULL;
+      return;
+    }
+    var->value.string_2d_array_data.inner_counts[i] = current_inner_count;
+
+    for (int j = 0; j < current_inner_count; j++) {
+      if (values_2d[i][j] == NULL) {
+        fprintf(stderr,
+                "[ERROR] context_set_array_of_arrays: NULL value at index "
+                "[%d][%d] for key '%s'. Skipping.\n",
+                i, j, key);
+        var->value.string_2d_array_data.values[i][j] = NULL;
+        continue;
+      }
+      var->value.string_2d_array_data.values[i][j] = strdup(values_2d[i][j]);
+      if (var->value.string_2d_array_data.values[i][j] == NULL) {
+        perror("Failed to duplicate string for inner array context");
+        fprintf(stderr,
+                "[ERROR] context_set_array_of_arrays: Failed to duplicate "
+                "value for item [%d][%d] of key '%s'.\n",
+                i, j, key);
+
+        for (int k = 0; k <= i; k++) {
+          if (var->value.string_2d_array_data.values[k] != NULL) {
+            for (int l = 0;
+                 l <
+                 (k == i ? j : var->value.string_2d_array_data.inner_counts[k]);
+                 l++) {
+              if (var->value.string_2d_array_data.values[k][l] != NULL) {
+                free(var->value.string_2d_array_data.values[k][l]);
+              }
+            }
+            free(var->value.string_2d_array_data.values[k]);
+          }
+        }
+        free(var->value.string_2d_array_data.values);
+        free(var->value.string_2d_array_data.inner_counts);
+        var->value.string_2d_array_data.values = NULL;
+        var->value.string_2d_array_data.inner_counts = NULL;
+        return;
+      }
+    }
+  }
+}
+
+void free_context(TemplateContext *ctx) {
+  if (ctx == NULL) {
+    return;
+  }
+  for (int i = 0; i < ctx->count; i++) {
+    if (ctx->vars[i].type == CONTEXT_TYPE_STRING_ARRAY) {
+      free_string_array_var(&ctx->vars[i]);
+    } else if (ctx->vars[i].type == CONTEXT_TYPE_STRING_2D_ARRAY) {
+      free_string_2d_array_var(&ctx->vars[i]);
+    }
+  }
+  ctx->count = 0;
+}
+
+static char *html_escape(const char *input) {
+  if (input == NULL) {
+    return strdup("");
+  }
+
+  size_t input_len = strlen(input);
+
+  size_t estimated_len = input_len * 5 + 1;
+  char *output = (char *)malloc(estimated_len);
+  if (output == NULL) {
+    perror("Failed to allocate memory for HTML escape output");
+    return NULL;
+  }
+  output[0] = '\0';
+  size_t current_output_len = 0;
+
+  for (size_t i = 0; i < input_len; i++) {
+    const char *replacement = NULL;
+
+    switch (input[i]) {
+    case '&':
+      replacement = "&amp;";
+      break;
+    case '<':
+      replacement = "&lt;";
+      break;
+    case '>':
+      replacement = "&gt;";
+      break;
+    case '"':
+      replacement = "&quot;";
+      break;
+    case '\'':
+      replacement = "&apos;";
+      break;
+    default:
+      break;
+    }
+
+    if (replacement) {
+      size_t repl_len = strlen(replacement);
+
+      if (current_output_len + repl_len + 1 > estimated_len) {
+        estimated_len = (current_output_len + repl_len + 1) * 2;
+        char *new_output = (char *)realloc(output, estimated_len);
+        if (new_output == NULL) {
+          perror("Failed to reallocate memory for HTML escape output");
+          free(output);
+          return NULL;
+        }
+        output = new_output;
+      }
+      strcat(output, replacement);
+      current_output_len += repl_len;
+    } else {
+
+      if (current_output_len + 1 + 1 > estimated_len) {
+        estimated_len = (current_output_len + 1 + 1) * 2;
+        char *new_output = (char *)realloc(output, estimated_len);
+        if (new_output == NULL) {
+          perror("Failed to reallocate memory for HTML escape output");
+          free(output);
+          return NULL;
+        }
+        output = new_output;
+      }
+      output[current_output_len++] = input[i];
+      output[current_output_len] = '\0';
+    }
+  }
+  return output;
+}
+
+static void append_to_buffer(char **buffer, size_t *current_len,
+                             size_t *max_len, const char *str_to_add) {
+  if (str_to_add == NULL) {
+    fprintf(stderr, "[WARNING] append_to_buffer: Attempted to append NULL "
+                    "string. Skipping.\n");
+    return;
+  }
+
+  size_t add_len = strlen(str_to_add);
+
+  if (*current_len + add_len + 1 > *max_len) {
+    *max_len = (*current_len + add_len + 1) * 2;
+
+    if (*max_len < BUFFER_SIZE * 2) {
+      *max_len = BUFFER_SIZE * 2;
+    }
+
+    char *new_buffer = (char *)realloc(*buffer, *max_len);
+    if (new_buffer == NULL) {
+      perror("Failed to reallocate buffer for template rendering");
+      fprintf(stderr,
+              "[ERROR] append_to_buffer: Reallocation failed (requested %zu "
+              "bytes).\n",
+              *max_len);
+      free(*buffer);
+      *buffer = NULL;
+
+      exit(EXIT_FAILURE);
+    }
+    *buffer = new_buffer;
+  }
+
+  strcat(*buffer, str_to_add);
+  *current_len += add_len;
+}
+
+static char *parse_indexed_tag(const char *tag_content, int *index_val) {
+  *index_val = -1;
+
+  char *open_bracket = strchr(tag_content, '[');
+  if (open_bracket == NULL) {
+
+    char *key_name = strdup(tag_content);
+    if (key_name == NULL) {
+      perror("Failed to duplicate tag content for simple key");
+      fprintf(stderr, "[ERROR] parse_indexed_tag: strdup failed for '%s'.\n",
+              tag_content);
+    }
+    return key_name;
+  }
+
+  char *close_bracket = strchr(open_bracket, ']');
+  if (close_bracket == NULL) {
+    fprintf(stderr,
+            "[ERROR] parse_indexed_tag: Unclosed bracket in tag '%s'. "
+            "Returning raw tag content.\n",
+            tag_content);
+
+    char *key_name = strdup(tag_content);
+    if (key_name == NULL) {
+      perror("Failed to duplicate malformed tag content");
+    }
+    return key_name;
+  }
+
+  size_t key_len = open_bracket - tag_content;
+  char *key_name = (char *)malloc(key_len + 1);
+  if (key_name == NULL) {
+    perror("Failed to allocate memory for key_name in parse_indexed_tag");
+    fprintf(stderr,
+            "[ERROR] parse_indexed_tag: Allocation failed for key_name.\n");
+    return NULL;
+  }
+  strncpy(key_name, tag_content, key_len);
+  key_name[key_len] = '\0';
+
+  size_t index_str_len = close_bracket - (open_bracket + 1);
+  char *index_str = (char *)malloc(index_str_len + 1);
+  if (index_str == NULL) {
+    perror("Failed to allocate memory for index_str in parse_indexed_tag");
+    fprintf(stderr,
+            "[ERROR] parse_indexed_tag: Allocation failed for index_str.\n");
+    free(key_name);
+    return NULL;
+  }
+  strncpy(index_str, open_bracket + 1, index_str_len);
+  index_str[index_str_len] = '\0';
+
+  *index_val = atoi(index_str);
+  free(index_str);
+
+  return key_name;
+}
+
+static char *render_template_segment(const char *template_segment,
+                                     TemplateContext *ctx) {
+  size_t initial_max_len = BUFFER_SIZE;
+  char *rendered_buffer = (char *)malloc(initial_max_len);
+  if (rendered_buffer == NULL) {
+    perror("Failed to allocate initial buffer for template segment rendering");
+    fprintf(stderr,
+            "[ERROR] render_template_segment: Failed to allocate initial %zu "
+            "bytes for rendered_buffer.\n",
+            initial_max_len);
+    return NULL;
+  }
+  rendered_buffer[0] = '\0';
+  size_t current_len = 0;
+  size_t max_len = initial_max_len;
+
+  const char *current_pos = template_segment;
+  const char *start_tag;
+
+  while ((start_tag = strstr(current_pos, "{{")) != NULL) {
+
+    size_t text_len = start_tag - current_pos;
+    if (text_len > 0) {
+      char *text_before_tag = (char *)malloc(text_len + 1);
+      if (text_before_tag == NULL) {
+        perror("Failed to allocate memory for text_before_tag");
+        fprintf(stderr, "[ERROR] render_template_segment: Allocation failed "
+                        "for text_before_tag.\n");
+        free(rendered_buffer);
+        return NULL;
+      }
+      strncpy(text_before_tag, current_pos, text_len);
+      text_before_tag[text_len] = '\0';
+      append_to_buffer(&rendered_buffer, &current_len, &max_len,
+                       text_before_tag);
+      free(text_before_tag);
+    }
+
+    const char *end_tag = strstr(start_tag, "}}");
+    if (end_tag == NULL) {
+      fprintf(stderr, "[ERROR] render_template_segment: Unclosed '{{' tag. "
+                      "Appending remaining template content as-is.\n");
+      append_to_buffer(&rendered_buffer, &current_len, &max_len, start_tag);
+      return rendered_buffer;
+    }
+
+    size_t tag_content_len = end_tag - (start_tag + 2);
+    char *tag_content_raw = (char *)malloc(tag_content_len + 1);
+    if (tag_content_raw == NULL) {
+      perror("Failed to allocate memory for tag_content_raw");
+      fprintf(stderr, "[ERROR] render_template_segment: Allocation failed for "
+                      "tag_content_raw.\n");
+      free(rendered_buffer);
+      return NULL;
+    }
+    strncpy(tag_content_raw, start_tag + 2, tag_content_len);
+    tag_content_raw[tag_content_len] = '\0';
+
+    char *trimmed_tag_content = tag_content_raw;
+    while (*trimmed_tag_content != '\0' &&
+           (*trimmed_tag_content == ' ' || *trimmed_tag_content == '\t' ||
+            *trimmed_tag_content == '\n' || *trimmed_tag_content == '\r')) {
+      trimmed_tag_content++;
+    }
+
+    if (*trimmed_tag_content == '\0') {
+      free(tag_content_raw);
+      current_pos = end_tag + 2;
+      continue;
+    } else {
+      char *end_trimmed = trimmed_tag_content + strlen(trimmed_tag_content) - 1;
+      while (end_trimmed >= trimmed_tag_content &&
+             (*end_trimmed == ' ' || *end_trimmed == '\t' ||
+              *end_trimmed == '\n' || *end_trimmed == '\r')) {
+      }
+      *(end_trimmed + 1) = '\0';
+    }
+
+    if (strncmp(trimmed_tag_content, "for ", 4) == 0) {
+      char loop_var[MAX_KEY_LEN];
+      char list_var[MAX_KEY_LEN];
+      if (sscanf(trimmed_tag_content, "for %s in %s", loop_var, list_var) ==
+          2) {
+        ContextVar *list_ctx_var = find_context_var(ctx, list_var);
+
+        const char *loop_end_tag = strstr(end_tag + 2, "{{endfor}}");
+        if (loop_end_tag == NULL) {
+          append_to_buffer(&rendered_buffer, &current_len, &max_len,
+                           trimmed_tag_content);
+          free(tag_content_raw);
+          current_pos = end_tag + 2;
+          continue;
+        }
+
+        if (list_ctx_var != NULL) {
+
+          bool is_empty = false;
+          if (list_ctx_var->type == CONTEXT_TYPE_STRING_2D_ARRAY) {
+            is_empty =
+                (list_ctx_var->value.string_2d_array_data.outer_count == 0);
+          } else if (list_ctx_var->type == CONTEXT_TYPE_STRING_ARRAY) {
+            is_empty = (list_ctx_var->value.string_array_data.count == 0);
+          } else {
+
+            is_empty = true;
+          }
+
+          if (is_empty) {
+            current_pos = loop_end_tag + strlen("{{endfor}}");
+            free(tag_content_raw);
+            continue;
+          }
+
+          const char *loop_inner_start = end_tag + 2;
+          size_t loop_inner_len = loop_end_tag - loop_inner_start;
+          char *loop_inner_template = (char *)malloc(loop_inner_len + 1);
+          if (loop_inner_template == NULL) {
+            perror("Failed to allocate memory for loop_inner_template");
+            fprintf(stderr, "[ERROR] render_template_segment: Allocation "
+                            "failed for loop_inner_template.\n");
+            free(rendered_buffer);
+            free(tag_content_raw);
+            return NULL;
+          }
+          strncpy(loop_inner_template, loop_inner_start, loop_inner_len);
+          loop_inner_template[loop_inner_len] = '\0';
+
+          if (list_ctx_var->type == CONTEXT_TYPE_STRING_2D_ARRAY) {
+            for (int i = 0;
+                 i < list_ctx_var->value.string_2d_array_data.outer_count;
+                 i++) {
+              TemplateContext loop_ctx = new_context();
+
+              for (int j = 0; j < ctx->count; j++) {
+                if (ctx->vars[j].type == CONTEXT_TYPE_STRING) {
+                  context_set(&loop_ctx, ctx->vars[j].key,
+                              ctx->vars[j].value.string_val);
+                }
+              }
+
+              context_set_string_array(
+                  &loop_ctx, loop_var,
+                  list_ctx_var->value.string_2d_array_data.values[i],
+                  list_ctx_var->value.string_2d_array_data.inner_counts[i]);
+
+              char *rendered_loop_item =
+                  render_template_segment(loop_inner_template, &loop_ctx);
+              if (rendered_loop_item) {
+                append_to_buffer(&rendered_buffer, &current_len, &max_len,
+                                 rendered_loop_item);
+                free(rendered_loop_item);
+              }
+              free_context(&loop_ctx);
+            }
+          } else if (list_ctx_var->type == CONTEXT_TYPE_STRING_ARRAY) {
+            for (int i = 0; i < list_ctx_var->value.string_array_data.count;
+                 i++) {
+              TemplateContext loop_ctx = new_context();
+
+              for (int j = 0; j < ctx->count; j++) {
+                if (ctx->vars[j].type == CONTEXT_TYPE_STRING) {
+                  context_set(&loop_ctx, ctx->vars[j].key,
+                              ctx->vars[j].value.string_val);
+                }
+              }
+
+              context_set(&loop_ctx, loop_var,
+                          list_ctx_var->value.string_array_data.values[i]);
+
+              char *rendered_loop_item =
+                  render_template_segment(loop_inner_template, &loop_ctx);
+              if (rendered_loop_item) {
+                append_to_buffer(&rendered_buffer, &current_len, &max_len,
+                                 rendered_loop_item);
+                free(rendered_loop_item);
+              }
+              free_context(&loop_ctx);
+            }
+          } else {
+            fprintf(
+                stderr,
+                "[IGNORE] [ERROR] render_template_segment: List variable '%s' "
+                "(type %d) is not an iterable array type for 'for' loop.\n",
+                list_var, list_ctx_var->type);
+          }
+          free(loop_inner_template);
+          current_pos = loop_end_tag + strlen("{{endfor}}");
+          free(tag_content_raw);
+          continue;
+        } else {
+
+          fprintf(stderr,
+                  "[IGNORE] [ERROR] render_template_segment: List variable "
+                  "'%s' not found for 'for' loop. Skipping loop block.\n",
+                  list_var);
+          current_pos = loop_end_tag + strlen("{{endfor}}");
+          free(tag_content_raw);
+          continue;
+        }
+      } else {
+        fprintf(stderr,
+                "[ERROR] render_template_segment: Malformed 'for' loop tag: "
+                "'%s'. Expected 'for var in list'. Appending loop tag as-is.\n",
+                trimmed_tag_content);
+      }
+    }
+
+    else if (strcmp(trimmed_tag_content, "endfor") == 0) {
+      fprintf(stderr, "[WARNING] render_template_segment: '{{endfor}}' without "
+                      "matching '{{for}}'. Appending endfor tag as-is.\n");
+    }
+
+    else if (strncmp(trimmed_tag_content, "include ", 8) == 0) {
+      const char *filename_start = trimmed_tag_content + strlen("include ");
+      if (*filename_start == '"') {
+        filename_start++;
+        char *filename_end = strchr(filename_start, '"');
+        if (filename_end != NULL) {
+          size_t filename_len = filename_end - filename_start;
+          char *included_filename = (char *)malloc(filename_len + 1);
+          if (included_filename == NULL) {
+            perror("Failed to allocate memory for included filename");
+            fprintf(stderr, "[ERROR] render_template_segment: Allocation "
+                            "failed for included_filename.\n");
+            free(rendered_buffer);
+            free(tag_content_raw);
+            return NULL;
+          }
+          strncpy(included_filename, filename_start, filename_len);
+          included_filename[filename_len] = '\0';
+
+          char *included_html = render_template(included_filename, ctx);
+          if (included_html) {
+            append_to_buffer(&rendered_buffer, &current_len, &max_len,
+                             included_html);
+            free(included_html);
+          } else {
+            fprintf(stderr,
+                    "[WARNING] render_template_segment: Failed to render "
+                    "included template '%s'.\n",
+                    included_filename);
+
+            append_to_buffer(&rendered_buffer, &current_len, &max_len,
+                             "<!-- Failed to include ");
+            append_to_buffer(&rendered_buffer, &current_len, &max_len,
+                             included_filename);
+            append_to_buffer(&rendered_buffer, &current_len, &max_len, " -->");
+          }
+          free(included_filename);
+          current_pos = end_tag + 2;
+          free(tag_content_raw);
+          continue;
+        } else {
+          fprintf(stderr,
+                  "[ERROR] render_template_segment: Malformed include tag "
+                  "'%s'. Missing closing quote.\n",
+                  trimmed_tag_content);
+
+          append_to_buffer(&rendered_buffer, &current_len, &max_len, "{{");
+          append_to_buffer(&rendered_buffer, &current_len, &max_len,
+                           trimmed_tag_content);
+          append_to_buffer(&rendered_buffer, &current_len, &max_len, "}}");
+          free(tag_content_raw);     
+
+          current_pos = end_tag + 2; 
+
+          continue;                  
+
+        }
+      } else {
+        fprintf(stderr,
+                "[ERROR] render_template_segment: Malformed include tag '%s'. "
+                "Expected quoted filename.\n",
+                trimmed_tag_content);
+
+        append_to_buffer(&rendered_buffer, &current_len, &max_len, "{{");
+        append_to_buffer(&rendered_buffer, &current_len, &max_len,
+                         trimmed_tag_content);
+        append_to_buffer(&rendered_buffer, &current_len, &max_len, "}}");
+      }
+    }
+
+    else {
+      bool is_safe = false;
+      char *processing_tag_content = strdup(trimmed_tag_content);
+      if (processing_tag_content == NULL) {
+        perror("Failed to duplicate tag content for processing");
+        free(rendered_buffer);
+        free(tag_content_raw);
+        return NULL;
+      }
+
+      char *safe_flag_pos_in_processing =
+          strstr(processing_tag_content, "|safe");
+      if (safe_flag_pos_in_processing != NULL) {
+        is_safe = true;
+        *safe_flag_pos_in_processing = '\0';
+      }
+
+      int index_val = -1;
+      char *key_name = parse_indexed_tag(processing_tag_content, &index_val);
+      free(processing_tag_content);
+
+      if (key_name == NULL) {
+        fprintf(stderr,
+                "[ERROR] render_template_segment: parse_indexed_tag failed for "
+                "'%s'.\n",
+                trimmed_tag_content);
+        free(rendered_buffer);
+        free(tag_content_raw);
+        return NULL;
+      }
+
+      const char *value_to_append = NULL;
+      ContextVar *var = find_context_var(ctx, key_name);
+
+      if (var != NULL) {
+        if (index_val == -1) {
+          if (var->type == CONTEXT_TYPE_STRING) {
+            value_to_append = var->value.string_val;
+          } else {
+            fprintf(
+                stderr,
+                "[WARNING] render_template_segment: Variable '%s' is not a "
+                "simple string (type %d). Not rendering as simple string.\n",
+                key_name, var->type);
+
+            append_to_buffer(&rendered_buffer, &current_len, &max_len, "{{");
+            append_to_buffer(&rendered_buffer, &current_len, &max_len,
+                             trimmed_tag_content);
+            append_to_buffer(&rendered_buffer, &current_len, &max_len, "}}");
+          }
+        } else {
+          if (var->type == CONTEXT_TYPE_STRING_ARRAY) {
+            if (index_val >= 0 &&
+                index_val < var->value.string_array_data.count) {
+              value_to_append = var->value.string_array_data.values[index_val];
+            } else {
+              fprintf(stderr,
+                      "[ERROR] render_template_segment: Index %d out of bounds "
+                      "for '%s' (count %d). Appending tag as-is.\n",
+                      index_val, key_name, var->value.string_array_data.count);
+            }
+          } else {
+            fprintf(
+                stderr,
+                "[ERROR] render_template_segment: Variable '%s' (type %d) is "
+                "not a string array for indexed access. Appending tag as-is.\n",
+                key_name, var->type);
+          }
+        }
+      } else {
+        fprintf(stderr,
+                "[WARNING] render_template_segment: Key '%s' not found in "
+                "context. Appending tag as-is.\n",
+                key_name);
+      }
+
+      if (value_to_append != NULL) {
+        if (is_safe) {
+          append_to_buffer(&rendered_buffer, &current_len, &max_len,
+                           value_to_append);
+        } else {
+          char *escaped_value = html_escape(value_to_append);
+          if (escaped_value) {
+            append_to_buffer(&rendered_buffer, &current_len, &max_len,
+                             escaped_value);
+            free(escaped_value);
+          } else {
+            fprintf(stderr,
+                    "[ERROR] render_template_segment: Failed to HTML escape "
+                    "value for key '%s'. Appending raw.\n",
+                    key_name);
+            append_to_buffer(&rendered_buffer, &current_len, &max_len,
+                             value_to_append);
+          }
+        }
+      }
+
+      free(key_name);            
+
+      free(tag_content_raw);     
+
+      current_pos = end_tag + 2; 
+
+      continue;                  
+
+    }
+
+    free(tag_content_raw);
+    current_pos = end_tag + 2;
+  }
+
+  append_to_buffer(&rendered_buffer, &current_len, &max_len, current_pos);
+  return rendered_buffer;
+}
+
+char *render_template(const char *template_file, TemplateContext *ctx) {
+  char full_path[MAX_PATH_LEN];
+
+  snprintf(full_path, sizeof(full_path), "%s%s", TEMPLATES_DIR, template_file);
+
+  FILE *fp = fopen(full_path, "r");
+  if (fp == NULL) {
+    perror("Error opening template file");
+    fprintf(stderr,
+            "[ERROR] render_template: Could not open template '%s'. %s\n",
+            full_path, strerror(errno));
+    return NULL;
+  }
+
+  fseek(fp, 0, SEEK_END);
+  long file_size = ftell(fp);
+  fseek(fp, 0, SEEK_SET);
+
+  char *template_content = (char *)malloc(file_size + 1);
+  if (template_content == NULL) {
+    perror("Error allocating memory for template content");
+    fprintf(stderr,
+            "[ERROR] render_template: Failed to allocate %ld bytes for "
+            "template content.\n",
+            file_size + 1);
+    fclose(fp);
+    return NULL;
+  }
+  fread(template_content, 1, file_size, fp);
+  template_content[file_size] = '\0';
+  fclose(fp);
+
+  char *rendered_html = render_template_segment(template_content, ctx);
+  free(template_content);
+  return rendered_html;
+}
\ No newline at end of file
-- 
cgit v1.2.3