Added the old repo, refactored it, added the C jit.

9 files changed, 5790 insertions, 0 deletions

diff --git a/src/app.c b/src/app.c
new file mode 100644
index 0000000..3ae368c
--- /dev/null
+++ b/src/app.c
@@ -0,0 +1,1578 @@
+#include "app.h"
+#include "common.h"
+
+#include <dirent.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+
+void app_message(app_t *app, const char *msg) {
+    if (!app || !msg) return;
+
+    snprintf(app->message, sizeof(app->message), "%s", msg);
+    app->dirty = 1;
+}
+
+static const char *app_clipboard_get(void *userdata) {
+    app_t *app = userdata;
+    if (!app || !app->window) return NULL;
+    return glfwGetClipboardString(app->window);
+}
+
+static void app_clipboard_set(void *userdata, const char *text) {
+    app_t *app = userdata;
+    if (!app || !app->window || !text) return;
+    glfwSetClipboardString(app->window, text);
+}
+
+static void app_reset_completion(app_t *app) {
+    if (!app) return;
+
+    app->completion_active = 0;
+    app->completion_query[0] = '\0';
+    app->completion_index = 0;
+    app->completion_count = 0;
+}
+
+static void app_set_minibuffer(app_t *app, const char *text) {
+    if (!app || !text) return;
+
+    snprintf(app->minibuffer, sizeof(app->minibuffer), "%s", text);
+    app->minibuffer_len = strlen(app->minibuffer);
+    app->dirty = 1;
+}
+
+static void app_reset_prompt_completion(app_t *app) {
+    if (!app) return;
+
+    app->prompt_completion_active = 0;
+    app->prompt_completion_query[0] = '\0';
+    app->prompt_completion_index = 0;
+    app->prompt_completion_count = 0;
+}
+
+static void app_set_prompt_input(app_t *app, const char *text) {
+    if (!app || !text) return;
+
+    snprintf(app->prompt_input, sizeof(app->prompt_input), "%s", text);
+    app->prompt_input_len = strlen(app->prompt_input);
+    app->dirty = 1;
+}
+
+static char *app_expand_user_path(const char *path) {
+    if (!path) return NULL;
+
+    if (path[0] != '~' || (path[1] != '\0' && path[1] != '/')) {
+        char *copy = malloc(strlen(path) + 1);
+        if (!copy) return NULL;
+        strcpy(copy, path);
+        return copy;
+    }
+
+    const char *home = getenv("HOME");
+    if (!home || !home[0]) {
+        char *copy = malloc(strlen(path) + 1);
+        if (!copy) return NULL;
+        strcpy(copy, path);
+        return copy;
+    }
+
+    size_t home_len = strlen(home);
+    size_t rest_len = strlen(path + 1);
+
+    char *expanded = malloc(home_len + rest_len + 1);
+    if (!expanded) return NULL;
+
+    memcpy(expanded, home, home_len);
+    memcpy(expanded + home_len, path + 1, rest_len + 1);
+    return expanded;
+}
+
+typedef struct command_candidate {
+    const char *name;
+    int score;
+    size_t order;
+} command_candidate_t;
+
+static int ascii_lower(int c) {
+    if (c >= 'A' && c <= 'Z') return c - 'A' + 'a';
+    return c;
+}
+
+static int ascii_strncasecmp_local(const char *a, const char *b, size_t n) {
+    for (size_t i = 0; i < n; i++) {
+        int ac = ascii_lower((unsigned char)a[i]);
+        int bc = ascii_lower((unsigned char)b[i]);
+
+        if (ac != bc || ac == '\0' || bc == '\0') {
+            return ac - bc;
+        }
+    }
+
+    return 0;
+}
+
+static int ascii_contains_ci(const char *haystack, const char *needle) {
+    if (!haystack || !needle) return 0;
+    if (needle[0] == '\0') return 1;
+
+    size_t needle_len = strlen(needle);
+
+    for (size_t i = 0; haystack[i]; i++) {
+        if (ascii_strncasecmp_local(haystack + i, needle, needle_len) == 0) {
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+static int command_fuzzy_score(const char *candidate, const char *query) {
+    if (!candidate || !query) return -1;
+
+    if (query[0] == '\0') {
+        return 0;
+    }
+
+    int score = 0;
+    int consecutive = 0;
+    int last_match = -1;
+
+    size_t ci = 0;
+    size_t qi = 0;
+
+    while (candidate[ci] && query[qi]) {
+        char c = candidate[ci];
+        char q = query[qi];
+
+        if (c >= 'A' && c <= 'Z') c = (char)(c - 'A' + 'a');
+        if (q >= 'A' && q <= 'Z') q = (char)(q - 'A' + 'a');
+
+        if (c == q) {
+            score += 10;
+
+            if ((int)ci == last_match + 1) {
+                consecutive++;
+                score += 5 * consecutive;
+            } else {
+                consecutive = 0;
+            }
+
+            if (ci == 0) {
+                score += 20;
+            }
+
+            if (ci > 0 &&
+                (candidate[ci - 1] == '-' ||
+                 candidate[ci - 1] == '_' ||
+                 candidate[ci - 1] == ' ')) {
+                score += 15;
+            }
+
+            last_match = (int)ci;
+            qi++;
+        }
+
+        ci++;
+    }
+
+    if (query[qi] != '\0') {
+        return -1;
+    }
+
+    score -= (int)strlen(candidate);
+
+    if (strncmp(candidate, query, strlen(query)) == 0) {
+        score += 100;
+    }
+
+    if (ascii_contains_ci(candidate, query)) {
+        score += 75;
+    }
+
+    return score;
+}
+
+static int compare_command_candidates(const void *a, const void *b) {
+    const command_candidate_t *ca = (const command_candidate_t *)a;
+    const command_candidate_t *cb = (const command_candidate_t *)b;
+
+    if (ca->score != cb->score) {
+        return cb->score - ca->score;
+    }
+
+    if (ca->order < cb->order) return -1;
+    if (ca->order > cb->order) return 1;
+    return 0;
+}
+
+static command_candidate_t *collect_command_candidates(ecex_t *ed,
+                                                       const char *query,
+                                                       size_t *out_count) {
+    if (out_count) *out_count = 0;
+    if (!ed || !query || ed->command_count == 0) return NULL;
+
+    command_candidate_t *items = malloc(ed->command_count * sizeof(*items));
+    if (!items) return NULL;
+
+    size_t count = 0;
+
+    for (size_t i = 0; i < ed->command_count; i++) {
+        const char *name = ed->commands[i].name;
+        int score = command_fuzzy_score(name, query);
+
+        if (score >= 0) {
+            items[count].name = name;
+            items[count].score = score;
+            items[count].order = i;
+            count++;
+        }
+    }
+
+    if (count == 0) {
+        free(items);
+        return NULL;
+    }
+
+    qsort(items, count, sizeof(*items), compare_command_candidates);
+
+    if (out_count) *out_count = count;
+    return items;
+}
+
+static const char *command_candidate_at(ecex_t *ed,
+                                        const char *query,
+                                        size_t index,
+                                        size_t *out_count) {
+    size_t count = 0;
+    command_candidate_t *items = collect_command_candidates(ed, query, &count);
+    if (!items || count == 0) return NULL;
+
+    const char *name = items[index % count].name;
+
+    if (out_count) {
+        *out_count = count;
+    }
+
+    free(items);
+    return name;
+}
+
+typedef struct path_candidate {
+    char *path;
+    int score;
+    int is_dir;
+    size_t order;
+} path_candidate_t;
+
+static void free_path_candidates(path_candidate_t *items, size_t count) {
+    if (!items) return;
+
+    for (size_t i = 0; i < count; i++) {
+        free(items[i].path);
+    }
+
+    free(items);
+}
+
+static int compare_path_candidates(const void *a, const void *b) {
+    const path_candidate_t *pa = (const path_candidate_t *)a;
+    const path_candidate_t *pb = (const path_candidate_t *)b;
+
+    if (pa->score != pb->score) {
+        return pb->score - pa->score;
+    }
+
+    if (pa->is_dir != pb->is_dir) {
+        return pb->is_dir - pa->is_dir;
+    }
+
+    int cmp = strcmp(pa->path, pb->path);
+    if (cmp != 0) return cmp;
+
+    if (pa->order < pb->order) return -1;
+    if (pa->order > pb->order) return 1;
+    return 0;
+}
+
+static int split_path_query(const char *query,
+                            char *display_dir,
+                            size_t display_dir_size,
+                            char *fs_dir,
+                            size_t fs_dir_size,
+                            char *needle,
+                            size_t needle_size) {
+    if (!query || !display_dir || !fs_dir || !needle) return -1;
+
+    const char *last_slash = strrchr(query, '/');
+
+    if (last_slash) {
+        size_t dir_len = (size_t)(last_slash - query) + 1;
+        if (dir_len >= display_dir_size) dir_len = display_dir_size - 1;
+
+        memcpy(display_dir, query, dir_len);
+        display_dir[dir_len] = '\0';
+
+        snprintf(needle, needle_size, "%s", last_slash + 1);
+    } else {
+        display_dir[0] = '\0';
+        snprintf(needle, needle_size, "%s", query);
+    }
+
+    if (display_dir[0] == '\0') {
+        snprintf(fs_dir, fs_dir_size, ".");
+    } else {
+        char *expanded = app_expand_user_path(display_dir);
+        if (!expanded) return -1;
+
+        snprintf(fs_dir, fs_dir_size, "%s", expanded);
+        free(expanded);
+    }
+
+    return 0;
+}
+
+static char *join_display_path(const char *display_dir,
+                               const char *name,
+                               int is_dir) {
+    size_t dir_len = display_dir ? strlen(display_dir) : 0;
+    size_t name_len = name ? strlen(name) : 0;
+    size_t slash_len = is_dir ? 1 : 0;
+
+    char *out = malloc(dir_len + name_len + slash_len + 1);
+    if (!out) return NULL;
+
+    if (dir_len) memcpy(out, display_dir, dir_len);
+    if (name_len) memcpy(out + dir_len, name, name_len);
+    if (is_dir) out[dir_len + name_len] = '/';
+    out[dir_len + name_len + slash_len] = '\0';
+    return out;
+}
+
+static path_candidate_t *collect_path_candidates(const char *query,
+                                                 size_t *out_count) {
+    if (out_count) *out_count = 0;
+    if (!query) return NULL;
+
+    char display_dir[1024];
+    char fs_dir[1024];
+    char needle[512];
+
+    if (split_path_query(query,
+                         display_dir,
+                         sizeof(display_dir),
+                         fs_dir,
+                         sizeof(fs_dir),
+                         needle,
+                         sizeof(needle)) != 0) {
+        return NULL;
+    }
+
+    DIR *dir = opendir(fs_dir);
+    if (!dir) return NULL;
+
+    size_t cap = 32;
+    size_t count = 0;
+    size_t order = 0;
+    path_candidate_t *items = malloc(cap * sizeof(*items));
+    if (!items) {
+        closedir(dir);
+        return NULL;
+    }
+
+    struct dirent *entry = NULL;
+    while ((entry = readdir(dir)) != NULL) {
+        const char *name = entry->d_name;
+
+        if (strcmp(name, ".") == 0) {
+            continue;
+        }
+
+        if (name[0] == '.' && needle[0] != '.' && strcmp(name, "..") != 0) {
+            continue;
+        }
+
+        int score = command_fuzzy_score(name, needle);
+        if (score < 0) {
+            order++;
+            continue;
+        }
+
+        char fs_path[2048];
+        if (strcmp(fs_dir, ".") == 0) {
+            snprintf(fs_path, sizeof(fs_path), "%s", name);
+        } else {
+            size_t len = strlen(fs_dir);
+            snprintf(fs_path,
+                     sizeof(fs_path),
+                     "%s%s%s",
+                     fs_dir,
+                     (len > 0 && fs_dir[len - 1] == '/') ? "" : "/",
+                     name);
+        }
+
+        struct stat st;
+        int is_dir = stat(fs_path, &st) == 0 && S_ISDIR(st.st_mode);
+
+        if (count == cap) {
+            size_t new_cap = cap * 2;
+            path_candidate_t *new_items = realloc(items, new_cap * sizeof(*items));
+            if (!new_items) break;
+            items = new_items;
+            cap = new_cap;
+        }
+
+        items[count].path = join_display_path(display_dir, name, is_dir);
+        if (!items[count].path) continue;
+
+        items[count].score = score + (is_dir ? 20 : 0);
+        items[count].is_dir = is_dir;
+        items[count].order = order;
+        count++;
+        order++;
+    }
+
+    closedir(dir);
+
+    if (count == 0) {
+        free(items);
+        return NULL;
+    }
+
+    qsort(items, count, sizeof(*items), compare_path_candidates);
+
+    if (out_count) *out_count = count;
+    return items;
+}
+
+static const char *path_candidate_at(const char *query,
+                                     size_t index,
+                                     size_t *out_count) {
+    static char candidate[1024];
+
+    size_t count = 0;
+    path_candidate_t *items = collect_path_candidates(query, &count);
+    if (!items || count == 0) {
+        free_path_candidates(items, count);
+        return NULL;
+    }
+
+    snprintf(candidate, sizeof(candidate), "%s", items[index % count].path);
+
+    if (out_count) {
+        *out_count = count;
+    }
+
+    free_path_candidates(items, count);
+    return candidate;
+}
+
+static void app_update_prompt_completion_preview(app_t *app) {
+    if (!app || !app->prompt_completion_active) return;
+
+    size_t count = 0;
+    path_candidate_t *items = collect_path_candidates(app->prompt_completion_query, &count);
+    if (!items || count == 0) {
+        free_path_candidates(items, count);
+        app->prompt_completion_preview_start = 0;
+        app->prompt_completion_preview_count = 0;
+        return;
+    }
+
+    size_t max_preview = sizeof(app->prompt_completion_preview) /
+        sizeof(app->prompt_completion_preview[0]);
+
+    size_t start = 0;
+    if (app->prompt_completion_index >= max_preview) {
+        start = app->prompt_completion_index - max_preview + 1;
+    }
+
+    app->prompt_completion_preview_start = start;
+    app->prompt_completion_preview_count = 0;
+
+    for (size_t i = 0; i < max_preview && start + i < count; i++) {
+        snprintf(app->prompt_completion_preview[i],
+                 sizeof(app->prompt_completion_preview[i]),
+                 "%s",
+                 items[start + i].path);
+        app->prompt_completion_preview_count++;
+    }
+
+    free_path_candidates(items, count);
+}
+
+static void app_begin_prompt_completion(app_t *app, int direction) {
+    if (!app) return;
+
+    snprintf(app->prompt_completion_query,
+             sizeof(app->prompt_completion_query),
+             "%s",
+             app->prompt_input);
+
+    size_t count = 0;
+    path_candidate_t *items = collect_path_candidates(app->prompt_completion_query, &count);
+
+    if (!items || count == 0) {
+        free_path_candidates(items, count);
+        app_reset_prompt_completion(app);
+        app_message(app, "No file completions");
+        app->mode = APP_MODE_PROMPT;
+        return;
+    }
+
+    app->prompt_completion_active = 1;
+    app->prompt_completion_count = count;
+    app->prompt_completion_index = direction < 0 ? count - 1 : 0;
+
+    app_set_prompt_input(app, items[app->prompt_completion_index].path);
+    free_path_candidates(items, count);
+    app_update_prompt_completion_preview(app);
+}
+
+static void app_cycle_prompt_completion(app_t *app, int delta) {
+    if (!app) return;
+
+    if (!app->prompt_completion_active || app->prompt_completion_count == 0) {
+        app_begin_prompt_completion(app, delta);
+        return;
+    }
+
+    if (delta < 0) {
+        app->prompt_completion_index = app->prompt_completion_index == 0
+            ? app->prompt_completion_count - 1
+            : app->prompt_completion_index - 1;
+    } else {
+        app->prompt_completion_index =
+            (app->prompt_completion_index + 1) % app->prompt_completion_count;
+    }
+
+    size_t count = 0;
+    const char *candidate = path_candidate_at(app->prompt_completion_query,
+                                              app->prompt_completion_index,
+                                              &count);
+
+    if (!candidate || count == 0) {
+        app_reset_prompt_completion(app);
+        return;
+    }
+
+    app->prompt_completion_count = count;
+    app_set_prompt_input(app, candidate);
+    app_update_prompt_completion_preview(app);
+}
+
+static void app_begin_completion(app_t *app, int direction) {
+    if (!app) return;
+
+    snprintf(app->completion_query,
+             sizeof(app->completion_query),
+             "%s",
+             app->minibuffer);
+
+    size_t count = 0;
+    command_candidate_t *items =
+        collect_command_candidates(app->ed, app->completion_query, &count);
+
+    if (!items || count == 0) {
+        free(items);
+        app_reset_completion(app);
+        app_message(app, "No command completions");
+        app->mode = APP_MODE_MX;
+        return;
+    }
+
+    app->completion_active = 1;
+    app->completion_count = count;
+
+    if (direction < 0) {
+        app->completion_index = count - 1;
+    } else {
+        app->completion_index = 0;
+    }
+
+    app_set_minibuffer(app, items[app->completion_index].name);
+    free(items);
+}
+
+static void app_cycle_completion(app_t *app, int delta) {
+    if (!app) return;
+
+    if (!app->completion_active || app->completion_count == 0) {
+        app_begin_completion(app, delta);
+        return;
+    }
+
+    if (delta < 0) {
+        if (app->completion_index == 0) {
+            app->completion_index = app->completion_count - 1;
+        } else {
+            app->completion_index--;
+        }
+    } else {
+        app->completion_index =
+            (app->completion_index + 1) % app->completion_count;
+    }
+
+    size_t count = 0;
+    const char *candidate = command_candidate_at(app->ed,
+                                                 app->completion_query,
+                                                 app->completion_index,
+                                                 &count);
+
+    if (!candidate || count == 0) {
+        app_reset_completion(app);
+        return;
+    }
+
+    app->completion_count = count;
+    app_set_minibuffer(app, candidate);
+}
+
+static void app_enter_mx(app_t *app) {
+    app->mode = APP_MODE_MX;
+    app->minibuffer[0] = '\0';
+    app->minibuffer_len = 0;
+    app->prefix[0] = '\0';
+    app->prefix_len = 0;
+    app->message[0] = '\0';
+    app_reset_completion(app);
+    app->dirty = 1;
+}
+
+static void app_cancel_mx(app_t *app) {
+    app->mode = APP_MODE_EDIT;
+    app->minibuffer[0] = '\0';
+    app->minibuffer_len = 0;
+    app_reset_completion(app);
+    app_message(app, "Quit");
+}
+
+
+static void app_update_isearch(app_t *app) {
+    if (!app || !app->ed) return;
+    buffer_t *buf = ecex_current_buffer(app->ed);
+    if (!buf || app->isearch_len == 0) {
+        app->isearch_has_match = 0;
+        app->dirty = 1;
+        return;
+    }
+    size_t pos = 0;
+    size_t start = app->isearch_backward
+        ? (buf->point > 0 ? buf->point - 1 : buf->len)
+        : buf->point;
+    int ok = app->isearch_backward
+        ? buffer_search_backward(buf, app->isearch_query, start, &pos)
+        : buffer_search_forward(buf, app->isearch_query, start, &pos);
+    if (ok == ECEX_OK) {
+        app->isearch_match = pos;
+        app->isearch_has_match = 1;
+        buffer_set_point(buf, pos);
+        buffer_set_mark(buf, pos + strlen(app->isearch_query));
+    } else {
+        app->isearch_has_match = 0;
+    }
+    app->dirty = 1;
+}
+
+static void app_enter_isearch(app_t *app, int backward) {
+    if (!app || !app->ed) return;
+    buffer_t *buf = ecex_current_buffer(app->ed);
+    app->mode = APP_MODE_ISEARCH;
+    app->isearch_backward = backward ? 1 : 0;
+    app->isearch_query[0] = '\0';
+    app->isearch_len = 0;
+    app->isearch_origin = buf ? buf->point : 0;
+    app->isearch_match = app->isearch_origin;
+    app->isearch_has_match = 0;
+    app->prefix[0] = '\0';
+    app->prefix_len = 0;
+    app->message[0] = '\0';
+    app->dirty = 1;
+}
+
+static void app_cancel_isearch(app_t *app) {
+    if (!app || !app->ed) return;
+    buffer_t *buf = ecex_current_buffer(app->ed);
+    if (buf) {
+        buffer_set_point(buf, app->isearch_origin);
+        buffer_clear_mark(buf);
+    }
+    app->mode = APP_MODE_EDIT;
+    app_message(app, "Search cancelled");
+}
+
+static void app_finish_isearch(app_t *app) {
+    if (!app || !app->ed) return;
+    buffer_t *buf = ecex_current_buffer(app->ed);
+    if (app->isearch_len > 0) {
+        snprintf(app->last_search_query, sizeof(app->last_search_query), "%s", app->isearch_query);
+    }
+    if (buf) buffer_clear_mark(buf);
+    app->mode = APP_MODE_EDIT;
+    if (app->isearch_len > 0) app_message(app, app->isearch_has_match ? "Search done" : "Search failed");
+    app->dirty = 1;
+}
+
+static void app_enter_prompt(app_t *app,
+                             ecex_prompt_request_t kind,
+                             const char *label) {
+    if (!app) return;
+
+    app->mode = APP_MODE_PROMPT;
+    app->prompt_kind = kind;
+    snprintf(app->prompt_label,
+             sizeof(app->prompt_label),
+             "%s",
+             label ? label : "");
+    app->prompt_input[0] = '\0';
+    app->prompt_input_len = 0;
+    app_reset_prompt_completion(app);
+    app->message[0] = '\0';
+    app->dirty = 1;
+}
+
+
+static void app_reload_font_if_needed(app_t *app) {
+    if (!app || !app->ed) return;
+
+    const char *path = NULL;
+    if (app->ed->theme.font_path && app->ed->theme.font_path[0]) {
+        path = app->ed->theme.font_path;
+    } else if (app->font_path[0]) {
+        path = app->font_path;
+    } else {
+        path = font_choose_path(NULL);
+    }
+
+    if (!path || !path[0]) return;
+
+    float size = app->ed->theme.font_size;
+    int same_path = app->font_path[0] && strcmp(app->font_path, path) == 0;
+    int same_size = app->font.size_px == size;
+
+    if (same_path && same_size) return;
+
+    font_t new_font;
+    if (font_load(&new_font, path, size) != 0) {
+        char msg[ECEX_MINIBUFFER_SIZE];
+        snprintf(msg, sizeof(msg), "Failed to reload font: %s", path);
+        app_message(app, msg);
+        return;
+    }
+
+    font_free(&app->font);
+    app->font = new_font;
+    snprintf(app->font_path, sizeof(app->font_path), "%s", path);
+    app->dirty = 1;
+}
+
+static int app_handle_prompt_request(app_t *app) {
+    if (!app || !app->ed) return 0;
+
+    if (app->ed->prompt_request == ECEX_PROMPT_NONE) {
+        return 0;
+    }
+
+    ecex_prompt_request_t request = app->ed->prompt_request;
+    char label[sizeof(app->ed->prompt_message)];
+    snprintf(label, sizeof(label), "%s", app->ed->prompt_message);
+
+    ecex_clear_prompt_request(app->ed);
+    if (request == ECEX_PROMPT_ISEARCH_FORWARD) {
+        app_enter_isearch(app, 0);
+    } else if (request == ECEX_PROMPT_ISEARCH_BACKWARD) {
+        app_enter_isearch(app, 1);
+    } else {
+        app_enter_prompt(app, request, label);
+    }
+    return 1;
+}
+
+static int app_execute_command(app_t *app, const char *command) {
+    if (!app || !app->ed || !command) return -1;
+
+    int result = ecex_execute_command(app->ed, command);
+    if (result == 0) {
+        app_reload_font_if_needed(app);
+        app_handle_prompt_request(app);
+    }
+
+    if (app->ed->should_quit && app->window) {
+        glfwSetWindowShouldClose(app->window, GLFW_TRUE);
+        glfwPostEmptyEvent();
+    }
+
+    app->dirty = 1;
+    return result;
+}
+
+static void app_cancel_prompt(app_t *app) {
+    if (!app) return;
+
+    app->mode = APP_MODE_EDIT;
+    app->prompt_kind = ECEX_PROMPT_NONE;
+    app->prompt_label[0] = '\0';
+    app->prompt_input[0] = '\0';
+    app->prompt_input_len = 0;
+    app_reset_prompt_completion(app);
+    app_message(app, "Prompt cancelled");
+}
+
+static void app_submit_prompt(app_t *app) {
+    if (!app || !app->ed) return;
+
+    if (app->prompt_input_len == 0 && app->prompt_kind != ECEX_PROMPT_COMPILE) {
+        app_cancel_prompt(app);
+        return;
+    }
+
+    char input[sizeof(app->prompt_input)];
+    snprintf(input, sizeof(input), "%s", app->prompt_input);
+
+    ecex_prompt_request_t kind = app->prompt_kind;
+    app->mode = APP_MODE_EDIT;
+    app->prompt_kind = ECEX_PROMPT_NONE;
+    app->prompt_label[0] = '\0';
+    app->prompt_input[0] = '\0';
+    app->prompt_input_len = 0;
+
+    char *expanded_input = app_expand_user_path(input);
+    const char *path = expanded_input ? expanded_input : input;
+
+    int result = -1;
+    const char *verb = "Prompt";
+
+    switch (kind) {
+        case ECEX_PROMPT_FIND_FILE:
+            result = ecex_find_file(app->ed, path);
+            verb = "Opened";
+            break;
+
+        case ECEX_PROMPT_WRITE_FILE:
+            result = ecex_write_current_buffer(app->ed, path);
+            verb = "Wrote";
+            break;
+
+        case ECEX_PROMPT_EVAL_FILE:
+            result = ecex_eval_file(app->ed, path);
+            verb = "Evaluated";
+            break;
+
+        case ECEX_PROMPT_SWITCH_BUFFER:
+            result = ecex_switch_buffer(app->ed, input);
+            verb = "Switched";
+            break;
+
+        case ECEX_PROMPT_KILL_BUFFER:
+            result = ecex_kill_buffer(app->ed, input);
+            verb = "Killed";
+            break;
+
+        case ECEX_PROMPT_COMPILE:
+            result = ecex_compile(app->ed, input[0] ? input : "make");
+            verb = "Compiled";
+            break;
+
+        case ECEX_PROMPT_GREP:
+            result = ecex_grep(app->ed, input);
+            verb = "Grep";
+            break;
+
+        case ECEX_PROMPT_NONE:
+        default:
+            result = -1;
+            break;
+    }
+
+    if (result == 0) {
+        app_reload_font_if_needed(app);
+    }
+
+    char msg[ECEX_MINIBUFFER_SIZE];
+    if (result == 0) {
+        snprintf(msg, sizeof(msg), "%s: %s", verb, path);
+    } else {
+        snprintf(msg, sizeof(msg), "Failed: %s", path);
+    }
+
+    free(expanded_input);
+    app_reset_prompt_completion(app);
+    app_message(app, msg);
+}
+
+static void app_execute_mx(app_t *app) {
+    if (!app) return;
+
+    if (app->minibuffer_len == 0) {
+        app_cancel_mx(app);
+        return;
+    }
+
+    char command[ECEX_MINIBUFFER_SIZE];
+    snprintf(command, sizeof(command), "%s", app->minibuffer);
+
+    app->mode = APP_MODE_EDIT;
+    app->minibuffer[0] = '\0';
+    app->minibuffer_len = 0;
+    app_reset_completion(app);
+
+    if (app_execute_command(app, command) == 0) {
+        if (app->mode == APP_MODE_EDIT) {
+            char msg[ECEX_MINIBUFFER_SIZE];
+            snprintf(msg, sizeof(msg), "Executed: %s", command);
+            app_message(app, msg);
+        }
+    } else {
+        char msg[ECEX_MINIBUFFER_SIZE];
+        snprintf(msg, sizeof(msg), "No such command: %s", command);
+        app_message(app, msg);
+    }
+
+    if (app->ed->should_quit) {
+        glfwSetWindowShouldClose(app->window, GLFW_TRUE);
+        glfwPostEmptyEvent();
+    }
+
+    app->dirty = 1;
+}
+
+static void app_complete_mx(app_t *app) {
+    if (!app) return;
+
+    if (app->completion_active) {
+        app_cycle_completion(app, 1);
+    } else {
+        app_begin_completion(app, 1);
+    }
+}
+
+static void app_enter_prefix(app_t *app, const char *first_key) {
+    if (!app || !first_key) return;
+
+    app->mode = APP_MODE_PREFIX;
+    app->minibuffer[0] = '\0';
+    app->minibuffer_len = 0;
+    app_reset_completion(app);
+
+    snprintf(app->prefix, sizeof(app->prefix), "%s", first_key);
+    app->prefix_len = strlen(app->prefix);
+
+    app->message[0] = '\0';
+    app->dirty = 1;
+}
+
+static void app_cancel_prefix(app_t *app) {
+    if (!app) return;
+
+    app->mode = APP_MODE_EDIT;
+    app->prefix[0] = '\0';
+    app->prefix_len = 0;
+
+    app_message(app, "Prefix cancelled");
+}
+
+static int app_append_prefix_key(app_t *app, const char *key_name) {
+    if (!app || !key_name) return -1;
+
+    size_t key_len = strlen(key_name);
+
+    if (app->prefix_len + 1 + key_len + 1 >= sizeof(app->prefix)) {
+        app_cancel_prefix(app);
+        return -1;
+    }
+
+    app->prefix[app->prefix_len++] = ' ';
+    memcpy(app->prefix + app->prefix_len, key_name, key_len + 1);
+    app->prefix_len += key_len;
+
+    return 0;
+}
+
+static int key_sequence_has_prefix(app_t *app, const char *prefix) {
+    if (!app || !app->ed || !prefix) return 0;
+    return ecex_key_sequence_has_prefix_for_buffer(app->ed,
+                                                   ecex_current_buffer(app->ed),
+                                                   prefix);
+}
+
+static void app_finish_prefix(app_t *app) {
+    if (!app) return;
+
+    const char *command = ecex_lookup_key_for_buffer(app->ed, ecex_current_buffer(app->ed), app->prefix);
+
+    if (command) {
+        if (app_execute_command(app, command) == 0) {
+            if (app->mode == APP_MODE_EDIT) {
+                char msg[ECEX_MINIBUFFER_SIZE];
+                snprintf(msg, sizeof(msg), "Executed: %s", command);
+                app_message(app, msg);
+            }
+        } else {
+            char msg[ECEX_MINIBUFFER_SIZE];
+            snprintf(msg, sizeof(msg), "Command failed: %s", command);
+            app_message(app, msg);
+        }
+
+        if (app->ed->should_quit) {
+            glfwSetWindowShouldClose(app->window, GLFW_TRUE);
+            glfwPostEmptyEvent();
+        }
+
+        if (app->mode != APP_MODE_PROMPT) {
+            app->mode = APP_MODE_EDIT;
+        }
+        app->prefix[0] = '\0';
+        app->prefix_len = 0;
+        app->dirty = 1;
+        return;
+    }
+
+    if (key_sequence_has_prefix(app, app->prefix)) {
+        app->dirty = 1;
+        return;
+    }
+
+    char msg[ECEX_MINIBUFFER_SIZE];
+    snprintf(msg, sizeof(msg), "Undefined key: %s", app->prefix);
+
+    app->mode = APP_MODE_EDIT;
+    app->prefix[0] = '\0';
+    app->prefix_len = 0;
+
+    app_message(app, msg);
+}
+
+
+static float app_mono_cell_width(app_t *app) {
+    float w = text_width(&app->font, "M");
+    return w > 1.0f ? w : app->font.size_px * 0.6f;
+}
+
+static float app_status_height(app_t *app) {
+    float line_h = app->font.line_height > 1.0f ? app->font.line_height : app->font.size_px * 1.2f;
+    float pad_y = app->font.size_px * 0.35f;
+    if (pad_y < 4.0f) pad_y = 4.0f;
+    return line_h + pad_y * 2.0f;
+}
+
+static float app_minibuffer_height(app_t *app) { return app_status_height(app); }
+
+static int app_minibuffer_visible(app_t *app) {
+    return app->mode == APP_MODE_MX || app->mode == APP_MODE_PREFIX ||
+           app->mode == APP_MODE_PROMPT || app->mode == APP_MODE_ISEARCH ||
+           app->message[0] != '\0';
+}
+
+static size_t app_offset_for_line(buffer_t *buf, size_t target_line) {
+    if (!buf || target_line == 0) return 0;
+    size_t line = 0;
+    for (size_t i = 0; i < buf->len; i++) {
+        if (buf->data[i] == '\n') {
+            line++;
+            if (line == target_line) return i + 1;
+        }
+    }
+    return buf->len;
+}
+
+static int app_focus_window_at(app_t *app, double px, double py) {
+    if (!app || !app->ed || app->ed->window_count == 0) return -1;
+    float editor_h = (float)app->height - app_status_height(app);
+    if (app_minibuffer_visible(app)) editor_h -= app_minibuffer_height(app);
+    if (editor_h < 1.0f) editor_h = 1.0f;
+    for (size_t i = 0; i < app->ed->window_count; i++) {
+        ecex_window_t *w = &app->ed->windows[i];
+        float x = w->x * (float)app->width;
+        float y = w->y * editor_h;
+        float ww = w->w * (float)app->width;
+        float hh = w->h * editor_h;
+        if (px >= x && px < x + ww && py >= y && py < y + hh) {
+            app->ed->current_window_index = i;
+            ecex_sync_current_buffer(app->ed);
+            return (int)i;
+        }
+    }
+    return -1;
+}
+
+static void app_move_point_to_pixel(app_t *app, double px, double py) {
+    int wi = app_focus_window_at(app, px, py);
+    if (wi < 0) return;
+    ecex_window_t *w = &app->ed->windows[wi];
+    buffer_t *buf = w->buffer;
+    if (!buf) return;
+    float editor_h = (float)app->height - app_status_height(app);
+    if (app_minibuffer_visible(app)) editor_h -= app_minibuffer_height(app);
+    float wx = w->x * (float)app->width;
+    float wy = w->y * editor_h;
+    float pad_x = app->font.size_px * 0.75f; if (pad_x < 8.0f) pad_x = 8.0f;
+    float pad_y = app->font.size_px * 0.35f; if (pad_y < 4.0f) pad_y = 4.0f;
+    size_t row = py > wy + pad_y ? (size_t)((py - wy - pad_y) / app->font.line_height) : 0;
+    size_t col = px > wx + pad_x ? (size_t)((px - wx - pad_x) / app_mono_cell_width(app)) : 0;
+    size_t line = buf->scroll_line + row;
+    size_t start = app_offset_for_line(buf, line);
+    size_t end = buffer_line_end_at(buf, start);
+    buffer_set_point(buf, start + ECEX_MIN(col + buf->scroll_col, end - start));
+    app->dirty = 1;
+}
+
+static void mouse_button_callback(GLFWwindow *window, int button, int action, int mods) {
+    (void)mods;
+    if (button != GLFW_MOUSE_BUTTON_LEFT || action != GLFW_PRESS) return;
+    app_t *app = glfwGetWindowUserPointer(window);
+    if (!app) return;
+    glfwGetFramebufferSize(window, &app->width, &app->height);
+    double x = 0.0, y = 0.0;
+    glfwGetCursorPos(window, &x, &y);
+    app_move_point_to_pixel(app, x, y);
+}
+
+static void scroll_callback(GLFWwindow *window, double xoffset, double yoffset) {
+    (void)xoffset;
+    app_t *app = glfwGetWindowUserPointer(window);
+    if (!app || !app->ed) return;
+    buffer_t *buf = ecex_current_buffer(app->ed);
+    if (!buf) return;
+    if (yoffset < 0.0) buf->scroll_line += 3;
+    else if (yoffset > 0.0) buf->scroll_line = buf->scroll_line > 3 ? buf->scroll_line - 3 : 0;
+    app->dirty = 1;
+}
+
+static void mark_dirty(GLFWwindow *window) {
+    app_t *app = glfwGetWindowUserPointer(window);
+    if (app) {
+        app->dirty = 1;
+    }
+}
+
+static void framebuffer_size_callback(GLFWwindow *window, int width, int height) {
+    (void)width;
+    (void)height;
+
+    mark_dirty(window);
+}
+
+static void window_refresh_callback(GLFWwindow *window) {
+    mark_dirty(window);
+}
+
+static const char *key_name_for_special(int key) {
+    switch (key) {
+        case GLFW_KEY_F1: return "F1";
+        case GLFW_KEY_F2: return "F2";
+        case GLFW_KEY_F3: return "F3";
+        case GLFW_KEY_F4: return "F4";
+        case GLFW_KEY_F5: return "F5";
+        case GLFW_KEY_LEFT: return "LEFT";
+        case GLFW_KEY_RIGHT: return "RIGHT";
+        case GLFW_KEY_UP: return "UP";
+        case GLFW_KEY_DOWN: return "DOWN";
+        case GLFW_KEY_ENTER: return "ENTER";
+        case GLFW_KEY_BACKSPACE: return "BACKSPACE";
+        case GLFW_KEY_DELETE: return "DELETE";
+        case GLFW_KEY_TAB: return "TAB";
+        case GLFW_KEY_SPACE: return "SPC";
+        case GLFW_KEY_ESCAPE: return "ESC";
+        case GLFW_KEY_HOME: return "HOME";
+        case GLFW_KEY_END: return "END";
+        case GLFW_KEY_PAGE_UP: return "PAGEUP";
+        case GLFW_KEY_PAGE_DOWN: return "PAGEDOWN";
+        default: return NULL;
+    }
+}
+
+static int layout_key_name(int key,
+                           int scancode,
+                           char *out,
+                           size_t out_size) {
+    if (!out || out_size == 0) return -1;
+
+    out[0] = '\0';
+
+    const char *special = key_name_for_special(key);
+    if (special) {
+        snprintf(out, out_size, "%s", special);
+        return 0;
+    }
+
+    const char *name = glfwGetKeyName(key, scancode);
+    if (!name || !name[0]) return -1;
+
+    if (name[1] != '\0') return -1;
+
+    char c = name[0];
+    if (c >= 'A' && c <= 'Z') {
+        c = (char)(c - 'A' + 'a');
+    }
+
+    out[0] = c;
+    out[1] = '\0';
+    return 0;
+}
+
+static int key_event_to_string(int key,
+                               int scancode,
+                               int mods,
+                               char *out,
+                               size_t out_size) {
+    if (!out || out_size == 0) return -1;
+
+    out[0] = '\0';
+
+    char base[32];
+    if (layout_key_name(key, scancode, base, sizeof(base)) != 0) {
+        return -1;
+    }
+
+    char prefix[32];
+    prefix[0] = '\0';
+
+    if (mods & GLFW_MOD_CONTROL) {
+        strncat(prefix, "C-", sizeof(prefix) - strlen(prefix) - 1);
+    }
+
+    if (mods & GLFW_MOD_ALT) {
+        strncat(prefix, "M-", sizeof(prefix) - strlen(prefix) - 1);
+    }
+
+    if (mods & GLFW_MOD_SUPER) {
+        strncat(prefix, "S-", sizeof(prefix) - strlen(prefix) - 1);
+    }
+
+    snprintf(out, out_size, "%s%s", prefix, base);
+    return 0;
+}
+
+static int is_layout_char_key(int key,
+                              int scancode,
+                              char wanted) {
+    char name[32];
+
+    if (layout_key_name(key, scancode, name, sizeof(name)) != 0) {
+        return 0;
+    }
+
+    if (wanted >= 'A' && wanted <= 'Z') {
+        wanted = (char)(wanted - 'A' + 'a');
+    }
+
+    return name[0] == wanted && name[1] == '\0';
+}
+
+static int key_produces_text(int key, int scancode) {
+    if (key_name_for_special(key)) {
+        return 0;
+    }
+
+    const char *name = glfwGetKeyName(key, scancode);
+    return name && name[0] && name[1] == '\0';
+}
+
+static void try_execute_keybind(app_t *app, const char *key_name) {
+    const char *command = ecex_lookup_key_for_buffer(app->ed, ecex_current_buffer(app->ed), key_name);
+    if (!command) return;
+
+    if (app_execute_command(app, command) == 0) {
+        app->dirty = 1;
+    } else {
+        char msg[ECEX_MINIBUFFER_SIZE];
+        snprintf(msg, sizeof(msg), "Bad keybind: %s -> %s", key_name, command);
+        app_message(app, msg);
+    }
+
+    if (app->ed->should_quit) {
+        glfwSetWindowShouldClose(app->window, GLFW_TRUE);
+        glfwPostEmptyEvent();
+    }
+}
+
+static void char_callback(GLFWwindow *window, unsigned int codepoint) {
+    app_t *app = glfwGetWindowUserPointer(window);
+    if (!app || !app->ed) return;
+
+    if (app->suppress_next_char) {
+        app->suppress_next_char = 0;
+        return;
+    }
+
+    if (app->mode == APP_MODE_EDIT) {
+        if ((app->current_mods & GLFW_MOD_ALT) && codepoint == 'x') {
+            app_enter_mx(app);
+            return;
+        }
+    }
+
+    if (app->mode == APP_MODE_MX) {
+        if (codepoint >= 32 && codepoint <= 126) {
+            if (app->minibuffer_len + 1 < sizeof(app->minibuffer)) {
+                app_reset_completion(app);
+                app->minibuffer[app->minibuffer_len++] = (char)codepoint;
+                app->minibuffer[app->minibuffer_len] = '\0';
+                app->dirty = 1;
+            }
+        }
+        return;
+    }
+
+    if (app->mode == APP_MODE_ISEARCH) {
+        if (codepoint >= 32 && codepoint <= 126) {
+            if (app->isearch_len + 1 < sizeof(app->isearch_query)) {
+                app->isearch_query[app->isearch_len++] = (char)codepoint;
+                app->isearch_query[app->isearch_len] = '\0';
+                app_update_isearch(app);
+            }
+        }
+        return;
+    }
+
+    if (app->mode == APP_MODE_PROMPT) {
+        if (codepoint >= 32 && codepoint <= 126) {
+            if (app->prompt_input_len + 1 < sizeof(app->prompt_input)) {
+                app->prompt_input[app->prompt_input_len++] = (char)codepoint;
+                app->prompt_input[app->prompt_input_len] = '\0';
+                app->dirty = 1;
+            }
+        }
+        return;
+    }
+
+    if (app->mode == APP_MODE_PREFIX) {
+        return;
+    }
+
+    buffer_t *buf = ecex_current_buffer(app->ed);
+    if (!buf) return;
+
+    if (buffer_is_interactive(buf)) {
+        return;
+    }
+
+    if (codepoint >= 32 && codepoint <= 126) {
+        buffer_insert_char(buf, (char)codepoint);
+        app->message[0] = '\0';
+        app->dirty = 1;
+    }
+}
+
+static void key_callback(GLFWwindow *window,
+                         int key,
+                         int scancode,
+                         int action,
+                         int mods) {
+    if (action != GLFW_PRESS && action != GLFW_REPEAT) {
+        return;
+    }
+
+    app_t *app = glfwGetWindowUserPointer(window);
+    if (!app || !app->ed) return;
+
+    app->current_mods = mods;
+
+    if (app->mode == APP_MODE_EDIT && key == GLFW_KEY_F1) {
+        app_enter_mx(app);
+        return;
+    }
+
+    if (app->mode == APP_MODE_EDIT &&
+        (mods & GLFW_MOD_ALT) &&
+        is_layout_char_key(key, scancode, 'g')) {
+        app_enter_prefix(app, "M-g");
+        return;
+    }
+
+    if (app->mode == APP_MODE_EDIT &&
+        (mods & GLFW_MOD_CONTROL) &&
+        is_layout_char_key(key, scancode, 'x')) {
+        app_enter_prefix(app, "C-x");
+        return;
+    }
+
+    if (app->mode == APP_MODE_MX) {
+        switch (key) {
+            case GLFW_KEY_ESCAPE:
+                app_cancel_mx(app);
+                return;
+
+            case GLFW_KEY_ENTER:
+                app_execute_mx(app);
+                return;
+
+            case GLFW_KEY_TAB:
+                app_complete_mx(app);
+                return;
+
+            case GLFW_KEY_DOWN:
+                app_cycle_completion(app, 1);
+                return;
+
+            case GLFW_KEY_UP:
+                app_cycle_completion(app, -1);
+                return;
+
+            case GLFW_KEY_BACKSPACE:
+                if (app->minibuffer_len > 0) {
+                    app_reset_completion(app);
+                    app->minibuffer_len--;
+                    app->minibuffer[app->minibuffer_len] = '\0';
+                    app->dirty = 1;
+                }
+                return;
+
+            default:
+                return;
+        }
+    }
+
+    if (app->mode == APP_MODE_ISEARCH) {
+        switch (key) {
+            case GLFW_KEY_ESCAPE:
+                app_cancel_isearch(app);
+                return;
+            case GLFW_KEY_ENTER:
+                app_finish_isearch(app);
+                return;
+            case GLFW_KEY_BACKSPACE:
+                if (app->isearch_len > 0) {
+                    app->isearch_len--;
+                    app->isearch_query[app->isearch_len] = '\0';
+                    buffer_t *buf = ecex_current_buffer(app->ed);
+                    if (buf) {
+                        buffer_set_point(buf, app->isearch_origin);
+                        buffer_clear_mark(buf);
+                    }
+                    app_update_isearch(app);
+                }
+                return;
+            default:
+                if ((mods & GLFW_MOD_CONTROL) && is_layout_char_key(key, scancode, 's')) {
+                    app->isearch_backward = 0;
+                    app_update_isearch(app);
+                    return;
+                }
+                if ((mods & GLFW_MOD_CONTROL) && is_layout_char_key(key, scancode, 'r')) {
+                    app->isearch_backward = 1;
+                    app_update_isearch(app);
+                    return;
+                }
+                return;
+        }
+    }
+
+    if (app->mode == APP_MODE_PROMPT) {
+        switch (key) {
+            case GLFW_KEY_ESCAPE:
+                app_cancel_prompt(app);
+                return;
+
+            case GLFW_KEY_ENTER:
+                app_submit_prompt(app);
+                return;
+
+            case GLFW_KEY_TAB:
+                app_cycle_prompt_completion(app, 1);
+                return;
+
+            case GLFW_KEY_DOWN:
+                app_cycle_prompt_completion(app, 1);
+                return;
+
+            case GLFW_KEY_UP:
+                app_cycle_prompt_completion(app, -1);
+                return;
+
+            case GLFW_KEY_BACKSPACE:
+                if (app->prompt_input_len > 0) {
+                    app_reset_prompt_completion(app);
+                    app->prompt_input_len--;
+                    app->prompt_input[app->prompt_input_len] = '\0';
+                    app->dirty = 1;
+                }
+                return;
+
+            default:
+                return;
+        }
+    }
+
+    if (app->mode == APP_MODE_PREFIX) {
+        if (key == GLFW_KEY_ESCAPE) {
+            app_cancel_prefix(app);
+            return;
+        }
+
+        char key_name[64];
+
+        if (key_event_to_string(key, scancode, mods, key_name, sizeof(key_name)) == 0) {
+            if (key_produces_text(key, scancode)) {
+                app->suppress_next_char = 1;
+            }
+
+            if (app_append_prefix_key(app, key_name) == 0) {
+                app_finish_prefix(app);
+            }
+            return;
+        }
+
+        app_cancel_prefix(app);
+        return;
+    }
+
+    char key_name[64];
+    if (key_event_to_string(key, scancode, mods, key_name, sizeof(key_name)) == 0) {
+        const char *command = ecex_lookup_key_for_buffer(app->ed, ecex_current_buffer(app->ed), key_name);
+        if (command) {
+            if (key_produces_text(key, scancode) &&
+                !(mods & GLFW_MOD_CONTROL) &&
+                !(mods & GLFW_MOD_SUPER)) {
+                app->suppress_next_char = 1;
+            }
+
+            try_execute_keybind(app, key_name);
+            return;
+        }
+    }
+
+    if (key == GLFW_KEY_ESCAPE) {
+        glfwSetWindowShouldClose(window, GLFW_TRUE);
+        glfwPostEmptyEvent();
+        return;
+    }
+}
+
+void app_init(app_t *app, ecex_t *ed) {
+    if (!app) return;
+
+    memset(app, 0, sizeof(*app));
+    app->ed = ed;
+    app->dirty = 1;
+    app->mode = APP_MODE_EDIT;
+    app_reset_completion(app);
+    app_reset_prompt_completion(app);
+}
+
+void app_set_window(app_t *app, GLFWwindow *window) {
+    if (!app) return;
+
+    app->window = window;
+    if (app->ed) {
+        ecex_set_clipboard_callbacks(app->ed,
+                                     window ? app_clipboard_get : NULL,
+                                     window ? app_clipboard_set : NULL,
+                                     app);
+    }
+    if (window) {
+        glfwSetWindowUserPointer(window, app);
+    }
+}
+
+void app_install_callbacks(app_t *app) {
+    if (!app || !app->window) return;
+
+    glfwSetCharCallback(app->window, char_callback);
+    glfwSetKeyCallback(app->window, key_callback);
+    glfwSetFramebufferSizeCallback(app->window, framebuffer_size_callback);
+    glfwSetWindowRefreshCallback(app->window, window_refresh_callback);
+    glfwSetMouseButtonCallback(app->window, mouse_button_callback);
+    glfwSetScrollCallback(app->window, scroll_callback);
+}
diff --git a/src/buffers.c b/src/buffers.c
new file mode 100644
index 0000000..e8c1d23
--- /dev/null
+++ b/src/buffers.c
@@ -0,0 +1,701 @@
+#include "buffers.h"
+
+#include "common.h"
+#include "util.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define BUFFER_INITIAL_CAP 64
+
+static int buffer_is_word_char(char c) {
+    return (c >= 'a' && c <= 'z') ||
+           (c >= 'A' && c <= 'Z') ||
+           (c >= '0' && c <= '9') ||
+           c == '_';
+}
+
+static int buffer_require_editable(buffer_t *buffer) {
+    if (!buffer || buffer->read_only) return ECEX_ERR;
+    return ECEX_OK;
+}
+
+static void buffer_undo_entry_free(ecex_undo_entry_t *entry) {
+    if (!entry) return;
+    free(entry->data);
+    entry->data = NULL;
+    entry->len = 0;
+    entry->point = 0;
+    entry->mark = 0;
+    entry->mark_active = 0;
+}
+
+static void buffer_undo_stack_clear(ecex_undo_entry_t *stack, size_t count) {
+    if (!stack) return;
+    for (size_t i = 0; i < count; i++) buffer_undo_entry_free(&stack[i]);
+}
+
+static int buffer_push_snapshot_to(ecex_undo_entry_t **stack,
+                                   size_t *count,
+                                   size_t *cap,
+                                   buffer_t *buffer) {
+    if (!stack || !count || !cap || !buffer) return ECEX_ERR;
+    if (ECEX_GROW_ARRAY(*stack, *count, *cap, 64) != ECEX_OK) return ECEX_ERR;
+    ecex_undo_entry_t *entry = &(*stack)[(*count)++];
+    memset(entry, 0, sizeof(*entry));
+    entry->data = malloc(buffer->len + 1);
+    if (!entry->data) { (*count)--; return ECEX_ERR; }
+    memcpy(entry->data, buffer->data, buffer->len + 1);
+    entry->len = buffer->len;
+    entry->point = buffer->point;
+    entry->mark = buffer->mark;
+    entry->mark_active = buffer->mark_active;
+    return ECEX_OK;
+}
+
+static void buffer_clear_redo(buffer_t *buffer) {
+    if (!buffer) return;
+    buffer_undo_stack_clear(buffer->redo_stack, buffer->redo_count);
+    buffer->redo_count = 0;
+}
+
+static int buffer_record_undo(buffer_t *buffer) {
+    if (!buffer || buffer->undo_disabled) return ECEX_OK;
+    if (buffer_push_snapshot_to(&buffer->undo_stack,
+                                &buffer->undo_count,
+                                &buffer->undo_cap,
+                                buffer) != ECEX_OK) {
+        return ECEX_ERR;
+    }
+    buffer_clear_redo(buffer);
+    return ECEX_OK;
+}
+
+static int buffer_restore_snapshot(buffer_t *buffer, ecex_undo_entry_t *entry) {
+    if (!buffer || !entry || !entry->data) return ECEX_ERR;
+    char *copy = malloc(entry->len + 1);
+    if (!copy) return ECEX_ERR;
+    memcpy(copy, entry->data, entry->len + 1);
+    free(buffer->data);
+    buffer->data = copy;
+    buffer->len = entry->len;
+    buffer->cap = entry->len + 1;
+    buffer->point = ECEX_MIN(entry->point, buffer->len);
+    buffer->mark = ECEX_MIN(entry->mark, buffer->len);
+    buffer->mark_active = entry->mark_active;
+    buffer->modified = 1;
+    return ECEX_OK;
+}
+
+buffer_t *buffer_new(const char *name, const char *path, int read_only) {
+    assert(name && "buffer name cannot be NULL");
+
+    buffer_t *buffer = calloc(1, sizeof(*buffer));
+    if (!buffer) return NULL;
+
+    buffer->name = ecex_strdup(name);
+    buffer->path = ecex_strdup(path);
+    buffer->data = malloc(1);
+
+    if (!buffer->name || (path && !buffer->path) || !buffer->data) {
+        buffer_free(buffer);
+        return NULL;
+    }
+
+    buffer->data[0] = '\0';
+    buffer->len = 0;
+    buffer->cap = 1;
+    buffer->read_only = read_only;
+
+    return buffer;
+}
+
+void buffer_free(buffer_t *buffer) {
+    if (!buffer) return;
+
+    buffer_clear_interactive_actions(buffer);
+    buffer_undo_stack_clear(buffer->undo_stack, buffer->undo_count);
+    buffer_undo_stack_clear(buffer->redo_stack, buffer->redo_count);
+    free(buffer->undo_stack);
+    free(buffer->redo_stack);
+    free(buffer->interactive_actions);
+    free(buffer->name);
+    free(buffer->path);
+    free(buffer->data);
+    free(buffer);
+}
+
+int buffer_reserve(buffer_t *buffer, size_t needed) {
+    ECEX_RETURN_ERR_IF_NULL(buffer);
+    if (needed <= buffer->cap) return ECEX_OK;
+
+    size_t new_cap = buffer->cap ? buffer->cap : BUFFER_INITIAL_CAP;
+    while (new_cap < needed) {
+        new_cap *= 2;
+    }
+
+    char *new_data = realloc(buffer->data, new_cap);
+    if (!new_data) return ECEX_ERR;
+
+    buffer->data = new_data;
+    buffer->cap = new_cap;
+    return ECEX_OK;
+}
+
+int buffer_clear(buffer_t *buffer) {
+    if (buffer_require_editable(buffer) != ECEX_OK) return ECEX_ERR;
+    if (buffer_record_undo(buffer) != ECEX_OK) return ECEX_ERR;
+
+    if (buffer_reserve(buffer, 1) != ECEX_OK) return ECEX_ERR;
+
+    buffer->data[0] = '\0';
+    buffer->len = 0;
+    buffer->point = 0;
+    buffer->mark = 0;
+    buffer->mark_active = 0;
+    buffer->scroll_line = 0;
+    buffer->scroll_col = 0;
+    buffer_clear_interactive_actions(buffer);
+    buffer->modified = 1;
+    return ECEX_OK;
+}
+
+int buffer_set_text(buffer_t *buffer, const char *text) {
+    if (buffer_require_editable(buffer) != ECEX_OK || !text) return ECEX_ERR;
+    if (buffer_record_undo(buffer) != ECEX_OK) return ECEX_ERR;
+
+    size_t len = strlen(text);
+    if (buffer_reserve(buffer, len + 1) != ECEX_OK) return ECEX_ERR;
+
+    memcpy(buffer->data, text, len + 1);
+    buffer->len = len;
+    buffer->point = len;
+    buffer->mark = 0;
+    buffer->mark_active = 0;
+    buffer->scroll_line = 0;
+    buffer->scroll_col = 0;
+    buffer_clear_interactive_actions(buffer);
+    buffer->modified = 1;
+    return ECEX_OK;
+}
+
+int buffer_insert_at(buffer_t *buffer, size_t pos, const char *text) {
+    if (buffer_require_editable(buffer) != ECEX_OK || !text) return ECEX_ERR;
+    if (pos > buffer->len) return ECEX_ERR;
+
+    size_t text_len = strlen(text);
+    if (text_len == 0) return ECEX_OK;
+    if (buffer_record_undo(buffer) != ECEX_OK) return ECEX_ERR;
+    size_t needed = buffer->len + text_len + 1;
+
+    if (buffer_reserve(buffer, needed) != ECEX_OK) return ECEX_ERR;
+
+    memmove(buffer->data + pos + text_len,
+            buffer->data + pos,
+            buffer->len - pos + 1);
+    memcpy(buffer->data + pos, text, text_len);
+
+    buffer->len += text_len;
+    buffer->point = pos + text_len;
+    buffer->modified = 1;
+    return ECEX_OK;
+}
+
+int buffer_insert(buffer_t *buffer, const char *text) {
+    ECEX_RETURN_ERR_IF_NULL(buffer);
+    return buffer_insert_at(buffer, buffer->point, text);
+}
+
+int buffer_append(buffer_t *buffer, const char *text) {
+    ECEX_RETURN_ERR_IF_NULL(buffer);
+    return buffer_insert_at(buffer, buffer->len, text);
+}
+
+int buffer_prepend(buffer_t *buffer, const char *text) {
+    return buffer_insert_at(buffer, 0, text);
+}
+
+int buffer_insert_char_at(buffer_t *buffer, size_t pos, char c) {
+    if (buffer_require_editable(buffer) != ECEX_OK) return ECEX_ERR;
+    if (pos > buffer->len) return ECEX_ERR;
+    if (buffer_record_undo(buffer) != ECEX_OK) return ECEX_ERR;
+
+    if (buffer_reserve(buffer, buffer->len + 2) != ECEX_OK) return ECEX_ERR;
+
+    memmove(buffer->data + pos + 1,
+            buffer->data + pos,
+            buffer->len - pos + 1);
+
+    buffer->data[pos] = c;
+    buffer->len++;
+    buffer->point = pos + 1;
+    buffer->modified = 1;
+    return ECEX_OK;
+}
+
+int buffer_insert_char(buffer_t *buffer, char c) {
+    ECEX_RETURN_ERR_IF_NULL(buffer);
+    return buffer_insert_char_at(buffer, buffer->point, c);
+}
+
+int buffer_delete_range(buffer_t *buffer, size_t start, size_t end) {
+    if (buffer_require_editable(buffer) != ECEX_OK) return ECEX_ERR;
+    if (start > end || end > buffer->len) return ECEX_ERR;
+    if (start == end) return ECEX_OK;
+    if (buffer_record_undo(buffer) != ECEX_OK) return ECEX_ERR;
+
+    size_t deleted = end - start;
+
+    memmove(buffer->data + start,
+            buffer->data + end,
+            buffer->len - end + 1);
+
+    buffer->len -= deleted;
+
+    if (buffer->point > end) {
+        buffer->point -= deleted;
+    } else if (buffer->point > start) {
+        buffer->point = start;
+    }
+
+    if (buffer->mark > end) {
+        buffer->mark -= deleted;
+    } else if (buffer->mark > start) {
+        buffer->mark = start;
+    }
+
+    if (buffer->mark_active && buffer->mark == buffer->point) {
+        buffer->mark_active = 0;
+    }
+
+    buffer->modified = 1;
+    return ECEX_OK;
+}
+
+int buffer_delete_selection(buffer_t *buffer) {
+    if (!buffer_has_selection(buffer)) return ECEX_OK;
+
+    size_t start = 0;
+    size_t end = 0;
+    buffer_selection_range(buffer, &start, &end);
+
+    int result = buffer_delete_range(buffer, start, end);
+    if (result == ECEX_OK) buffer_clear_mark(buffer);
+    return result;
+}
+
+int buffer_replace_selection(buffer_t *buffer, const char *text) {
+    if (!buffer || !text) return ECEX_ERR;
+    if (!buffer_has_selection(buffer)) return buffer_insert(buffer, text);
+
+    size_t start = 0;
+    size_t end = 0;
+    buffer_selection_range(buffer, &start, &end);
+
+    if (buffer_delete_range(buffer, start, end) != ECEX_OK) return ECEX_ERR;
+    buffer->point = start;
+    buffer_clear_mark(buffer);
+    return buffer_insert(buffer, text);
+}
+
+int buffer_backspace(buffer_t *buffer) {
+    if (!buffer) return ECEX_ERR;
+    if (buffer_has_selection(buffer)) return buffer_delete_selection(buffer);
+    if (buffer->point == 0) return ECEX_OK;
+    return buffer_delete_range(buffer, buffer->point - 1, buffer->point);
+}
+
+int buffer_delete_forward(buffer_t *buffer) {
+    if (!buffer) return ECEX_ERR;
+    if (buffer_has_selection(buffer)) return buffer_delete_selection(buffer);
+    if (buffer->point >= buffer->len) return ECEX_OK;
+    return buffer_delete_range(buffer, buffer->point, buffer->point + 1);
+}
+
+int buffer_kill_line(buffer_t *buffer) {
+    if (!buffer) return ECEX_ERR;
+
+    size_t end = buffer_line_end_at(buffer, buffer->point);
+    if (end == buffer->point && end < buffer->len && buffer->data[end] == '\n') {
+        end++;
+    }
+
+    return buffer_delete_range(buffer, buffer->point, end);
+}
+
+void buffer_set_point(buffer_t *buffer, size_t point) {
+    if (!buffer) return;
+    buffer->point = ECEX_MIN(point, buffer->len);
+}
+
+void buffer_move_left(buffer_t *buffer) {
+    if (!buffer || buffer->point == 0) return;
+    buffer->point--;
+}
+
+void buffer_move_right(buffer_t *buffer) {
+    if (!buffer || buffer->point >= buffer->len) return;
+    buffer->point++;
+}
+
+void buffer_move_up(buffer_t *buffer) {
+    if (!buffer) return;
+
+    size_t current_start = buffer_line_start_at(buffer, buffer->point);
+    if (current_start == 0) {
+        buffer->point = 0;
+        return;
+    }
+
+    size_t wanted_col = buffer->point - current_start;
+    size_t prev_end = current_start - 1;
+    size_t prev_start = buffer_line_start_at(buffer, prev_end);
+    size_t prev_len = prev_end - prev_start;
+
+    buffer->point = prev_start + ECEX_MIN(wanted_col, prev_len);
+}
+
+void buffer_move_down(buffer_t *buffer) {
+    if (!buffer) return;
+
+    size_t current_start = buffer_line_start_at(buffer, buffer->point);
+    size_t current_end = buffer_line_end_at(buffer, buffer->point);
+    if (current_end >= buffer->len) {
+        buffer->point = buffer->len;
+        return;
+    }
+
+    size_t wanted_col = buffer->point - current_start;
+    size_t next_start = current_end + 1;
+    size_t next_end = buffer_line_end_at(buffer, next_start);
+    size_t next_len = next_end - next_start;
+
+    buffer->point = next_start + ECEX_MIN(wanted_col, next_len);
+}
+
+void buffer_move_word_left(buffer_t *buffer) {
+    if (!buffer) return;
+
+    size_t pos = buffer->point;
+    while (pos > 0 && !buffer_is_word_char(buffer->data[pos - 1])) pos--;
+    while (pos > 0 && buffer_is_word_char(buffer->data[pos - 1])) pos--;
+    buffer->point = pos;
+}
+
+void buffer_move_word_right(buffer_t *buffer) {
+    if (!buffer) return;
+
+    size_t pos = buffer->point;
+    while (pos < buffer->len && !buffer_is_word_char(buffer->data[pos])) pos++;
+    while (pos < buffer->len && buffer_is_word_char(buffer->data[pos])) pos++;
+    buffer->point = pos;
+}
+
+void buffer_move_beginning_of_line(buffer_t *buffer) {
+    if (!buffer) return;
+    buffer->point = buffer_line_start_at(buffer, buffer->point);
+}
+
+void buffer_move_end_of_line(buffer_t *buffer) {
+    if (!buffer) return;
+    buffer->point = buffer_line_end_at(buffer, buffer->point);
+}
+
+void buffer_move_beginning_of_buffer(buffer_t *buffer) {
+    if (!buffer) return;
+    buffer->point = 0;
+}
+
+void buffer_move_end_of_buffer(buffer_t *buffer) {
+    if (!buffer) return;
+    buffer->point = buffer->len;
+}
+
+void buffer_set_mark(buffer_t *buffer, size_t mark) {
+    if (!buffer) return;
+    buffer->mark = ECEX_MIN(mark, buffer->len);
+    buffer->mark_active = 1;
+}
+
+void buffer_clear_mark(buffer_t *buffer) {
+    if (!buffer) return;
+    buffer->mark_active = 0;
+}
+
+int buffer_has_selection(buffer_t *buffer) {
+    return buffer && buffer->mark_active && buffer->mark != buffer->point;
+}
+
+void buffer_selection_range(buffer_t *buffer, size_t *out_start, size_t *out_end) {
+    size_t start = 0;
+    size_t end = 0;
+
+    if (buffer && buffer_has_selection(buffer)) {
+        start = ECEX_MIN(buffer->point, buffer->mark);
+        end = ECEX_MAX(buffer->point, buffer->mark);
+    }
+
+    if (out_start) *out_start = start;
+    if (out_end) *out_end = end;
+}
+
+size_t buffer_line_start_at(buffer_t *buffer, size_t pos) {
+    if (!buffer) return 0;
+    pos = ECEX_MIN(pos, buffer->len);
+
+    while (pos > 0 && buffer->data[pos - 1] != '\n') {
+        pos--;
+    }
+
+    return pos;
+}
+
+size_t buffer_line_end_at(buffer_t *buffer, size_t pos) {
+    if (!buffer) return 0;
+    pos = ECEX_MIN(pos, buffer->len);
+
+    while (pos < buffer->len && buffer->data[pos] != '\n') {
+        pos++;
+    }
+
+    return pos;
+}
+
+size_t buffer_current_line_start(buffer_t *buffer) {
+    if (!buffer) return 0;
+    return buffer_line_start_at(buffer, buffer->point);
+}
+
+size_t buffer_current_line_end(buffer_t *buffer) {
+    if (!buffer) return 0;
+    return buffer_line_end_at(buffer, buffer->point);
+}
+
+size_t buffer_current_column(buffer_t *buffer) {
+    if (!buffer) return 0;
+    return buffer->point - buffer_line_start_at(buffer, buffer->point);
+}
+
+size_t buffer_current_line_number(buffer_t *buffer) {
+    if (!buffer) return 0;
+
+    size_t line = 1;
+    for (size_t i = 0; i < buffer->point && i < buffer->len; i++) {
+        if (buffer->data[i] == '\n') line++;
+    }
+
+    return line;
+}
+
+size_t buffer_line_count(buffer_t *buffer) {
+    if (!buffer || buffer->len == 0) return 1;
+
+    size_t lines = 1;
+    for (size_t i = 0; i < buffer->len; i++) {
+        if (buffer->data[i] == '\n') lines++;
+    }
+
+    return lines;
+}
+
+char *buffer_substring(buffer_t *buffer, size_t start, size_t end) {
+    if (!buffer || start > end || end > buffer->len) return NULL;
+
+    size_t len = end - start;
+    char *copy = malloc(len + 1);
+    if (!copy) return NULL;
+
+    memcpy(copy, buffer->data + start, len);
+    copy[len] = '\0';
+    return copy;
+}
+
+char *buffer_current_line_copy(buffer_t *buffer) {
+    if (!buffer) return NULL;
+    return buffer_substring(buffer,
+                            buffer_current_line_start(buffer),
+                            buffer_current_line_end(buffer));
+}
+
+int buffer_load_file(buffer_t *buffer, const char *path) {
+    if (buffer_require_editable(buffer) != ECEX_OK || !path) return ECEX_ERR;
+
+    size_t size = 0;
+    char *new_data = ecex_read_entire_file(path, &size);
+    if (!new_data) return ECEX_ERR;
+
+    char *new_path = ecex_strdup(path);
+    if (!new_path) {
+        free(new_data);
+        return ECEX_ERR;
+    }
+
+    free(buffer->data);
+    free(buffer->path);
+
+    buffer->data = new_data;
+    buffer->path = new_path;
+    buffer->len = size;
+    buffer->cap = size + 1;
+    buffer->point = 0;
+    buffer->mark = 0;
+    buffer->mark_active = 0;
+    buffer->scroll_line = 0;
+    buffer->scroll_col = 0;
+    buffer->modified = 0;
+    buffer_clear_undo(buffer);
+    return ECEX_OK;
+}
+
+int buffer_save(buffer_t *buffer) {
+    if (!buffer || buffer->read_only || !buffer->path) return ECEX_ERR;
+
+    FILE *file = fopen(buffer->path, "wb");
+    if (!file) return ECEX_ERR;
+
+    size_t written = fwrite(buffer->data, 1, buffer->len, file);
+    int close_result = fclose(file);
+
+    if (close_result != 0 || written != buffer->len) return ECEX_ERR;
+
+    buffer->modified = 0;
+    return ECEX_OK;
+}
+
+int buffer_save_as(buffer_t *buffer, const char *path) {
+    if (buffer_require_editable(buffer) != ECEX_OK || !path) return ECEX_ERR;
+
+    char *new_path = ecex_strdup(path);
+    if (!new_path) return ECEX_ERR;
+
+    free(buffer->path);
+    buffer->path = new_path;
+    return buffer_save(buffer);
+}
+
+
+
+int buffer_undo(buffer_t *buffer) {
+    if (buffer_require_editable(buffer) != ECEX_OK) return ECEX_ERR;
+    if (buffer->undo_count == 0) return ECEX_OK;
+    if (buffer_push_snapshot_to(&buffer->redo_stack, &buffer->redo_count, &buffer->redo_cap, buffer) != ECEX_OK) return ECEX_ERR;
+    ecex_undo_entry_t entry = buffer->undo_stack[--buffer->undo_count];
+    int result = buffer_restore_snapshot(buffer, &entry);
+    buffer_undo_entry_free(&entry);
+    return result;
+}
+
+int buffer_redo(buffer_t *buffer) {
+    if (buffer_require_editable(buffer) != ECEX_OK) return ECEX_ERR;
+    if (buffer->redo_count == 0) return ECEX_OK;
+    if (buffer_push_snapshot_to(&buffer->undo_stack, &buffer->undo_count, &buffer->undo_cap, buffer) != ECEX_OK) return ECEX_ERR;
+    ecex_undo_entry_t entry = buffer->redo_stack[--buffer->redo_count];
+    int result = buffer_restore_snapshot(buffer, &entry);
+    buffer_undo_entry_free(&entry);
+    return result;
+}
+
+void buffer_clear_undo(buffer_t *buffer) {
+    if (!buffer) return;
+    buffer_undo_stack_clear(buffer->undo_stack, buffer->undo_count);
+    buffer_undo_stack_clear(buffer->redo_stack, buffer->redo_count);
+    buffer->undo_count = 0;
+    buffer->redo_count = 0;
+}
+
+int buffer_search_forward(buffer_t *buffer, const char *query, size_t start, size_t *out_pos) {
+    if (!buffer || !query || !query[0]) return ECEX_ERR;
+    if (start > buffer->len) start = buffer->len;
+    char *hit = strstr(buffer->data + start, query);
+    if (!hit && start > 0) hit = strstr(buffer->data, query);
+    if (!hit) return ECEX_ERR;
+    if (out_pos) *out_pos = (size_t)(hit - buffer->data);
+    return ECEX_OK;
+}
+
+int buffer_search_backward(buffer_t *buffer, const char *query, size_t start, size_t *out_pos) {
+    if (!buffer || !query || !query[0]) return ECEX_ERR;
+    size_t qlen = strlen(query);
+    if (qlen > buffer->len) return ECEX_ERR;
+    if (start > buffer->len) start = buffer->len;
+    size_t best = (size_t)-1;
+    for (size_t i = 0; i + qlen <= start; i++) {
+        if (memcmp(buffer->data + i, query, qlen) == 0) best = i;
+    }
+    if (best == (size_t)-1) {
+        for (size_t i = start; i + qlen <= buffer->len; i++) {
+            if (memcmp(buffer->data + i, query, qlen) == 0) best = i;
+        }
+    }
+    if (best == (size_t)-1) return ECEX_ERR;
+    if (out_pos) *out_pos = best;
+    return ECEX_OK;
+}
+
+void buffer_set_interactive(buffer_t *buffer, int interactive) {
+    if (!buffer) return;
+    buffer->interactive = interactive ? 1 : 0;
+}
+
+int buffer_is_interactive(buffer_t *buffer) {
+    return buffer && buffer->interactive;
+}
+
+int buffer_clear_interactive_actions(buffer_t *buffer) {
+    if (!buffer) return ECEX_ERR;
+
+    for (size_t i = 0; i < buffer->interactive_action_count; i++) {
+        free(buffer->interactive_actions[i].payload);
+        buffer->interactive_actions[i].payload = NULL;
+        buffer->interactive_actions[i].fn = NULL;
+        buffer->interactive_actions[i].userdata = NULL;
+        buffer->interactive_actions[i].line = 0;
+    }
+
+    buffer->interactive_action_count = 0;
+    return ECEX_OK;
+}
+
+int buffer_add_interactive_action(buffer_t *buffer,
+                                  size_t line,
+                                  ecex_interactive_line_fn fn,
+                                  const char *payload,
+                                  void *userdata) {
+    if (!buffer || !fn) return ECEX_ERR;
+
+    if (ECEX_GROW_ARRAY(buffer->interactive_actions,
+                        buffer->interactive_action_count,
+                        buffer->interactive_action_cap,
+                        16) != ECEX_OK) {
+        return ECEX_ERR;
+    }
+
+    char *payload_copy = ecex_strdup(payload);
+    if (payload && !payload_copy) return ECEX_ERR;
+
+    ecex_interactive_line_action_t *action =
+        &buffer->interactive_actions[buffer->interactive_action_count++];
+
+    action->line = line;
+    action->fn = fn;
+    action->payload = payload_copy;
+    action->userdata = userdata;
+
+    buffer->interactive = 1;
+    return ECEX_OK;
+}
+
+ecex_interactive_line_action_t *buffer_interactive_action_at_line(buffer_t *buffer,
+                                                                  size_t line) {
+    if (!buffer || !buffer->interactive) return NULL;
+
+    for (size_t i = 0; i < buffer->interactive_action_count; i++) {
+        if (buffer->interactive_actions[i].line == line) {
+            return &buffer->interactive_actions[i];
+        }
+    }
+
+    return NULL;
+}
diff --git a/src/config.c b/src/config.c
new file mode 100644
index 0000000..b416d7a
--- /dev/null
+++ b/src/config.c
@@ -0,0 +1,293 @@
+#include "config.h"
+
+#include "buffers.h"
+#include "ccdjit.h"
+#include "common.h"
+#include "ecex.h"
+#include "eval.h"
+#include "util.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+typedef int (*ecex_config_init_fn)(ecex_t *ed);
+
+typedef struct host_symbol {
+    const char *name;
+    void *addr;
+} host_symbol_t;
+
+void ecex_print_ccdjit_error(ccdjit_context *ctx) {
+    const ccdjit_diagnostic *diag = ccdjit_context_last_error(ctx);
+
+    if (!diag) {
+        fprintf(stderr, "ccdjit: unknown error\n");
+        return;
+    }
+
+    fprintf(stderr,
+            "ccdjit error [%s] %s:%d:%d: %s\n",
+            diag->phase ? diag->phase : "?",
+            diag->filename ? diag->filename : "<input>",
+            diag->line,
+            diag->column,
+            diag->message ? diag->message : "(no message)");
+
+    if (diag->source_line) fprintf(stderr, "%s\n", diag->source_line);
+    if (diag->caret_line) fprintf(stderr, "%s\n", diag->caret_line);
+}
+
+#define HOST_SYMBOL(fn) { #fn, (void *)(fn) }
+
+static const host_symbol_t host_symbols[] = {
+    HOST_SYMBOL(ecex_current_buffer),
+    HOST_SYMBOL(ecex_create_buffer),
+    HOST_SYMBOL(ecex_find_buffer),
+    HOST_SYMBOL(ecex_switch_buffer),
+    HOST_SYMBOL(ecex_next_buffer),
+    HOST_SYMBOL(ecex_previous_buffer),
+    HOST_SYMBOL(ecex_current_window),
+    HOST_SYMBOL(ecex_window_count),
+    HOST_SYMBOL(ecex_split_window_vertically),
+    HOST_SYMBOL(ecex_split_window_horizontally),
+    HOST_SYMBOL(ecex_other_window),
+    HOST_SYMBOL(ecex_previous_window),
+    HOST_SYMBOL(ecex_delete_window),
+    HOST_SYMBOL(ecex_delete_other_windows),
+    HOST_SYMBOL(ecex_kill_buffer),
+
+    HOST_SYMBOL(ecex_register_command),
+    HOST_SYMBOL(ecex_execute_command),
+    HOST_SYMBOL(ecex_bind_key),
+    HOST_SYMBOL(ecex_lookup_key),
+    HOST_SYMBOL(ecex_define_major_mode),
+    HOST_SYMBOL(ecex_major_mode_by_name),
+    HOST_SYMBOL(ecex_major_mode_name),
+    HOST_SYMBOL(ecex_buffer_set_major_mode),
+    HOST_SYMBOL(ecex_buffer_set_major_mode_by_name),
+    HOST_SYMBOL(ecex_buffer_major_mode_name),
+    HOST_SYMBOL(ecex_bind_mode_key),
+    HOST_SYMBOL(ecex_lookup_key_for_buffer),
+    HOST_SYMBOL(ecex_key_sequence_has_prefix_for_buffer),
+    HOST_SYMBOL(ecex_auto_set_major_mode),
+    HOST_SYMBOL(ecex_list_commands),
+    HOST_SYMBOL(ecex_list_buffers),
+    HOST_SYMBOL(ecex_create_interactive_buffer),
+    HOST_SYMBOL(ecex_interactive_append_line),
+    HOST_SYMBOL(ecex_interactive_activate_current_line),
+    HOST_SYMBOL(ecex_find_file),
+    HOST_SYMBOL(ecex_save_current_buffer),
+    HOST_SYMBOL(ecex_write_current_buffer),
+    HOST_SYMBOL(ecex_request_prompt),
+    HOST_SYMBOL(ecex_clear_prompt_request),
+    HOST_SYMBOL(ecex_complete_command),
+    HOST_SYMBOL(ecex_eval_source),
+    HOST_SYMBOL(ecex_eval_current_buffer),
+    HOST_SYMBOL(ecex_eval_current_line),
+    HOST_SYMBOL(ecex_eval_current_region),
+    HOST_SYMBOL(ecex_eval_file),
+    HOST_SYMBOL(ecex_eval_rerun_last),
+
+    HOST_SYMBOL(ecex_set_font),
+    HOST_SYMBOL(ecex_get_font_size),
+    HOST_SYMBOL(ecex_set_font_size),
+    HOST_SYMBOL(ecex_adjust_font_size),
+    HOST_SYMBOL(ecex_set_bg_color),
+    HOST_SYMBOL(ecex_set_fg_color),
+    HOST_SYMBOL(ecex_set_status_bg_color),
+    HOST_SYMBOL(ecex_set_status_fg_color),
+    HOST_SYMBOL(ecex_set_status_border_color),
+    HOST_SYMBOL(ecex_set_cursor_color),
+    HOST_SYMBOL(ecex_set_region_bg_color),
+    HOST_SYMBOL(ecex_set_minibuffer_bg_color),
+    HOST_SYMBOL(ecex_set_minibuffer_fg_color),
+    HOST_SYMBOL(ecex_set_completion_fg_color),
+    HOST_SYMBOL(ecex_set_completion_enabled),
+    HOST_SYMBOL(ecex_set_interactive_highlight_bg_color),
+    HOST_SYMBOL(ecex_set_interactive_highlight_fg_color),
+
+    HOST_SYMBOL(buffer_clear),
+    HOST_SYMBOL(buffer_set_text),
+    HOST_SYMBOL(buffer_insert),
+    HOST_SYMBOL(buffer_insert_at),
+    HOST_SYMBOL(buffer_append),
+    HOST_SYMBOL(buffer_prepend),
+    HOST_SYMBOL(buffer_insert_char),
+    HOST_SYMBOL(buffer_insert_char_at),
+    HOST_SYMBOL(buffer_delete_range),
+    HOST_SYMBOL(buffer_delete_selection),
+    HOST_SYMBOL(buffer_replace_selection),
+    HOST_SYMBOL(buffer_backspace),
+    HOST_SYMBOL(buffer_delete_forward),
+    HOST_SYMBOL(buffer_kill_line),
+
+    HOST_SYMBOL(buffer_set_point),
+    HOST_SYMBOL(buffer_move_left),
+    HOST_SYMBOL(buffer_move_right),
+    HOST_SYMBOL(buffer_move_up),
+    HOST_SYMBOL(buffer_move_down),
+    HOST_SYMBOL(buffer_move_word_left),
+    HOST_SYMBOL(buffer_move_word_right),
+    HOST_SYMBOL(buffer_move_beginning_of_line),
+    HOST_SYMBOL(buffer_move_end_of_line),
+    HOST_SYMBOL(buffer_move_beginning_of_buffer),
+    HOST_SYMBOL(buffer_move_end_of_buffer),
+
+    HOST_SYMBOL(buffer_set_mark),
+    HOST_SYMBOL(buffer_clear_mark),
+    HOST_SYMBOL(buffer_has_selection),
+    HOST_SYMBOL(buffer_selection_range),
+
+    HOST_SYMBOL(buffer_line_start_at),
+    HOST_SYMBOL(buffer_line_end_at),
+    HOST_SYMBOL(buffer_current_line_start),
+    HOST_SYMBOL(buffer_current_line_end),
+    HOST_SYMBOL(buffer_current_column),
+    HOST_SYMBOL(buffer_current_line_number),
+    HOST_SYMBOL(buffer_line_count),
+    HOST_SYMBOL(buffer_substring),
+    HOST_SYMBOL(buffer_current_line_copy),
+
+    HOST_SYMBOL(buffer_load_file),
+    HOST_SYMBOL(buffer_save),
+    HOST_SYMBOL(buffer_save_as),
+    HOST_SYMBOL(buffer_set_interactive),
+    HOST_SYMBOL(buffer_is_interactive),
+    HOST_SYMBOL(buffer_clear_interactive_actions),
+    HOST_SYMBOL(buffer_add_interactive_action),
+    HOST_SYMBOL(buffer_interactive_action_at_line),
+};
+
+#undef HOST_SYMBOL
+
+int ecex_register_host_symbols(ccdjit_context *ctx) {
+    for (size_t i = 0; i < ECEX_ARRAY_LEN(host_symbols); i++) {
+        if (ccdjit_context_register_symbol(ctx,
+                                           host_symbols[i].name,
+                                           host_symbols[i].addr) != 0) {
+            fprintf(stderr, "ecex: failed to register symbol: %s\n", host_symbols[i].name);
+            ecex_print_ccdjit_error(ctx);
+            return ECEX_ERR;
+        }
+    }
+
+    return ECEX_OK;
+}
+
+static int add_include_path(ccdjit_context *ctx, const char *path) {
+    if (ccdjit_context_add_include_path(ctx, path) == 0) return ECEX_OK;
+
+    fprintf(stderr, "ecex: failed to add include path: %s\n", path);
+    ecex_print_ccdjit_error(ctx);
+    return ECEX_ERR;
+}
+
+int ecex_add_ccdjit_include_paths(ccdjit_context *ctx) {
+    if (add_include_path(ctx, "include") != ECEX_OK) return ECEX_ERR;
+    if (add_include_path(ctx, "../include") != ECEX_OK) return ECEX_ERR;
+
+    const char *env_include = getenv("ECEX_INCLUDE");
+    if (env_include && env_include[0]) {
+        if (add_include_path(ctx, env_include) != ECEX_OK) return ECEX_ERR;
+    }
+
+    return ECEX_OK;
+}
+
+static char *make_config_source_with_forced_main(const char *path) {
+    size_t source_size = 0;
+    char *source = ecex_read_entire_file(path, &source_size);
+    if (!source) return NULL;
+
+    const char *forced_main =
+        "\n"
+        "\n"
+        "int main(int argc, char **argv) {\n"
+        "    (void)argc;\n"
+        "    (void)argv;\n"
+        "    return ecex_config_init((ecex_t *)0);\n"
+        "}\n";
+
+    size_t forced_main_len = strlen(forced_main);
+    char *combined = malloc(source_size + forced_main_len + 1);
+    if (!combined) {
+        free(source);
+        return NULL;
+    }
+
+    memcpy(combined, source, source_size);
+    memcpy(combined + source_size, forced_main, forced_main_len + 1);
+
+    free(source);
+    return combined;
+}
+
+int ecex_load_c_config(ecex_t *ed, const char *path) {
+    if (!ed || !path) return ECEX_ERR;
+
+    ccdjit_context *ctx = ccdjit_context_new(NULL);
+    if (!ctx) {
+        fprintf(stderr, "ecex: failed to create ccdjit context\n");
+        return ECEX_ERR;
+    }
+
+    if (ecex_add_ccdjit_include_paths(ctx) != ECEX_OK || ecex_register_host_symbols(ctx) != ECEX_OK) {
+        ccdjit_context_free(ctx);
+        return ECEX_ERR;
+    }
+
+    char *source = make_config_source_with_forced_main(path);
+    if (!source) {
+        fprintf(stderr, "ecex: failed to read or prepare config: %s\n", path);
+        ccdjit_context_free(ctx);
+        return ECEX_ERR;
+    }
+
+    ccdjit_module *module = NULL;
+    if (ccdjit_compile_string(ctx, source, path, &module) != 0) {
+        fprintf(stderr, "ecex: failed to compile config: %s\n", path);
+        ecex_print_ccdjit_error(ctx);
+        free(source);
+        ccdjit_context_free(ctx);
+        return ECEX_ERR;
+    }
+
+    free(source);
+
+    ecex_config_init_fn init =
+        (ecex_config_init_fn)ccdjit_module_symbol(module, "ecex_config_init");
+
+    if (!init) {
+        fprintf(stderr, "ecex: config missing function: ecex_config_init\n");
+        ecex_print_ccdjit_error(ctx);
+        ccdjit_module_free(module);
+        ccdjit_context_free(ctx);
+        return ECEX_ERR;
+    }
+
+    int result = init(ed);
+    if (result != 0) {
+        fprintf(stderr, "ecex: config init failed with code: %d\n", result);
+        ccdjit_module_free(module);
+        ccdjit_context_free(ctx);
+        return ECEX_ERR;
+    }
+
+    if (ecex_keep_jit_module(ed, module) != ECEX_OK) {
+        fprintf(stderr, "ecex: failed to retain config module\n");
+        ccdjit_module_free(module);
+        ccdjit_context_free(ctx);
+        return ECEX_ERR;
+    }
+
+    if (ecex_set_config_path(ed, path) != ECEX_OK) {
+        fprintf(stderr, "ecex: failed to remember config path: %s\n", path);
+        ccdjit_context_free(ctx);
+        return ECEX_ERR;
+    }
+
+    ccdjit_context_free(ctx);
+    fprintf(stderr, "ecex: loaded config: %s\n", path);
+    return ECEX_OK;
+}
diff --git a/src/ecex.c b/src/ecex.c
new file mode 100644
index 0000000..2f4c962
--- /dev/null
+++ b/src/ecex.c
@@ -0,0 +1,1630 @@
+#include "ecex.h"
+
+#include "ccdjit.h"
+#include "common.h"
+#include "config.h"
+#include "util.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+extern FILE *popen(const char *command, const char *type);
+extern int pclose(FILE *stream);
+
+#define ECEX_INITIAL_BUFFER_CAP 8
+#define ECEX_INITIAL_COMMAND_CAP 32
+#define ECEX_INITIAL_KEYBIND_CAP 32
+#define ECEX_INITIAL_WINDOW_CAP 4
+#define ECEX_INITIAL_MODE_CAP 8
+#define ECEX_INITIAL_MODE_KEYBIND_CAP 16
+
+ecex_window_t *ecex_current_window(ecex_t *ed);
+
+static ecex_color_t ecex_color(float r, float g, float b) {
+    ecex_color_t c = {r, g, b};
+    return c;
+}
+
+static void ecex_theme_set_defaults(ecex_t *ed) {
+    if (!ed) return;
+
+    ed->theme.font_path = NULL;
+    ed->theme.font_size = 22.0f;
+
+    ed->theme.bg = ecex_color(0.08f, 0.09f, 0.11f);
+    ed->theme.fg = ecex_color(0.88f, 0.88f, 0.86f);
+
+    ed->theme.status_bg = ecex_color(0.15f, 0.15f, 0.18f);
+    ed->theme.status_fg = ecex_color(0.86f, 0.86f, 0.84f);
+    ed->theme.status_border = ecex_color(0.28f, 0.28f, 0.32f);
+
+    ed->theme.cursor = ecex_color(1.0f, 1.0f, 1.0f);
+    ed->theme.region_bg = ecex_color(0.22f, 0.34f, 0.48f);
+
+    ed->theme.minibuffer_bg = ecex_color(0.10f, 0.11f, 0.14f);
+    ed->theme.minibuffer_fg = ecex_color(0.95f, 0.95f, 0.90f);
+
+    ed->theme.completion_fg = ecex_color(0.45f, 0.45f, 0.45f);
+    ed->theme.completion_enabled = 1;
+
+    ed->theme.interactive_highlight_bg = ecex_color(0.18f, 0.20f, 0.24f);
+    ed->theme.interactive_highlight_fg = ecex_color(1.0f, 1.0f, 1.0f);
+    ed->theme.current_line_bg = ecex_color(0.12f, 0.13f, 0.16f);
+    ed->theme.search_bg = ecex_color(0.55f, 0.42f, 0.12f);
+    ed->theme.line_numbers_enabled = 1;
+    ed->theme.current_line_enabled = 1;
+}
+
+#define ECEX_COMMAND(name, fn) \
+    do { \
+        if (ecex_register_command(ed, (name), (fn)) != ECEX_OK) return ECEX_ERR; \
+    } while (0)
+
+#define ECEX_BIND(key, command) \
+    do { \
+        if (ecex_bind_key(ed, (key), (command)) != ECEX_OK) return ECEX_ERR; \
+    } while (0)
+
+#define CURRENT_BUFFER_OR_ERR(ed) \
+    buffer_t *buf = ecex_current_buffer(ed); \
+    if (!buf) return ECEX_ERR
+
+static int cmd_quit(ecex_t *ed) {
+    if (!ed) return ECEX_ERR;
+    ed->should_quit = 1;
+    return ECEX_OK;
+}
+
+static int cmd_next_buffer(ecex_t *ed) { return ecex_next_buffer(ed); }
+static int cmd_previous_buffer(ecex_t *ed) { return ecex_previous_buffer(ed); }
+static int cmd_split_window_right(ecex_t *ed) { return ecex_split_window_vertically(ed); }
+static int cmd_split_window_below(ecex_t *ed) { return ecex_split_window_horizontally(ed); }
+static int cmd_other_window(ecex_t *ed) { return ecex_other_window(ed); }
+static int cmd_previous_window(ecex_t *ed) { return ecex_previous_window(ed); }
+static int cmd_delete_window(ecex_t *ed) { return ecex_delete_window(ed); }
+static int cmd_delete_other_windows(ecex_t *ed) { return ecex_delete_other_windows(ed); }
+static int cmd_balance_windows(ecex_t *ed) { return ecex_balance_windows(ed); }
+
+static int cmd_move_left(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); buffer_move_left(buf); return ECEX_OK; }
+static int cmd_move_right(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); buffer_move_right(buf); return ECEX_OK; }
+static int cmd_move_up(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); buffer_move_up(buf); return ECEX_OK; }
+static int cmd_move_down(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); buffer_move_down(buf); return ECEX_OK; }
+static int cmd_move_word_left(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); buffer_move_word_left(buf); return ECEX_OK; }
+static int cmd_move_word_right(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); buffer_move_word_right(buf); return ECEX_OK; }
+static int cmd_beginning_of_line(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); buffer_move_beginning_of_line(buf); return ECEX_OK; }
+static int cmd_end_of_line(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); buffer_move_end_of_line(buf); return ECEX_OK; }
+static int cmd_beginning_of_buffer(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); buffer_move_beginning_of_buffer(buf); return ECEX_OK; }
+static int cmd_end_of_buffer(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); buffer_move_end_of_buffer(buf); return ECEX_OK; }
+
+static int cmd_undo(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); return buffer_undo(buf); }
+static int cmd_redo(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); return buffer_redo(buf); }
+static int cmd_backspace(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); return buffer_backspace(buf); }
+static int cmd_delete_forward(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); return buffer_delete_forward(buf); }
+static int cmd_newline(ecex_t *ed) {
+    CURRENT_BUFFER_OR_ERR(ed);
+    if (buffer_is_interactive(buf)) {
+        return ecex_interactive_activate_current_line(ed);
+    }
+    return buffer_insert_char(buf, '\n');
+}
+static int cmd_kill_line(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); return buffer_kill_line(buf); }
+static int cmd_clear_buffer(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); return buffer_clear(buf); }
+static int cmd_set_mark(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); buffer_set_mark(buf, buf->point); return ECEX_OK; }
+static int cmd_clear_mark(ecex_t *ed) { CURRENT_BUFFER_OR_ERR(ed); buffer_clear_mark(buf); return ECEX_OK; }
+
+
+static int cmd_yank(ecex_t *ed) {
+    CURRENT_BUFFER_OR_ERR(ed);
+    const char *text = ecex_clipboard_get(ed);
+    if (!text || !text[0]) return ECEX_OK;
+    return buffer_replace_selection(buf, text);
+}
+
+static int cmd_copy_region(ecex_t *ed) {
+    CURRENT_BUFFER_OR_ERR(ed);
+    if (!buffer_has_selection(buf)) return ECEX_OK;
+
+    size_t start = 0;
+    size_t end = 0;
+    buffer_selection_range(buf, &start, &end);
+
+    char *text = buffer_substring(buf, start, end);
+    if (!text) return ECEX_ERR;
+
+    int result = ecex_clipboard_set(ed, text);
+    free(text);
+    return result;
+}
+
+static int cmd_kill_region(ecex_t *ed) {
+    CURRENT_BUFFER_OR_ERR(ed);
+    if (!buffer_has_selection(buf)) return ECEX_OK;
+
+    size_t start = 0;
+    size_t end = 0;
+    buffer_selection_range(buf, &start, &end);
+
+    char *text = buffer_substring(buf, start, end);
+    if (!text) return ECEX_ERR;
+
+    int result = ecex_clipboard_set(ed, text);
+    free(text);
+    if (result != ECEX_OK) return result;
+
+    return buffer_delete_selection(buf);
+}
+
+static int cmd_list_commands(ecex_t *ed) { return ecex_list_commands(ed); }
+static int cmd_list_buffers(ecex_t *ed) { return ecex_list_buffers(ed); }
+static int cmd_switch_buffer(ecex_t *ed) { ecex_request_prompt(ed, ECEX_PROMPT_SWITCH_BUFFER, "Switch buffer: "); return ECEX_OK; }
+static int cmd_kill_buffer_command(ecex_t *ed) { ecex_request_prompt(ed, ECEX_PROMPT_KILL_BUFFER, "Kill buffer: "); return ECEX_OK; }
+static int cmd_compile(ecex_t *ed) { ecex_request_prompt(ed, ECEX_PROMPT_COMPILE, "Compile: "); return ECEX_OK; }
+static int cmd_grep(ecex_t *ed) { ecex_request_prompt(ed, ECEX_PROMPT_GREP, "Grep: "); return ECEX_OK; }
+static int cmd_recompile(ecex_t *ed) { return ecex_rerun_compile(ed); }
+static int cmd_regrep(ecex_t *ed) { return ecex_rerun_grep(ed); }
+static int cmd_next_error(ecex_t *ed) { return ecex_next_interactive_action(ed); }
+static int cmd_previous_error(ecex_t *ed) { return ecex_previous_interactive_action(ed); }
+static int cmd_comment_region(ecex_t *ed) { return ecex_comment_region(ed); }
+static int cmd_uncomment_region(ecex_t *ed) { return ecex_uncomment_region(ed); }
+static int cmd_toggle_line_numbers(ecex_t *ed) { if (!ed) return ECEX_ERR; ed->theme.line_numbers_enabled = !ed->theme.line_numbers_enabled; return ECEX_OK; }
+static int cmd_toggle_current_line(ecex_t *ed) { if (!ed) return ECEX_ERR; ed->theme.current_line_enabled = !ed->theme.current_line_enabled; return ECEX_OK; }
+static int cmd_isearch_forward(ecex_t *ed) { ecex_request_prompt(ed, ECEX_PROMPT_ISEARCH_FORWARD, "I-search: "); return ECEX_OK; }
+static int cmd_isearch_backward(ecex_t *ed) { ecex_request_prompt(ed, ECEX_PROMPT_ISEARCH_BACKWARD, "I-search backward: "); return ECEX_OK; }
+
+static int cmd_find_file(ecex_t *ed) {
+    ecex_request_prompt(ed, ECEX_PROMPT_FIND_FILE, "Find file: ");
+    return ECEX_OK;
+}
+
+static int cmd_write_file(ecex_t *ed) {
+    ecex_request_prompt(ed, ECEX_PROMPT_WRITE_FILE, "Write file: ");
+    return ECEX_OK;
+}
+
+static int cmd_save_buffer(ecex_t *ed) {
+    if (!ed) return ECEX_ERR;
+
+    buffer_t *buf = ecex_current_buffer(ed);
+    if (!buf) return ECEX_ERR;
+
+    if (!buf->path) {
+        ecex_request_prompt(ed, ECEX_PROMPT_WRITE_FILE, "Write file: ");
+        return ECEX_OK;
+    }
+
+    return ecex_save_current_buffer(ed);
+}
+
+static int cmd_eval_buffer(ecex_t *ed) {
+    return ecex_eval_current_buffer(ed);
+}
+
+static int cmd_eval_line(ecex_t *ed) {
+    return ecex_eval_current_line(ed);
+}
+
+static int cmd_eval_region(ecex_t *ed) {
+    return ecex_eval_current_region(ed);
+}
+
+static int cmd_eval_file(ecex_t *ed) {
+    ecex_request_prompt(ed, ECEX_PROMPT_EVAL_FILE, "Eval file: ");
+    return ECEX_OK;
+}
+
+static int cmd_eval_rerun_last(ecex_t *ed) {
+    return ecex_eval_rerun_last(ed);
+}
+
+static int cmd_quit_window(ecex_t *ed) {
+    if (!ed) return ECEX_ERR;
+    if (ecex_window_count(ed) > 1) return ecex_delete_window(ed);
+    return ecex_previous_buffer(ed);
+}
+
+static int cmd_reload_config(ecex_t *ed) {
+    return ecex_reload_config(ed);
+}
+
+static int ecex_register_builtins(ecex_t *ed) {
+    ECEX_COMMAND("quit", cmd_quit);
+    ECEX_COMMAND("find-file", cmd_find_file);
+    ECEX_COMMAND("save-buffer", cmd_save_buffer);
+    ECEX_COMMAND("write-file", cmd_write_file);
+    ECEX_COMMAND("eval-buffer", cmd_eval_buffer);
+    ECEX_COMMAND("eval-line", cmd_eval_line);
+    ECEX_COMMAND("eval-region", cmd_eval_region);
+    ECEX_COMMAND("eval-selection", cmd_eval_region);
+    ECEX_COMMAND("eval-file", cmd_eval_file);
+    ECEX_COMMAND("eval-rerun-last", cmd_eval_rerun_last);
+    ECEX_COMMAND("revert-eval-buffer", cmd_eval_rerun_last);
+    ECEX_COMMAND("quit-window", cmd_quit_window);
+    ECEX_COMMAND("reload-config", cmd_reload_config);
+    ECEX_COMMAND("list-commands", cmd_list_commands);
+    ECEX_COMMAND("list-buffers", cmd_list_buffers);
+    ECEX_COMMAND("switch-buffer", cmd_switch_buffer);
+    ECEX_COMMAND("kill-buffer", cmd_kill_buffer_command);
+    ECEX_COMMAND("compile", cmd_compile);
+    ECEX_COMMAND("recompile", cmd_recompile);
+    ECEX_COMMAND("grep", cmd_grep);
+    ECEX_COMMAND("regrep", cmd_regrep);
+    ECEX_COMMAND("next-error", cmd_next_error);
+    ECEX_COMMAND("previous-error", cmd_previous_error);
+    ECEX_COMMAND("comment-region", cmd_comment_region);
+    ECEX_COMMAND("uncomment-region", cmd_uncomment_region);
+    ECEX_COMMAND("toggle-line-numbers", cmd_toggle_line_numbers);
+    ECEX_COMMAND("toggle-current-line", cmd_toggle_current_line);
+    ECEX_COMMAND("isearch-forward", cmd_isearch_forward);
+    ECEX_COMMAND("isearch-backward", cmd_isearch_backward);
+
+    ECEX_COMMAND("next-buffer", cmd_next_buffer);
+    ECEX_COMMAND("previous-buffer", cmd_previous_buffer);
+    ECEX_COMMAND("split-window-right", cmd_split_window_right);
+    ECEX_COMMAND("split-window-vertically", cmd_split_window_right);
+    ECEX_COMMAND("split-window-below", cmd_split_window_below);
+    ECEX_COMMAND("split-window-horizontally", cmd_split_window_below);
+    ECEX_COMMAND("other-window", cmd_other_window);
+    ECEX_COMMAND("previous-window", cmd_previous_window);
+    ECEX_COMMAND("delete-window", cmd_delete_window);
+    ECEX_COMMAND("delete-other-windows", cmd_delete_other_windows);
+    ECEX_COMMAND("balance-windows", cmd_balance_windows);
+
+    ECEX_COMMAND("move-left", cmd_move_left);
+    ECEX_COMMAND("move-right", cmd_move_right);
+    ECEX_COMMAND("move-up", cmd_move_up);
+    ECEX_COMMAND("move-down", cmd_move_down);
+    ECEX_COMMAND("move-word-left", cmd_move_word_left);
+    ECEX_COMMAND("move-word-right", cmd_move_word_right);
+    ECEX_COMMAND("beginning-of-line", cmd_beginning_of_line);
+    ECEX_COMMAND("end-of-line", cmd_end_of_line);
+    ECEX_COMMAND("beginning-of-buffer", cmd_beginning_of_buffer);
+    ECEX_COMMAND("end-of-buffer", cmd_end_of_buffer);
+
+    ECEX_COMMAND("undo", cmd_undo);
+    ECEX_COMMAND("redo", cmd_redo);
+    ECEX_COMMAND("backspace", cmd_backspace);
+    ECEX_COMMAND("delete-forward", cmd_delete_forward);
+    ECEX_COMMAND("newline", cmd_newline);
+    ECEX_COMMAND("kill-line", cmd_kill_line);
+    ECEX_COMMAND("clear-buffer", cmd_clear_buffer);
+    ECEX_COMMAND("set-mark", cmd_set_mark);
+    ECEX_COMMAND("clear-mark", cmd_clear_mark);
+    ECEX_COMMAND("yank", cmd_yank);
+    ECEX_COMMAND("paste", cmd_yank);
+    ECEX_COMMAND("copy-region", cmd_copy_region);
+    ECEX_COMMAND("copy-region-as-kill", cmd_copy_region);
+    ECEX_COMMAND("kill-region", cmd_kill_region);
+
+    ECEX_BIND("LEFT", "move-left");
+    ECEX_BIND("RIGHT", "move-right");
+    ECEX_BIND("UP", "move-up");
+    ECEX_BIND("DOWN", "move-down");
+
+    ECEX_BIND("C-b", "move-left");
+    ECEX_BIND("C-f", "move-right");
+    ECEX_BIND("C-p", "move-up");
+    ECEX_BIND("C-n", "move-down");
+    ECEX_BIND("C-a", "beginning-of-line");
+    ECEX_BIND("C-e", "end-of-line");
+    ECEX_BIND("C-k", "kill-line");
+    ECEX_BIND("C-SPC", "set-mark");
+    ECEX_BIND("C-y", "yank");
+    ECEX_BIND("C-v", "paste");
+    ECEX_BIND("M-w", "copy-region-as-kill");
+    ECEX_BIND("C-w", "kill-region");
+    ECEX_BIND("C-s", "isearch-forward");
+    ECEX_BIND("C-r", "isearch-backward");
+    ECEX_BIND("C-/", "undo");
+    ECEX_BIND("C-z", "undo");
+    ECEX_BIND("C-S-z", "redo");
+
+    ECEX_BIND("C-x C-f", "find-file");
+    ECEX_BIND("C-x C-s", "save-buffer");
+    ECEX_BIND("C-x C-w", "write-file");
+    ECEX_BIND("C-x C-b", "list-buffers");
+    ECEX_BIND("C-x b", "switch-buffer");
+    ECEX_BIND("C-x k", "kill-buffer");
+    ECEX_BIND("C-x 2", "split-window-below");
+    ECEX_BIND("C-x 3", "split-window-right");
+    ECEX_BIND("C-x o", "other-window");
+    ECEX_BIND("C-x O", "previous-window");
+    ECEX_BIND("C-x 0", "delete-window");
+    ECEX_BIND("C-x 1", "delete-other-windows");
+    ECEX_BIND("C-x +", "balance-windows");
+    ECEX_BIND("C-x e b", "eval-buffer");
+    ECEX_BIND("C-x e l", "eval-line");
+    ECEX_BIND("C-x C-e", "eval-line");
+    ECEX_BIND("C-x e r", "eval-region");
+    ECEX_BIND("C-x e f", "eval-file");
+    ECEX_BIND("C-x C-r", "reload-config");
+    ECEX_BIND("F5", "reload-config");
+    ECEX_BIND("M-g n", "next-error");
+    ECEX_BIND("M-g p", "previous-error");
+    ECEX_BIND("M-;", "comment-region");
+
+    ECEX_BIND("BACKSPACE", "backspace");
+    ECEX_BIND("DELETE", "delete-forward");
+    ECEX_BIND("ENTER", "newline");
+
+    ecex_define_major_mode(ed, "fundamental-mode");
+    ecex_define_major_mode(ed, "c-mode");
+    ecex_define_major_mode(ed, "eval-output-mode");
+    ecex_define_major_mode(ed, "special-mode");
+    ecex_bind_mode_key(ed, "eval-output-mode", "g", "eval-rerun-last");
+    ecex_bind_mode_key(ed, "eval-output-mode", "q", "quit-window");
+    ecex_bind_mode_key(ed, "eval-output-mode", "r", "eval-rerun-last");
+    ecex_bind_mode_key(ed, "special-mode", "q", "quit-window");
+    ecex_bind_mode_key(ed, "special-mode", "g", "recompile");
+    ecex_bind_mode_key(ed, "special-mode", "n", "next-error");
+    ecex_bind_mode_key(ed, "special-mode", "p", "previous-error");
+
+    return ECEX_OK;
+}
+
+#undef ECEX_COMMAND
+#undef ECEX_BIND
+#undef CURRENT_BUFFER_OR_ERR
+
+ecex_t *ecex_new(void) {
+    ecex_t *ed = calloc(1, sizeof(*ed));
+    if (!ed) return NULL;
+
+    ecex_theme_set_defaults(ed);
+
+    buffer_t *scratch = buffer_new("*scratch*", NULL, 0);
+    if (!scratch || ecex_add_buffer(ed, scratch) != ECEX_OK) {
+        buffer_free(scratch);
+        ecex_free(ed);
+        return NULL;
+    }
+
+    ed->current_buffer_index = 0;
+    ed->current_buffer = scratch;
+    ed->next_major_mode_id = 1;
+
+    ed->window_cap = ECEX_INITIAL_WINDOW_CAP;
+    ed->windows = calloc(ed->window_cap, sizeof(*ed->windows));
+    if (!ed->windows) {
+        ecex_free(ed);
+        return NULL;
+    }
+    ed->window_count = 1;
+    ed->current_window_index = 0;
+    ed->windows[0].buffer = scratch;
+    ed->windows[0].x = 0.0f;
+    ed->windows[0].y = 0.0f;
+    ed->windows[0].w = 1.0f;
+    ed->windows[0].h = 1.0f;
+
+    if (ecex_register_builtins(ed) != ECEX_OK) {
+        ecex_free(ed);
+        return NULL;
+    }
+
+    ecex_buffer_set_major_mode_by_name(ed, scratch, "fundamental-mode");
+
+    return ed;
+}
+
+void ecex_free(ecex_t *ed) {
+    if (!ed) return;
+
+    for (size_t i = 0; i < ed->jit_module_count; i++) {
+        ccdjit_module_free((ccdjit_module *)ed->jit_modules[i]);
+    }
+
+    for (size_t i = 0; i < ed->buffer_count; i++) {
+        buffer_free(ed->buffers[i]);
+    }
+
+    for (size_t i = 0; i < ed->command_count; i++) {
+        free(ed->commands[i].name);
+    }
+
+    for (size_t i = 0; i < ed->keybind_count; i++) {
+        free(ed->keybinds[i].key);
+        free(ed->keybinds[i].command);
+    }
+
+    for (size_t i = 0; i < ed->mode_keybind_count; i++) {
+        free(ed->mode_keybinds[i].key);
+        free(ed->mode_keybinds[i].command);
+    }
+
+    for (size_t i = 0; i < ed->major_mode_count; i++) {
+        free(ed->major_modes[i].name);
+    }
+
+    free(ed->jit_modules);
+    free(ed->windows);
+    free(ed->buffers);
+    free(ed->commands);
+    free(ed->keybinds);
+    free(ed->mode_keybinds);
+    free(ed->major_modes);
+    free(ed->last_eval_source);
+    free(ed->last_eval_filename);
+    free(ed->last_compile_command);
+    free(ed->last_grep_command);
+    free(ed->config_path);
+    free(ed->theme.font_path);
+    free(ed);
+}
+
+int ecex_reserve_buffers(ecex_t *ed, size_t needed) {
+    ECEX_RETURN_ERR_IF_NULL(ed);
+    if (needed <= ed->buffer_cap) return ECEX_OK;
+
+    while (ed->buffer_cap < needed) {
+        if (ECEX_GROW_ARRAY(ed->buffers,
+                            ed->buffer_count,
+                            ed->buffer_cap,
+                            ECEX_INITIAL_BUFFER_CAP) != ECEX_OK) {
+            return ECEX_ERR;
+        }
+    }
+
+    return ECEX_OK;
+}
+
+int ecex_add_buffer(ecex_t *ed, buffer_t *buffer) {
+    if (!ed || !buffer) return ECEX_ERR;
+
+    if (ecex_reserve_buffers(ed, ed->buffer_count + 1) != ECEX_OK) return ECEX_ERR;
+
+    ed->buffers[ed->buffer_count++] = buffer;
+
+    if (!ed->current_buffer) {
+        ed->current_buffer_index = 0;
+        ed->current_buffer = buffer;
+    }
+
+    return ECEX_OK;
+}
+
+buffer_t *ecex_create_buffer(ecex_t *ed,
+                             const char *name,
+                             const char *path,
+                             int read_only) {
+    if (!ed || !name) return NULL;
+
+    buffer_t *buffer = buffer_new(name, path, read_only);
+    if (!buffer) return NULL;
+
+    if (ecex_add_buffer(ed, buffer) != ECEX_OK) {
+        buffer_free(buffer);
+        return NULL;
+    }
+
+    return buffer;
+}
+
+buffer_t *ecex_find_buffer(ecex_t *ed, const char *name) {
+    if (!ed || !name) return NULL;
+
+    for (size_t i = 0; i < ed->buffer_count; i++) {
+        if (strcmp(ed->buffers[i]->name, name) == 0) {
+            return ed->buffers[i];
+        }
+    }
+
+    return NULL;
+}
+
+
+static int ecex_set_current_buffer_index(ecex_t *ed, size_t index) {
+    if (!ed || index >= ed->buffer_count) return ECEX_ERR;
+    ed->current_buffer_index = index;
+    ed->current_buffer = ed->buffers[index];
+    ecex_window_t *win = ecex_current_window(ed);
+    if (win) win->buffer = ed->current_buffer;
+    return ECEX_OK;
+}
+
+int ecex_sync_current_buffer(ecex_t *ed) {
+    if (!ed) return ECEX_ERR;
+    ecex_window_t *win = ecex_current_window(ed);
+    if (!win || !win->buffer) return ECEX_ERR;
+
+    ed->current_buffer = win->buffer;
+    for (size_t i = 0; i < ed->buffer_count; i++) {
+        if (ed->buffers[i] == win->buffer) {
+            ed->current_buffer_index = i;
+            return ECEX_OK;
+        }
+    }
+    return ECEX_ERR;
+}
+
+int ecex_switch_buffer(ecex_t *ed, const char *name) {
+    if (!ed || !name) return ECEX_ERR;
+
+    for (size_t i = 0; i < ed->buffer_count; i++) {
+        if (strcmp(ed->buffers[i]->name, name) == 0) {
+            return ecex_set_current_buffer_index(ed, i);
+        }
+    }
+
+    return ECEX_ERR;
+}
+
+buffer_t *ecex_current_buffer(ecex_t *ed) {
+    if (!ed) return NULL;
+    ecex_window_t *win = ecex_current_window(ed);
+    if (win && win->buffer) return win->buffer;
+    return ed->current_buffer;
+}
+
+ecex_window_t *ecex_current_window(ecex_t *ed) {
+    if (!ed || ed->window_count == 0 || ed->current_window_index >= ed->window_count) return NULL;
+    return &ed->windows[ed->current_window_index];
+}
+
+size_t ecex_window_count(ecex_t *ed) {
+    return ed ? ed->window_count : 0;
+}
+
+static int ecex_reserve_windows(ecex_t *ed, size_t needed) {
+    if (!ed) return ECEX_ERR;
+    if (needed <= ed->window_cap) return ECEX_OK;
+    while (ed->window_cap < needed) {
+        if (ECEX_GROW_ARRAY(ed->windows,
+                            ed->window_count,
+                            ed->window_cap,
+                            ECEX_INITIAL_WINDOW_CAP) != ECEX_OK) {
+            return ECEX_ERR;
+        }
+    }
+    return ECEX_OK;
+}
+
+static int ecex_add_window(ecex_t *ed, ecex_window_t win) {
+    if (!ed || !win.buffer) return ECEX_ERR;
+    if (ecex_reserve_windows(ed, ed->window_count + 1) != ECEX_OK) return ECEX_ERR;
+    ed->windows[ed->window_count++] = win;
+    return ECEX_OK;
+}
+
+int ecex_split_window_vertically(ecex_t *ed) {
+    ecex_window_t *active = ecex_current_window(ed);
+    if (!active || !active->buffer || active->w < 0.08f) return ECEX_ERR;
+
+    ecex_window_t new_win = *active;
+    float half = active->w * 0.5f;
+    active->w = half;
+    new_win.x = active->x + half;
+    new_win.w = half;
+
+    if (ecex_add_window(ed, new_win) != ECEX_OK) return ECEX_ERR;
+    ed->current_window_index = ed->window_count - 1;
+    return ecex_sync_current_buffer(ed);
+}
+
+int ecex_split_window_horizontally(ecex_t *ed) {
+    ecex_window_t *active = ecex_current_window(ed);
+    if (!active || !active->buffer || active->h < 0.08f) return ECEX_ERR;
+
+    ecex_window_t new_win = *active;
+    float half = active->h * 0.5f;
+    active->h = half;
+    new_win.y = active->y + half;
+    new_win.h = half;
+
+    if (ecex_add_window(ed, new_win) != ECEX_OK) return ECEX_ERR;
+    ed->current_window_index = ed->window_count - 1;
+    return ecex_sync_current_buffer(ed);
+}
+
+int ecex_other_window(ecex_t *ed) {
+    if (!ed || ed->window_count == 0) return ECEX_ERR;
+    ed->current_window_index = (ed->current_window_index + 1) % ed->window_count;
+    return ecex_sync_current_buffer(ed);
+}
+
+int ecex_previous_window(ecex_t *ed) {
+    if (!ed || ed->window_count == 0) return ECEX_ERR;
+    if (ed->current_window_index == 0) ed->current_window_index = ed->window_count - 1;
+    else ed->current_window_index--;
+    return ecex_sync_current_buffer(ed);
+}
+
+int ecex_delete_window(ecex_t *ed) {
+    if (!ed || ed->window_count <= 1 || ed->current_window_index >= ed->window_count) return ECEX_ERR;
+
+    size_t index = ed->current_window_index;
+    for (size_t i = index; i + 1 < ed->window_count; i++) {
+        ed->windows[i] = ed->windows[i + 1];
+    }
+    ed->window_count--;
+    if (ed->current_window_index >= ed->window_count) ed->current_window_index = ed->window_count - 1;
+    return ecex_sync_current_buffer(ed);
+}
+
+int ecex_delete_other_windows(ecex_t *ed) {
+    ecex_window_t *active = ecex_current_window(ed);
+    if (!ed || !active) return ECEX_ERR;
+    ecex_window_t keep = *active;
+    keep.x = 0.0f; keep.y = 0.0f; keep.w = 1.0f; keep.h = 1.0f;
+    ed->windows[0] = keep;
+    ed->window_count = 1;
+    ed->current_window_index = 0;
+    return ecex_sync_current_buffer(ed);
+}
+
+int ecex_balance_windows(ecex_t *ed) {
+    if (!ed || ed->window_count == 0) return ECEX_ERR;
+    size_t n = ed->window_count;
+    size_t cols = 1;
+    while (cols * cols < n) cols++;
+    size_t rows = (n + cols - 1) / cols;
+    for (size_t i = 0; i < n; i++) {
+        size_t row = i / cols;
+        size_t col = i % cols;
+        ed->windows[i].x = (float)col / (float)cols;
+        ed->windows[i].y = (float)row / (float)rows;
+        ed->windows[i].w = 1.0f / (float)cols;
+        ed->windows[i].h = 1.0f / (float)rows;
+    }
+    return ecex_sync_current_buffer(ed);
+}
+
+int ecex_next_buffer(ecex_t *ed) {
+    if (!ed || ed->buffer_count == 0) return ECEX_ERR;
+    ecex_sync_current_buffer(ed);
+    return ecex_set_current_buffer_index(ed, (ed->current_buffer_index + 1) % ed->buffer_count);
+}
+
+int ecex_previous_buffer(ecex_t *ed) {
+    if (!ed || ed->buffer_count == 0) return ECEX_ERR;
+    ecex_sync_current_buffer(ed);
+
+    if (ed->current_buffer_index == 0) {
+        ed->current_buffer_index = ed->buffer_count - 1;
+    } else {
+        ed->current_buffer_index--;
+    }
+
+    return ecex_set_current_buffer_index(ed, ed->current_buffer_index);
+}
+
+int ecex_kill_buffer(ecex_t *ed, const char *name) {
+    if (!ed || !name || ed->buffer_count == 0) return ECEX_ERR;
+
+    size_t index = ed->buffer_count;
+    for (size_t i = 0; i < ed->buffer_count; i++) {
+        if (strcmp(ed->buffers[i]->name, name) == 0) {
+            index = i;
+            break;
+        }
+    }
+
+    if (index == ed->buffer_count) return ECEX_ERR;
+
+    buffer_t *victim = ed->buffers[index];
+
+    for (size_t i = index; i + 1 < ed->buffer_count; i++) {
+        ed->buffers[i] = ed->buffers[i + 1];
+    }
+
+    ed->buffer_count--;
+
+    buffer_t *fallback = ed->buffer_count > 0 ? ed->buffers[0] : NULL;
+    for (size_t i = 0; i < ed->window_count; i++) {
+        if (ed->windows[i].buffer == victim) {
+            ed->windows[i].buffer = fallback;
+        }
+    }
+
+    buffer_free(victim);
+
+    if (ed->buffer_count == 0) {
+        ed->current_buffer = NULL;
+        ed->current_buffer_index = 0;
+        ed->window_count = 0;
+        ed->current_window_index = 0;
+        return ECEX_OK;
+    }
+
+    if (ed->current_window_index >= ed->window_count) {
+        ed->current_window_index = ed->window_count ? ed->window_count - 1 : 0;
+    }
+
+    return ecex_sync_current_buffer(ed);
+}
+
+int ecex_keep_jit_module(ecex_t *ed, void *module) {
+    if (!ed || !module) return ECEX_ERR;
+
+    if (ECEX_GROW_ARRAY(ed->jit_modules,
+                        ed->jit_module_count,
+                        ed->jit_module_cap,
+                        8) != ECEX_OK) {
+        return ECEX_ERR;
+    }
+
+    ed->jit_modules[ed->jit_module_count++] = module;
+    return ECEX_OK;
+}
+
+int ecex_set_config_path(ecex_t *ed, const char *path) {
+    if (!ed) return ECEX_ERR;
+
+    char *copy = NULL;
+    if (path && path[0]) {
+        copy = ecex_strdup(path);
+        if (!copy) return ECEX_ERR;
+    }
+
+    free(ed->config_path);
+    ed->config_path = copy;
+    return ECEX_OK;
+}
+
+const char *ecex_config_path(ecex_t *ed) {
+    if (!ed) return NULL;
+    return ed->config_path;
+}
+
+static void ecex_clear_commands(ecex_t *ed) {
+    if (!ed) return;
+
+    for (size_t i = 0; i < ed->command_count; i++) {
+        free(ed->commands[i].name);
+    }
+    ed->command_count = 0;
+}
+
+static void ecex_clear_keybinds(ecex_t *ed) {
+    if (!ed) return;
+
+    for (size_t i = 0; i < ed->keybind_count; i++) {
+        free(ed->keybinds[i].key);
+        free(ed->keybinds[i].command);
+    }
+    ed->keybind_count = 0;
+}
+
+static void ecex_clear_mode_keybinds(ecex_t *ed) {
+    if (!ed) return;
+
+    for (size_t i = 0; i < ed->mode_keybind_count; i++) {
+        free(ed->mode_keybinds[i].key);
+        free(ed->mode_keybinds[i].command);
+    }
+    ed->mode_keybind_count = 0;
+}
+
+int ecex_reload_config(ecex_t *ed) {
+    if (!ed || !ed->config_path || !ed->config_path[0]) {
+        fprintf(stderr, "ecex: no config file to reload; start with --config path/to/ecexrc.c\n");
+        return ECEX_ERR;
+    }
+
+    char *path = ecex_strdup(ed->config_path);
+    if (!path) return ECEX_ERR;
+
+    ecex_clear_commands(ed);
+    ecex_clear_keybinds(ed);
+    ecex_clear_mode_keybinds(ed);
+
+    if (ecex_register_builtins(ed) != ECEX_OK) {
+        free(path);
+        return ECEX_ERR;
+    }
+
+    int result = ecex_load_c_config(ed, path);
+    free(path);
+    return result;
+}
+
+int ecex_register_command(ecex_t *ed, const char *name, ecex_command_fn fn) {
+    if (!ed || !name || !fn) return ECEX_ERR;
+
+    for (size_t i = 0; i < ed->command_count; i++) {
+        if (strcmp(ed->commands[i].name, name) == 0) {
+            ed->commands[i].fn = fn;
+            return ECEX_OK;
+        }
+    }
+
+    if (ECEX_GROW_ARRAY(ed->commands,
+                        ed->command_count,
+                        ed->command_cap,
+                        ECEX_INITIAL_COMMAND_CAP) != ECEX_OK) {
+        return ECEX_ERR;
+    }
+
+    char *copy = ecex_strdup(name);
+    if (!copy) return ECEX_ERR;
+
+    ed->commands[ed->command_count].name = copy;
+    ed->commands[ed->command_count].fn = fn;
+    ed->command_count++;
+    return ECEX_OK;
+}
+
+int ecex_execute_command(ecex_t *ed, const char *name) {
+    if (!ed || !name) return ECEX_ERR;
+
+    for (size_t i = 0; i < ed->command_count; i++) {
+        if (strcmp(ed->commands[i].name, name) == 0) {
+            return ed->commands[i].fn(ed);
+        }
+    }
+
+    return ECEX_ERR;
+}
+
+void ecex_set_clipboard_callbacks(ecex_t *ed,
+                                  ecex_clipboard_get_fn get_fn,
+                                  ecex_clipboard_set_fn set_fn,
+                                  void *userdata) {
+    if (!ed) return;
+    ed->clipboard_get = get_fn;
+    ed->clipboard_set = set_fn;
+    ed->clipboard_userdata = userdata;
+}
+
+const char *ecex_clipboard_get(ecex_t *ed) {
+    if (!ed || !ed->clipboard_get) return NULL;
+    return ed->clipboard_get(ed->clipboard_userdata);
+}
+
+int ecex_clipboard_set(ecex_t *ed, const char *text) {
+    if (!ed || !ed->clipboard_set || !text) return ECEX_ERR;
+    ed->clipboard_set(ed->clipboard_userdata, text);
+    return ECEX_OK;
+}
+
+int ecex_bind_key(ecex_t *ed, const char *key, const char *command) {
+    if (!ed || !key || !command) return ECEX_ERR;
+
+    for (size_t i = 0; i < ed->keybind_count; i++) {
+        if (strcmp(ed->keybinds[i].key, key) == 0) {
+            char *new_command = ecex_strdup(command);
+            if (!new_command) return ECEX_ERR;
+
+            free(ed->keybinds[i].command);
+            ed->keybinds[i].command = new_command;
+            return ECEX_OK;
+        }
+    }
+
+    if (ECEX_GROW_ARRAY(ed->keybinds,
+                        ed->keybind_count,
+                        ed->keybind_cap,
+                        ECEX_INITIAL_KEYBIND_CAP) != ECEX_OK) {
+        return ECEX_ERR;
+    }
+
+    char *key_copy = ecex_strdup(key);
+    char *command_copy = ecex_strdup(command);
+    if (!key_copy || !command_copy) {
+        free(key_copy);
+        free(command_copy);
+        return ECEX_ERR;
+    }
+
+    ed->keybinds[ed->keybind_count].key = key_copy;
+    ed->keybinds[ed->keybind_count].command = command_copy;
+    ed->keybind_count++;
+    return ECEX_OK;
+}
+
+const char *ecex_lookup_key(ecex_t *ed, const char *key) {
+    if (!ed || !key) return NULL;
+
+    for (size_t i = 0; i < ed->keybind_count; i++) {
+        if (strcmp(ed->keybinds[i].key, key) == 0) {
+            return ed->keybinds[i].command;
+        }
+    }
+
+    return NULL;
+}
+
+int ecex_define_major_mode(ecex_t *ed, const char *name) {
+    if (!ed || !name || !name[0]) return 0;
+
+    for (size_t i = 0; i < ed->major_mode_count; i++) {
+        if (strcmp(ed->major_modes[i].name, name) == 0) {
+            return ed->major_modes[i].id;
+        }
+    }
+
+    if (ECEX_GROW_ARRAY(ed->major_modes,
+                        ed->major_mode_count,
+                        ed->major_mode_cap,
+                        ECEX_INITIAL_MODE_CAP) != ECEX_OK) {
+        return 0;
+    }
+
+    char *copy = ecex_strdup(name);
+    if (!copy) return 0;
+
+    int id = ed->next_major_mode_id++;
+    ed->major_modes[ed->major_mode_count].id = id;
+    ed->major_modes[ed->major_mode_count].name = copy;
+    ed->major_mode_count++;
+    return id;
+}
+
+int ecex_major_mode_by_name(ecex_t *ed, const char *name) {
+    if (!ed || !name) return 0;
+    for (size_t i = 0; i < ed->major_mode_count; i++) {
+        if (strcmp(ed->major_modes[i].name, name) == 0) return ed->major_modes[i].id;
+    }
+    return 0;
+}
+
+const char *ecex_major_mode_name(ecex_t *ed, int mode) {
+    if (!ed || mode == 0) return "fundamental-mode";
+    for (size_t i = 0; i < ed->major_mode_count; i++) {
+        if (ed->major_modes[i].id == mode) return ed->major_modes[i].name;
+    }
+    return "unknown-mode";
+}
+
+int ecex_buffer_set_major_mode(buffer_t *buffer, int mode) {
+    if (!buffer) return ECEX_ERR;
+    buffer->major_mode = mode;
+    return ECEX_OK;
+}
+
+int ecex_buffer_set_major_mode_by_name(ecex_t *ed, buffer_t *buffer, const char *name) {
+    if (!ed || !buffer || !name) return ECEX_ERR;
+    int mode = ecex_define_major_mode(ed, name);
+    if (!mode) return ECEX_ERR;
+    return ecex_buffer_set_major_mode(buffer, mode);
+}
+
+const char *ecex_buffer_major_mode_name(ecex_t *ed, buffer_t *buffer) {
+    if (!buffer) return "fundamental-mode";
+    return ecex_major_mode_name(ed, buffer->major_mode);
+}
+
+int ecex_bind_mode_key(ecex_t *ed, const char *mode_name, const char *key, const char *command) {
+    if (!ed || !mode_name || !key || !command) return ECEX_ERR;
+
+    int mode = ecex_define_major_mode(ed, mode_name);
+    if (!mode) return ECEX_ERR;
+
+    for (size_t i = 0; i < ed->mode_keybind_count; i++) {
+        if (ed->mode_keybinds[i].mode == mode && strcmp(ed->mode_keybinds[i].key, key) == 0) {
+            char *new_command = ecex_strdup(command);
+            if (!new_command) return ECEX_ERR;
+            free(ed->mode_keybinds[i].command);
+            ed->mode_keybinds[i].command = new_command;
+            return ECEX_OK;
+        }
+    }
+
+    if (ECEX_GROW_ARRAY(ed->mode_keybinds,
+                        ed->mode_keybind_count,
+                        ed->mode_keybind_cap,
+                        ECEX_INITIAL_MODE_KEYBIND_CAP) != ECEX_OK) {
+        return ECEX_ERR;
+    }
+
+    char *key_copy = ecex_strdup(key);
+    char *command_copy = ecex_strdup(command);
+    if (!key_copy || !command_copy) {
+        free(key_copy);
+        free(command_copy);
+        return ECEX_ERR;
+    }
+
+    ed->mode_keybinds[ed->mode_keybind_count].mode = mode;
+    ed->mode_keybinds[ed->mode_keybind_count].key = key_copy;
+    ed->mode_keybinds[ed->mode_keybind_count].command = command_copy;
+    ed->mode_keybind_count++;
+    return ECEX_OK;
+}
+
+const char *ecex_lookup_key_for_buffer(ecex_t *ed, buffer_t *buffer, const char *key) {
+    if (!ed || !key) return NULL;
+
+    int mode = buffer ? buffer->major_mode : 0;
+    if (mode) {
+        for (size_t i = 0; i < ed->mode_keybind_count; i++) {
+            if (ed->mode_keybinds[i].mode == mode && strcmp(ed->mode_keybinds[i].key, key) == 0) {
+                return ed->mode_keybinds[i].command;
+            }
+        }
+    }
+
+    return ecex_lookup_key(ed, key);
+}
+
+int ecex_key_sequence_has_prefix_for_buffer(ecex_t *ed, buffer_t *buffer, const char *prefix) {
+    if (!ed || !prefix) return 0;
+    size_t prefix_len = strlen(prefix);
+    int mode = buffer ? buffer->major_mode : 0;
+
+    if (mode) {
+        for (size_t i = 0; i < ed->mode_keybind_count; i++) {
+            const char *key = ed->mode_keybinds[i].key;
+            if (ed->mode_keybinds[i].mode == mode &&
+                strncmp(key, prefix, prefix_len) == 0 && key[prefix_len] == ' ') {
+                return 1;
+            }
+        }
+    }
+
+    for (size_t i = 0; i < ed->keybind_count; i++) {
+        const char *key = ed->keybinds[i].key;
+        if (strncmp(key, prefix, prefix_len) == 0 && key[prefix_len] == ' ') return 1;
+    }
+
+    return 0;
+}
+
+int ecex_auto_set_major_mode(ecex_t *ed, buffer_t *buffer) {
+    if (!ed || !buffer) return ECEX_ERR;
+
+    const char *name = "fundamental-mode";
+    const char *path = buffer->path ? buffer->path : buffer->name;
+    const char *dot = path ? strrchr(path, '.') : NULL;
+
+    if (dot && (strcmp(dot, ".c") == 0 || strcmp(dot, ".h") == 0 ||
+                strcmp(dot, ".cc") == 0 || strcmp(dot, ".cpp") == 0 ||
+                strcmp(dot, ".hpp") == 0)) {
+        name = "c-mode";
+    }
+
+    if (buffer_is_interactive(buffer) && buffer->name && buffer->name[0] == '*') {
+        name = "special-mode";
+    }
+
+    return ecex_buffer_set_major_mode_by_name(ed, buffer, name);
+}
+
+int ecex_list_commands(ecex_t *ed) {
+    if (!ed) return ECEX_ERR;
+
+    buffer_t *buf = ecex_find_buffer(ed, "*commands*");
+    if (!buf) {
+        buf = ecex_create_buffer(ed, "*commands*", NULL, 0);
+        if (!buf) return ECEX_ERR;
+    }
+
+    if (buffer_clear(buf) != ECEX_OK) return ECEX_ERR;
+    buffer_append(buf, "Commands:\n\n");
+
+    for (size_t i = 0; i < ed->command_count; i++) {
+        const char *command_name = ed->commands[i].name;
+        int first_key = 1;
+
+        buffer_append(buf, "  ");
+        buffer_append(buf, command_name);
+
+        for (size_t j = 0; j < ed->keybind_count; j++) {
+            if (strcmp(ed->keybinds[j].command, command_name) == 0) {
+                buffer_append(buf, first_key ? "    [" : ", ");
+                buffer_append(buf, ed->keybinds[j].key);
+                first_key = 0;
+            }
+        }
+
+        for (size_t j = 0; j < ed->mode_keybind_count; j++) {
+            if (strcmp(ed->mode_keybinds[j].command, command_name) == 0) {
+                buffer_append(buf, first_key ? "    [" : ", ");
+                buffer_append(buf, ecex_major_mode_name(ed, ed->mode_keybinds[j].mode));
+                buffer_append(buf, ":");
+                buffer_append(buf, ed->mode_keybinds[j].key);
+                first_key = 0;
+            }
+        }
+
+        if (!first_key) buffer_append(buf, "]");
+        buffer_append(buf, "\n");
+    }
+
+    buf->point = 0;
+    buf->modified = 0;
+    return ecex_switch_buffer(ed, "*commands*");
+}
+
+
+
+static int ecex_interactive_switch_buffer_action(ecex_t *ed,
+                                                 buffer_t *buffer,
+                                                 size_t line,
+                                                 const char *payload,
+                                                 void *userdata) {
+    (void)buffer;
+    (void)line;
+    (void)userdata;
+
+    if (!ed || !payload) return ECEX_ERR;
+    return ecex_switch_buffer(ed, payload);
+}
+
+int ecex_list_buffers(ecex_t *ed) {
+    if (!ed) return ECEX_ERR;
+
+    buffer_t *buf = ecex_find_buffer(ed, "*buffers*");
+    if (!buf) {
+        buf = ecex_create_interactive_buffer(ed, "*buffers*");
+        if (!buf) return ECEX_ERR;
+    }
+
+    buffer_set_interactive(buf, 1);
+    if (buffer_clear(buf) != ECEX_OK) return ECEX_ERR;
+    buffer_set_interactive(buf, 1);
+
+    buffer_append(buf, "Buffers:\n");
+    buffer_append(buf, "Press ENTER on a buffer to switch to it.\n\n");
+
+    for (size_t i = 0; i < ed->buffer_count; i++) {
+        buffer_t *b = ed->buffers[i];
+        char line[1024];
+
+        snprintf(line,
+                 sizeof(line),
+                 "%s %s %-24s %-18s size:%zu%s%s",
+                 b == ed->current_buffer ? "*" : " ",
+                 b->modified ? "+" : " ",
+                 b->name ? b->name : "(unnamed)",
+                 ecex_buffer_major_mode_name(ed, b),
+                 b->len,
+                 b->path ? "    " : "",
+                 b->path ? b->path : "");
+
+        if (ecex_interactive_append_line(ed,
+                                         buf,
+                                         line,
+                                         ecex_interactive_switch_buffer_action,
+                                         b->name,
+                                         NULL) != ECEX_OK) {
+            return ECEX_ERR;
+        }
+    }
+
+    buf->point = 0;
+    buf->modified = 0;
+    return ecex_switch_buffer(ed, "*buffers*");
+}
+
+buffer_t *ecex_create_interactive_buffer(ecex_t *ed, const char *name) {
+    if (!ed || !name) return NULL;
+
+    buffer_t *buffer = ecex_find_buffer(ed, name);
+    if (!buffer) {
+        buffer = ecex_create_buffer(ed, name, NULL, 0);
+        if (!buffer) return NULL;
+    }
+
+    buffer_set_interactive(buffer, 1);
+    if (buffer->major_mode == 0) ecex_buffer_set_major_mode_by_name(ed, buffer, "special-mode");
+    return buffer;
+}
+
+int ecex_interactive_append_line(ecex_t *ed,
+                                 buffer_t *buffer,
+                                 const char *text,
+                                 ecex_interactive_line_fn fn,
+                                 const char *payload,
+                                 void *userdata) {
+    (void)ed;
+
+    if (!buffer || !text) return ECEX_ERR;
+
+    size_t line = buffer_line_count(buffer);
+    if (line > 0) line--;
+
+    if (fn) {
+        if (buffer_add_interactive_action(buffer, line, fn, payload, userdata) != ECEX_OK) {
+            return ECEX_ERR;
+        }
+    }
+
+    if (buffer_append(buffer, text) != ECEX_OK) return ECEX_ERR;
+    if (buffer_append(buffer, "\n") != ECEX_OK) return ECEX_ERR;
+
+    buffer_set_interactive(buffer, 1);
+    return ECEX_OK;
+}
+
+int ecex_interactive_activate_current_line(ecex_t *ed) {
+    if (!ed) return ECEX_ERR;
+
+    buffer_t *buffer = ecex_current_buffer(ed);
+    if (!buffer || !buffer_is_interactive(buffer)) return ECEX_ERR;
+
+    size_t line = buffer_current_line_number(buffer);
+    if (line > 0) line--;
+
+    ecex_interactive_line_action_t *action =
+        buffer_interactive_action_at_line(buffer, line);
+
+    if (!action || !action->fn) return ECEX_ERR;
+    return action->fn(ed, buffer, line, action->payload, action->userdata);
+}
+
+static const char *ecex_basename(const char *path) {
+    if (!path || !path[0]) return "untitled";
+
+    const char *last_slash = strrchr(path, '/');
+    if (last_slash && last_slash[1]) return last_slash + 1;
+    if (last_slash && last_slash == path) return "/";
+    return path;
+}
+
+static int ecex_buffer_path_equal(buffer_t *buffer, const char *path) {
+    return buffer && buffer->path && path && strcmp(buffer->path, path) == 0;
+}
+
+int ecex_find_file(ecex_t *ed, const char *path) {
+    if (!ed || !path || !path[0]) return ECEX_ERR;
+
+    for (size_t i = 0; i < ed->buffer_count; i++) {
+        if (ecex_buffer_path_equal(ed->buffers[i], path)) {
+            return ecex_set_current_buffer_index(ed, i);
+        }
+    }
+
+    const char *name = ecex_basename(path);
+    buffer_t *buf = ecex_create_buffer(ed, name, NULL, 0);
+    if (!buf) return ECEX_ERR;
+
+    if (ecex_file_exists(path)) {
+        if (buffer_load_file(buf, path) != ECEX_OK) {
+            ecex_kill_buffer(ed, buf->name);
+            return ECEX_ERR;
+        }
+    } else {
+        char *new_path = ecex_strdup(path);
+        if (!new_path) {
+            ecex_kill_buffer(ed, buf->name);
+            return ECEX_ERR;
+        }
+
+        free(buf->path);
+        buf->path = new_path;
+        buf->modified = 0;
+    }
+
+    ecex_auto_set_major_mode(ed, buf);
+    return ecex_set_current_buffer_index(ed, ed->buffer_count ? ed->buffer_count - 1 : 0);
+}
+
+int ecex_save_current_buffer(ecex_t *ed) {
+    buffer_t *buf = ecex_current_buffer(ed);
+    if (!buf) return ECEX_ERR;
+    return buffer_save(buf);
+}
+
+int ecex_write_current_buffer(ecex_t *ed, const char *path) {
+    buffer_t *buf = ecex_current_buffer(ed);
+    if (!buf || !path || !path[0]) return ECEX_ERR;
+    int result = buffer_save_as(buf, path);
+    if (result == ECEX_OK) ecex_auto_set_major_mode(ed, buf);
+    return result;
+}
+
+void ecex_request_prompt(ecex_t *ed,
+                         ecex_prompt_request_t request,
+                         const char *message) {
+    if (!ed) return;
+
+    ed->prompt_request = request;
+    snprintf(ed->prompt_message,
+             sizeof(ed->prompt_message),
+             "%s",
+             message ? message : "");
+}
+
+void ecex_clear_prompt_request(ecex_t *ed) {
+    if (!ed) return;
+    ed->prompt_request = ECEX_PROMPT_NONE;
+    ed->prompt_message[0] = '\0';
+}
+
+static int ecex_fuzzy_score(const char *candidate, const char *query) {
+    if (!candidate || !query) return -1;
+    if (query[0] == '\0') return 0;
+
+    int score = 0;
+    int consecutive = 0;
+    int last_match = -1;
+    size_t ci = 0;
+    size_t qi = 0;
+
+    while (candidate[ci] && query[qi]) {
+        char c = candidate[ci];
+        char q = query[qi];
+
+        if (c >= 'A' && c <= 'Z') c = (char)(c - 'A' + 'a');
+        if (q >= 'A' && q <= 'Z') q = (char)(q - 'A' + 'a');
+
+        if (c == q) {
+            score += 10;
+
+            if ((int)ci == last_match + 1) {
+                consecutive++;
+                score += 5 * consecutive;
+            } else {
+                consecutive = 0;
+            }
+
+            if (ci == 0) score += 20;
+            if (ci > 0 && (candidate[ci - 1] == '-' ||
+                           candidate[ci - 1] == '_' ||
+                           candidate[ci - 1] == ' ')) {
+                score += 15;
+            }
+
+            last_match = (int)ci;
+            qi++;
+        }
+
+        ci++;
+    }
+
+    if (query[qi] != '\0') return -1;
+
+    score -= (int)strlen(candidate);
+    if (strncmp(candidate, query, strlen(query)) == 0) score += 100;
+    return score;
+}
+
+const char *ecex_complete_command(ecex_t *ed, const char *query) {
+    if (!ed || !query || !ed->theme.completion_enabled) return NULL;
+
+    const char *best = NULL;
+    int best_score = -1;
+
+    for (size_t i = 0; i < ed->command_count; i++) {
+        const char *name = ed->commands[i].name;
+        int score = ecex_fuzzy_score(name, query);
+
+        if (score > best_score) {
+            best_score = score;
+            best = name;
+        }
+    }
+
+    return best;
+}
+
+
+static int ecex_set_owned_string(char **slot, const char *value) {
+    if (!slot) return ECEX_ERR;
+    char *copy = NULL;
+    if (value && value[0]) {
+        copy = ecex_strdup(value);
+        if (!copy) return ECEX_ERR;
+    }
+    free(*slot);
+    *slot = copy;
+    return ECEX_OK;
+}
+
+static int ecex_parse_file_line(const char *text, char *path, size_t path_size, size_t *out_line) {
+    if (!text || !path || path_size == 0 || !out_line) return ECEX_ERR;
+    const char *colon = strchr(text, ':');
+    if (!colon || colon == text) return ECEX_ERR;
+    char *end = NULL;
+    long line = strtol(colon + 1, &end, 10);
+    if (line <= 0 || end == colon + 1) return ECEX_ERR;
+    size_t len = (size_t)(colon - text);
+    if (len >= path_size) len = path_size - 1;
+    memcpy(path, text, len);
+    path[len] = '\0';
+    *out_line = (size_t)line;
+    return ECEX_OK;
+}
+
+static int ecex_goto_file_line_action(ecex_t *ed, buffer_t *buffer, size_t line, const char *payload, void *userdata) {
+    (void)buffer;
+    (void)line;
+    (void)userdata;
+    if (!ed || !payload) return ECEX_ERR;
+    char path[1024];
+    size_t target_line = 1;
+    if (ecex_parse_file_line(payload, path, sizeof(path), &target_line) != ECEX_OK) return ECEX_ERR;
+    if (ecex_find_file(ed, path) != ECEX_OK) return ECEX_ERR;
+    buffer_t *buf = ecex_current_buffer(ed);
+    if (!buf) return ECEX_ERR;
+    size_t pos = 0;
+    for (size_t l = 1; l < target_line && pos < buf->len; pos++) {
+        if (buf->data[pos] == '\n') l++;
+    }
+    buffer_set_point(buf, pos);
+    return ECEX_OK;
+}
+
+static int ecex_append_shell_output(ecex_t *ed, const char *name, const char *command) {
+    if (!ed || !name || !command || !command[0]) return ECEX_ERR;
+    buffer_t *buf = ecex_create_interactive_buffer(ed, name);
+    if (!buf) return ECEX_ERR;
+    buffer_set_interactive(buf, 1);
+    if (buffer_clear(buf) != ECEX_OK) return ECEX_ERR;
+    buffer_set_interactive(buf, 1);
+    ecex_buffer_set_major_mode_by_name(ed, buf, "special-mode");
+
+    char header[2048];
+    snprintf(header, sizeof(header), "%s\n\nKeys: g/r rerun, n/p next/previous result, RET jump, q quit.\n\n", command);
+    buffer_append(buf, header);
+
+    char shell_command[4096];
+    snprintf(shell_command, sizeof(shell_command), "%s 2>&1", command);
+    FILE *pipe = popen(shell_command, "r");
+    if (!pipe) {
+        buffer_append(buf, "Failed to start command.\n");
+        return ecex_switch_buffer(ed, name);
+    }
+
+    char line[4096];
+    while (fgets(line, sizeof(line), pipe)) {
+        size_t len = strlen(line);
+        while (len > 0 && (line[len - 1] == '\n' || line[len - 1] == '\r')) line[--len] = '\0';
+        char path[1024];
+        size_t target = 0;
+        ecex_interactive_line_fn fn = NULL;
+        char payload[1200];
+        payload[0] = '\0';
+        if (ecex_parse_file_line(line, path, sizeof(path), &target) == ECEX_OK) {
+            snprintf(payload, sizeof(payload), "%s:%zu", path, target);
+            fn = ecex_goto_file_line_action;
+        }
+        ecex_interactive_append_line(ed, buf, line, fn, payload[0] ? payload : NULL, NULL);
+    }
+
+    int status = pclose(pipe);
+    char footer[128];
+    snprintf(footer, sizeof(footer), "\n[process exited: %d]\n", status);
+    buffer_append(buf, footer);
+    buf->point = 0;
+    buf->modified = 0;
+    return ecex_switch_buffer(ed, name);
+}
+
+int ecex_compile(ecex_t *ed, const char *command) {
+    if (!ed || !command || !command[0]) return ECEX_ERR;
+    if (ecex_set_owned_string(&ed->last_compile_command, command) != ECEX_OK) return ECEX_ERR;
+    return ecex_append_shell_output(ed, "*compilation*", command);
+}
+
+int ecex_grep(ecex_t *ed, const char *command) {
+    if (!ed || !command || !command[0]) return ECEX_ERR;
+    if (ecex_set_owned_string(&ed->last_grep_command, command) != ECEX_OK) return ECEX_ERR;
+    return ecex_append_shell_output(ed, "*grep*", command);
+}
+
+int ecex_rerun_compile(ecex_t *ed) {
+    if (!ed || !ed->last_compile_command) return ECEX_ERR;
+    return ecex_append_shell_output(ed, "*compilation*", ed->last_compile_command);
+}
+
+int ecex_rerun_grep(ecex_t *ed) {
+    if (!ed || !ed->last_grep_command) return ECEX_ERR;
+    return ecex_append_shell_output(ed, "*grep*", ed->last_grep_command);
+}
+
+int ecex_next_interactive_action(ecex_t *ed) {
+    buffer_t *buf = ecex_current_buffer(ed);
+    if (!buf || !buffer_is_interactive(buf) || buf->interactive_action_count == 0) return ECEX_ERR;
+    size_t current = buffer_current_line_number(buf);
+    if (current > 0) current--;
+    size_t best = (size_t)-1;
+    for (size_t i = 0; i < buf->interactive_action_count; i++) {
+        size_t line = buf->interactive_actions[i].line;
+        if (line > current && (best == (size_t)-1 || line < best)) best = line;
+    }
+    if (best == (size_t)-1) best = buf->interactive_actions[0].line;
+    size_t pos = 0;
+    for (size_t l = 0; l < best && pos < buf->len; pos++) if (buf->data[pos] == '\n') l++;
+    buffer_set_point(buf, pos);
+    return ECEX_OK;
+}
+
+int ecex_previous_interactive_action(ecex_t *ed) {
+    buffer_t *buf = ecex_current_buffer(ed);
+    if (!buf || !buffer_is_interactive(buf) || buf->interactive_action_count == 0) return ECEX_ERR;
+    size_t current = buffer_current_line_number(buf);
+    if (current > 0) current--;
+    size_t best = (size_t)-1;
+    for (size_t i = 0; i < buf->interactive_action_count; i++) {
+        size_t line = buf->interactive_actions[i].line;
+        if (line < current && (best == (size_t)-1 || line > best)) best = line;
+    }
+    if (best == (size_t)-1) best = buf->interactive_actions[buf->interactive_action_count - 1].line;
+    size_t pos = 0;
+    for (size_t l = 0; l < best && pos < buf->len; pos++) if (buf->data[pos] == '\n') l++;
+    buffer_set_point(buf, pos);
+    return ECEX_OK;
+}
+
+static int ecex_region_lines(buffer_t *buf, size_t *out_start, size_t *out_end) {
+    if (!buf || !buffer_has_selection(buf)) return ECEX_ERR;
+    size_t start = 0, end = 0;
+    buffer_selection_range(buf, &start, &end);
+    start = buffer_line_start_at(buf, start);
+    end = buffer_line_end_at(buf, end);
+    if (end < buf->len) end++;
+    if (out_start) *out_start = start;
+    if (out_end) *out_end = end;
+    return ECEX_OK;
+}
+
+int ecex_comment_region(ecex_t *ed) {
+    buffer_t *buf = ecex_current_buffer(ed);
+    size_t start = 0, end = 0;
+    if (!buf || ecex_region_lines(buf, &start, &end) != ECEX_OK) return ECEX_ERR;
+    size_t pos = start;
+    while (pos <= end && pos <= buf->len) {
+        if (buffer_insert_at(buf, pos, "// ") != ECEX_OK) return ECEX_ERR;
+        pos += 3;
+        end += 3;
+        size_t eol = buffer_line_end_at(buf, pos);
+        if (eol >= end || eol >= buf->len) break;
+        pos = eol + 1;
+    }
+    return ECEX_OK;
+}
+
+int ecex_uncomment_region(ecex_t *ed) {
+    buffer_t *buf = ecex_current_buffer(ed);
+    size_t start = 0, end = 0;
+    if (!buf || ecex_region_lines(buf, &start, &end) != ECEX_OK) return ECEX_ERR;
+    size_t pos = start;
+    while (pos < end && pos < buf->len) {
+        if (pos + 2 <= buf->len && memcmp(buf->data + pos, "//", 2) == 0) {
+            size_t del = (pos + 3 <= buf->len && buf->data[pos + 2] == ' ') ? 3 : 2;
+            if (buffer_delete_range(buf, pos, pos + del) != ECEX_OK) return ECEX_ERR;
+            end = end > del ? end - del : 0;
+        }
+        size_t eol = buffer_line_end_at(buf, pos);
+        if (eol >= end || eol >= buf->len) break;
+        pos = eol + 1;
+    }
+    return ECEX_OK;
+}
+
+int ecex_set_font(ecex_t *ed, const char *path) {
+    if (!ed || !path) return ECEX_ERR;
+
+    char *copy = ecex_strdup(path);
+    if (!copy) return ECEX_ERR;
+
+    free(ed->theme.font_path);
+    ed->theme.font_path = copy;
+    return ECEX_OK;
+}
+
+float ecex_get_font_size(ecex_t *ed) {
+    if (!ed) return 0.0f;
+    return ed->theme.font_size;
+}
+
+int ecex_set_font_size(ecex_t *ed, float size) {
+    if (!ed) return ECEX_ERR;
+    ed->theme.font_size = ECEX_CLAMP(size, 8.0f, 96.0f);
+    return ECEX_OK;
+}
+
+int ecex_adjust_font_size(ecex_t *ed, float delta) {
+    if (!ed) return ECEX_ERR;
+    return ecex_set_font_size(ed, ed->theme.font_size + delta);
+}
+
+void ecex_set_bg_color(ecex_t *ed, float r, float g, float b) { if (ed) ed->theme.bg = ecex_color(r, g, b); }
+void ecex_set_fg_color(ecex_t *ed, float r, float g, float b) { if (ed) ed->theme.fg = ecex_color(r, g, b); }
+void ecex_set_status_bg_color(ecex_t *ed, float r, float g, float b) { if (ed) ed->theme.status_bg = ecex_color(r, g, b); }
+void ecex_set_status_fg_color(ecex_t *ed, float r, float g, float b) { if (ed) ed->theme.status_fg = ecex_color(r, g, b); }
+void ecex_set_status_border_color(ecex_t *ed, float r, float g, float b) { if (ed) ed->theme.status_border = ecex_color(r, g, b); }
+void ecex_set_cursor_color(ecex_t *ed, float r, float g, float b) { if (ed) ed->theme.cursor = ecex_color(r, g, b); }
+void ecex_set_region_bg_color(ecex_t *ed, float r, float g, float b) { if (ed) ed->theme.region_bg = ecex_color(r, g, b); }
+void ecex_set_minibuffer_bg_color(ecex_t *ed, float r, float g, float b) { if (ed) ed->theme.minibuffer_bg = ecex_color(r, g, b); }
+void ecex_set_minibuffer_fg_color(ecex_t *ed, float r, float g, float b) { if (ed) ed->theme.minibuffer_fg = ecex_color(r, g, b); }
+void ecex_set_completion_fg_color(ecex_t *ed, float r, float g, float b) { if (ed) ed->theme.completion_fg = ecex_color(r, g, b); }
+void ecex_set_completion_enabled(ecex_t *ed, int enabled) { if (ed) ed->theme.completion_enabled = enabled ? 1 : 0; }
+void ecex_set_interactive_highlight_bg_color(ecex_t *ed, float r, float g, float b) { if (ed) ed->theme.interactive_highlight_bg = ecex_color(r, g, b); }
+void ecex_set_interactive_highlight_fg_color(ecex_t *ed, float r, float g, float b) { if (ed) ed->theme.interactive_highlight_fg = ecex_color(r, g, b); }
+void ecex_set_current_line_bg_color(ecex_t *ed, float r, float g, float b) { if (ed) ed->theme.current_line_bg = ecex_color(r, g, b); }
+void ecex_set_search_bg_color(ecex_t *ed, float r, float g, float b) { if (ed) ed->theme.search_bg = ecex_color(r, g, b); }
+void ecex_set_line_numbers_enabled(ecex_t *ed, int enabled) { if (ed) ed->theme.line_numbers_enabled = enabled ? 1 : 0; }
+void ecex_set_current_line_enabled(ecex_t *ed, int enabled) { if (ed) ed->theme.current_line_enabled = enabled ? 1 : 0; }
diff --git a/src/eval.c b/src/eval.c
new file mode 100644
index 0000000..316d6d8
--- /dev/null
+++ b/src/eval.c
@@ -0,0 +1,482 @@
+#define _POSIX_C_SOURCE 200809L
+
+#include "eval.h"
+
+#include "buffers.h"
+#include "ccdjit.h"
+#include "common.h"
+#include "config.h"
+#include "ecex.h"
+#include "util.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+static ecex_t *g_eval_editor = NULL;
+
+static buffer_t *eval_output_buffer(ecex_t *ed) {
+    if (!ed) return NULL;
+
+    buffer_t *out = ecex_create_interactive_buffer(ed, "*eval-output*");
+    if (out) {
+        ecex_buffer_set_major_mode_by_name(ed, out, "eval-output-mode");
+    }
+
+    return out;
+}
+
+static void eval_append_diag(buffer_t *out, ccdjit_context *ctx) {
+    if (!out || !ctx) return;
+
+    const ccdjit_diagnostic *diag = ccdjit_context_last_error(ctx);
+    if (!diag) {
+        buffer_append(out, "ccdjit: unknown error\n");
+        return;
+    }
+
+    char line[1024];
+    snprintf(line,
+             sizeof(line),
+             "ccdjit error [%s] %s:%d:%d: %s\n",
+             diag->phase ? diag->phase : "?",
+             diag->filename ? diag->filename : "<input>",
+             diag->line,
+             diag->column,
+             diag->message ? diag->message : "(no message)");
+    buffer_append(out, line);
+
+    if (diag->source_line) {
+        buffer_append(out, diag->source_line);
+        buffer_append(out, "\n");
+    }
+
+    if (diag->caret_line) {
+        buffer_append(out, diag->caret_line);
+        buffer_append(out, "\n");
+    }
+}
+
+typedef struct eval_capture {
+    FILE *file;
+    int saved_stdout;
+    int saved_stderr;
+    int active;
+} eval_capture_t;
+
+static void eval_capture_init(eval_capture_t *capture) {
+    if (!capture) return;
+
+    capture->file = NULL;
+    capture->saved_stdout = -1;
+    capture->saved_stderr = -1;
+    capture->active = 0;
+}
+
+static int eval_capture_begin(eval_capture_t *capture, buffer_t *out) {
+    if (!capture) return ECEX_ERR;
+
+    eval_capture_init(capture);
+
+    capture->file = tmpfile();
+    if (!capture->file) {
+        if (out) buffer_append(out, "warning: failed to create stdout capture file\n");
+        return ECEX_ERR;
+    }
+
+    int capture_fd = fileno(capture->file);
+    if (capture_fd < 0) {
+        if (out) buffer_append(out, "warning: failed to get stdout capture fd\n");
+        fclose(capture->file);
+        eval_capture_init(capture);
+        return ECEX_ERR;
+    }
+
+    fflush(NULL);
+
+    capture->saved_stdout = dup(STDOUT_FILENO);
+    capture->saved_stderr = dup(STDERR_FILENO);
+
+    if (capture->saved_stdout < 0 || capture->saved_stderr < 0) {
+        if (out) buffer_append(out, "warning: failed to save stdout/stderr\n");
+
+        if (capture->saved_stdout >= 0) close(capture->saved_stdout);
+        if (capture->saved_stderr >= 0) close(capture->saved_stderr);
+        fclose(capture->file);
+        eval_capture_init(capture);
+        return ECEX_ERR;
+    }
+
+    if (dup2(capture_fd, STDOUT_FILENO) < 0 ||
+        dup2(capture_fd, STDERR_FILENO) < 0) {
+        if (out) buffer_append(out, "warning: failed to redirect stdout/stderr\n");
+
+        dup2(capture->saved_stdout, STDOUT_FILENO);
+        dup2(capture->saved_stderr, STDERR_FILENO);
+        close(capture->saved_stdout);
+        close(capture->saved_stderr);
+        fclose(capture->file);
+        eval_capture_init(capture);
+        return ECEX_ERR;
+    }
+
+    capture->active = 1;
+    return ECEX_OK;
+}
+
+static void eval_capture_restore(eval_capture_t *capture) {
+    if (!capture || !capture->active) return;
+
+    fflush(NULL);
+
+    if (capture->saved_stdout >= 0) {
+        dup2(capture->saved_stdout, STDOUT_FILENO);
+        close(capture->saved_stdout);
+        capture->saved_stdout = -1;
+    }
+
+    if (capture->saved_stderr >= 0) {
+        dup2(capture->saved_stderr, STDERR_FILENO);
+        close(capture->saved_stderr);
+        capture->saved_stderr = -1;
+    }
+
+    capture->active = 0;
+}
+
+static void eval_capture_append_output(eval_capture_t *capture, buffer_t *out) {
+    if (!capture || !capture->file || !out) return;
+
+    if (fseek(capture->file, 0, SEEK_END) != 0) {
+        return;
+    }
+
+    long size = ftell(capture->file);
+    if (size <= 0) {
+        return;
+    }
+
+    if (fseek(capture->file, 0, SEEK_SET) != 0) {
+        return;
+    }
+
+    buffer_append(out, "stdout/stderr:\n");
+
+    char chunk[4096];
+    size_t n = 0;
+
+    while ((n = fread(chunk, 1, sizeof(chunk), capture->file)) > 0) {
+        size_t old_len = out->len;
+
+        if (buffer_reserve(out, out->len + n + 1) != ECEX_OK) {
+            buffer_append(out, "\n[output truncated: allocation failed]\n");
+            return;
+        }
+
+        memcpy(out->data + old_len, chunk, n);
+        out->len += n;
+        out->data[out->len] = '\0';
+        out->point = out->len;
+    }
+
+    if (out->len > 0 && out->data[out->len - 1] != '\n') {
+        buffer_append(out, "\n");
+    }
+
+    buffer_append(out, "\n");
+}
+
+static void eval_capture_finish(eval_capture_t *capture, buffer_t *out) {
+    if (!capture) return;
+
+    eval_capture_restore(capture);
+    eval_capture_append_output(capture, out);
+
+    if (capture->file) {
+        fclose(capture->file);
+    }
+
+    eval_capture_init(capture);
+}
+
+static int source_has_main(const char *source) {
+    if (!source) return 0;
+
+    return strstr(source, "main(") != NULL ||
+           strstr(source, "main (") != NULL;
+}
+
+static char *make_eval_source(const char *source, int wrap_as_statements) {
+    if (!source) return NULL;
+
+    const char *prefix =
+        "#include \"ecex.h\"\n"
+        "#include \"buffers.h\"\n"
+        "extern ecex_t *__ecex_eval_editor;\n"
+        "#define ECEX_ED (__ecex_eval_editor)\n"
+        "\n";
+
+    const char *wrapper_open =
+        "int main(int argc, char **argv) {\n"
+        "    (void)argc;\n"
+        "    (void)argv;\n"
+        "    ecex_t *ed = __ecex_eval_editor;\n"
+        "    (void)ed;\n";
+
+    const char *wrapper_close =
+        "\n"
+        "    return 0;\n"
+        "}\n";
+
+    int do_wrap = wrap_as_statements || !source_has_main(source);
+
+    size_t prefix_len = strlen(prefix);
+    size_t source_len = strlen(source);
+    size_t open_len = do_wrap ? strlen(wrapper_open) : 0;
+    size_t close_len = do_wrap ? strlen(wrapper_close) : 0;
+
+    char *combined = malloc(prefix_len + open_len + source_len + close_len + 2);
+    if (!combined) return NULL;
+
+    char *p = combined;
+    memcpy(p, prefix, prefix_len);
+    p += prefix_len;
+
+    if (do_wrap) {
+        memcpy(p, wrapper_open, open_len);
+        p += open_len;
+    }
+
+    memcpy(p, source, source_len);
+    p += source_len;
+
+    if (do_wrap) {
+        if (source_len == 0 || source[source_len - 1] != '\n') {
+            *p++ = '\n';
+        }
+        memcpy(p, wrapper_close, close_len);
+        p += close_len;
+    }
+
+    *p = '\0';
+    return combined;
+}
+
+static int remember_last_eval(ecex_t *ed,
+                              const char *source,
+                              const char *filename,
+                              int wrap_as_statements) {
+    if (!ed || !source) return ECEX_ERR;
+
+    char *source_copy = ecex_strdup(source);
+    char *filename_copy = ecex_strdup(filename ? filename : "<eval>");
+    if (!source_copy || !filename_copy) {
+        free(source_copy);
+        free(filename_copy);
+        return ECEX_ERR;
+    }
+
+    free(ed->last_eval_source);
+    free(ed->last_eval_filename);
+    ed->last_eval_source = source_copy;
+    ed->last_eval_filename = filename_copy;
+    ed->last_eval_wrap_as_statements = wrap_as_statements;
+    return ECEX_OK;
+}
+
+int ecex_eval_source(ecex_t *ed,
+                     const char *source,
+                     const char *filename,
+                     int wrap_as_statements) {
+    if (!ed || !source) return ECEX_ERR;
+
+    remember_last_eval(ed, source, filename, wrap_as_statements);
+
+    buffer_t *out = eval_output_buffer(ed);
+    if (!out) return ECEX_ERR;
+
+    buffer_clear(out);
+    buffer_set_interactive(out, 1);
+    ecex_buffer_set_major_mode_by_name(ed, out, "eval-output-mode");
+    buffer_append(out, "Eval output (g: re-eval, q: quit window, ENTER: follow line if available)\n");
+    buffer_append(out, "────────────────────────────────────────────────────────────────\n\n");
+    buffer_append(out, "Eval: ");
+    buffer_append(out, filename ? filename : "<eval>");
+    buffer_append(out, "\n\n");
+
+    char *eval_source = make_eval_source(source, wrap_as_statements);
+    if (!eval_source) {
+        buffer_append(out, "failed to allocate eval source\n");
+        ecex_switch_buffer(ed, "*eval-output*");
+        return ECEX_ERR;
+    }
+
+    ccdjit_context *ctx = ccdjit_context_new(NULL);
+    if (!ctx) {
+        buffer_append(out, "failed to create ccdjit context\n");
+        free(eval_source);
+        ecex_switch_buffer(ed, "*eval-output*");
+        return ECEX_ERR;
+    }
+
+    if (ecex_add_ccdjit_include_paths(ctx) != ECEX_OK ||
+        ecex_register_host_symbols(ctx) != ECEX_OK ||
+        ccdjit_context_register_symbol(ctx,
+                                       "__ecex_eval_editor",
+                                       (void *)&g_eval_editor) != 0) {
+        buffer_append(out, "failed to prepare eval context\n");
+        eval_append_diag(out, ctx);
+        ccdjit_context_free(ctx);
+        free(eval_source);
+        ecex_switch_buffer(ed, "*eval-output*");
+        return ECEX_ERR;
+    }
+
+    g_eval_editor = ed;
+
+    ccdjit_module *module = NULL;
+    if (ccdjit_compile_string(ctx,
+                              eval_source,
+                              filename ? filename : "<eval>",
+                              &module) != 0) {
+        buffer_append(out, "compile failed\n\n");
+        eval_append_diag(out, ctx);
+        g_eval_editor = NULL;
+        ccdjit_context_free(ctx);
+        free(eval_source);
+        ecex_switch_buffer(ed, "*eval-output*");
+        return ECEX_ERR;
+    }
+
+    int result = 0;
+    eval_capture_t capture;
+    int capture_enabled = (eval_capture_begin(&capture, out) == ECEX_OK);
+    int runtime_status = ccdjit_module_call_main(module, 0, NULL, &result);
+
+    if (capture_enabled) {
+        eval_capture_finish(&capture, out);
+    }
+
+    if (runtime_status != 0) {
+        buffer_append(out, "runtime failed\n\n");
+        eval_append_diag(out, ctx);
+        ccdjit_module_free(module);
+        g_eval_editor = NULL;
+        ccdjit_context_free(ctx);
+        free(eval_source);
+        ecex_switch_buffer(ed, "*eval-output*");
+        return ECEX_ERR;
+    }
+
+    char line[128];
+    snprintf(line, sizeof(line), "ok, result = %d\n", result);
+    buffer_append(out, line);
+
+    /*
+     * Keep successful eval modules alive.  This makes eval useful for live
+     * customization: code evaluated from a buffer may register commands whose
+     * function pointers remain valid after eval returns.
+     */
+    if (ecex_keep_jit_module(ed, module) != ECEX_OK) {
+        buffer_append(out, "failed to keep eval module alive\n");
+        ccdjit_module_free(module);
+        g_eval_editor = NULL;
+        ccdjit_context_free(ctx);
+        free(eval_source);
+        ecex_switch_buffer(ed, "*eval-output*");
+        return ECEX_ERR;
+    }
+
+    g_eval_editor = NULL;
+    ccdjit_context_free(ctx);
+    free(eval_source);
+
+    out->modified = 0;
+    out->point = 0;
+    ecex_switch_buffer(ed, "*eval-output*");
+    return ECEX_OK;
+}
+
+int ecex_eval_current_buffer(ecex_t *ed) {
+    buffer_t *buf = ecex_current_buffer(ed);
+    if (!buf || !buf->data) return ECEX_ERR;
+
+    return ecex_eval_source(ed,
+                            buf->data,
+                            buf->path ? buf->path : buf->name,
+                            0);
+}
+
+int ecex_eval_current_line(ecex_t *ed) {
+    buffer_t *buf = ecex_current_buffer(ed);
+    if (!buf) return ECEX_ERR;
+
+    char *line = buffer_current_line_copy(buf);
+    if (!line) return ECEX_ERR;
+
+    int result = ecex_eval_source(ed, line, "<current-line>", 1);
+    free(line);
+    return result;
+}
+
+
+int ecex_eval_current_region(ecex_t *ed) {
+    buffer_t *buf = ecex_current_buffer(ed);
+    if (!buf || !buffer_has_selection(buf)) return ECEX_ERR;
+
+    size_t start = 0;
+    size_t end = 0;
+    buffer_selection_range(buf, &start, &end);
+
+    char *region = buffer_substring(buf, start, end);
+    if (!region) return ECEX_ERR;
+
+    int result = ecex_eval_source(ed, region, "<region>", 1);
+    free(region);
+    return result;
+}
+
+int ecex_eval_file(ecex_t *ed, const char *path) {
+    if (!ed || !path || !path[0]) return ECEX_ERR;
+
+    size_t size = 0;
+    char *source = ecex_read_entire_file(path, &size);
+    (void)size;
+
+    if (!source) {
+        buffer_t *out = eval_output_buffer(ed);
+        if (out) {
+            buffer_clear(out);
+            buffer_append(out, "failed to read eval file: ");
+            buffer_append(out, path);
+            buffer_append(out, "\n");
+            out->modified = 0;
+            ecex_switch_buffer(ed, "*eval-output*");
+        }
+        return ECEX_ERR;
+    }
+
+    int result = ecex_eval_source(ed, source, path, 0);
+    free(source);
+    return result;
+}
+
+int ecex_eval_rerun_last(ecex_t *ed) {
+    if (!ed || !ed->last_eval_source) return ECEX_ERR;
+
+    char *source = ecex_strdup(ed->last_eval_source);
+    char *filename = ecex_strdup(ed->last_eval_filename ? ed->last_eval_filename : "<eval>");
+    int wrap = ed->last_eval_wrap_as_statements;
+
+    if (!source || !filename) {
+        free(source);
+        free(filename);
+        return ECEX_ERR;
+    }
+
+    int result = ecex_eval_source(ed, source, filename, wrap);
+    free(source);
+    free(filename);
+    return result;
+}
diff --git a/src/font.c b/src/font.c
new file mode 100644
index 0000000..62985e4
--- /dev/null
+++ b/src/font.c
@@ -0,0 +1,258 @@
+#include "font.h"
+#include "util.h"
+
+#define STB_TRUETYPE_IMPLEMENTATION
+#include "stb_truetype.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+const char *font_choose_path(const char *explicit_font_path) {
+    static char candidate[4096];
+
+    if (explicit_font_path && explicit_font_path[0]) {
+        return explicit_font_path;
+    }
+
+    const char *env_font = getenv("ECEX_FONT");
+    if (env_font && env_font[0]) {
+        return env_font;
+    }
+
+    const char *guix_env = getenv("GUIX_ENVIRONMENT");
+    if (guix_env && guix_env[0]) {
+        snprintf(candidate, sizeof(candidate),
+                 "%s/share/fonts/truetype/DejaVuSansMono.ttf", guix_env);
+        if (ecex_file_exists(candidate)) return candidate;
+
+        snprintf(candidate, sizeof(candidate),
+                 "%s/share/fonts/truetype/dejavu/DejaVuSansMono.ttf", guix_env);
+        if (ecex_file_exists(candidate)) return candidate;
+
+        snprintf(candidate, sizeof(candidate),
+                 "%s/share/fonts/dejavu/DejaVuSansMono.ttf", guix_env);
+        if (ecex_file_exists(candidate)) return candidate;
+    }
+
+    const char *home = getenv("HOME");
+    if (home && home[0]) {
+        snprintf(candidate, sizeof(candidate),
+                 "%s/.guix-profile/share/fonts/truetype/DejaVuSansMono.ttf", home);
+        if (ecex_file_exists(candidate)) return candidate;
+
+        snprintf(candidate, sizeof(candidate),
+                 "%s/.guix-profile/share/fonts/truetype/dejavu/DejaVuSansMono.ttf", home);
+        if (ecex_file_exists(candidate)) return candidate;
+
+        snprintf(candidate, sizeof(candidate),
+                 "%s/.guix-profile/share/fonts/dejavu/DejaVuSansMono.ttf", home);
+        if (ecex_file_exists(candidate)) return candidate;
+    }
+
+    if (ecex_file_exists("/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf")) {
+        return "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf";
+    }
+
+    if (ecex_file_exists("/usr/share/fonts/TTF/DejaVuSansMono.ttf")) {
+        return "/usr/share/fonts/TTF/DejaVuSansMono.ttf";
+    }
+
+    return NULL;
+}
+
+int font_load(font_t *font, const char *path, float size_px) {
+    if (!font || !path) return -1;
+
+    memset(font, 0, sizeof(*font));
+
+    size_t ttf_size = 0;
+    char *ttf_data = ecex_read_entire_file(path, &ttf_size);
+    if (!ttf_data) {
+        fprintf(stderr, "failed to read font: %s\n", path);
+        return -1;
+    }
+
+    unsigned char *bitmap = calloc(1, ECEX_FONT_BITMAP_W * ECEX_FONT_BITMAP_H);
+    if (!bitmap) {
+        free(ttf_data);
+        return -1;
+    }
+
+    stbtt_fontinfo info;
+    int ascent = 0;
+    int descent = 0;
+    int line_gap = 0;
+
+    if (stbtt_InitFont(&info, (const unsigned char *)ttf_data, 0)) {
+        float scale = stbtt_ScaleForPixelHeight(&info, size_px);
+        stbtt_GetFontVMetrics(&info, &ascent, &descent, &line_gap);
+
+        font->ascent_px = (float)ascent * scale;
+        font->descent_px = (float)(-descent) * scale;
+        font->line_gap_px = (float)line_gap * scale;
+    }
+
+    if (font->ascent_px <= 0.0f) {
+        font->ascent_px = size_px * 0.80f;
+    }
+
+    if (font->descent_px <= 0.0f) {
+        font->descent_px = size_px * 0.20f;
+    }
+
+    if (font->line_gap_px < 0.0f) {
+        font->line_gap_px = 0.0f;
+    }
+
+    int bake_result = stbtt_BakeFontBitmap(
+        (const unsigned char *)ttf_data,
+        0,
+        size_px,
+        bitmap,
+        ECEX_FONT_BITMAP_W,
+        ECEX_FONT_BITMAP_H,
+        ECEX_FONT_FIRST_CHAR,
+        ECEX_FONT_CHAR_COUNT,
+        font->chars
+    );
+
+    free(ttf_data);
+
+    if (bake_result <= 0) {
+        fprintf(stderr, "failed to bake font atlas from: %s\n", path);
+        free(bitmap);
+        return -1;
+    }
+
+    glGenTextures(1, &font->texture);
+    glBindTexture(GL_TEXTURE_2D, font->texture);
+
+    glTexImage2D(GL_TEXTURE_2D,
+                 0,
+                 GL_ALPHA,
+                 ECEX_FONT_BITMAP_W,
+                 ECEX_FONT_BITMAP_H,
+                 0,
+                 GL_ALPHA,
+                 GL_UNSIGNED_BYTE,
+                 bitmap);
+
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+    free(bitmap);
+
+    font->size_px = size_px;
+    font->line_height = font->ascent_px + font->descent_px + font->line_gap_px;
+
+    if (font->line_height < size_px * 1.15f) {
+        font->line_height = size_px * 1.15f;
+    }
+
+    fprintf(stderr, "ecex: loaded font: %s\n", path);
+    return 0;
+}
+
+void font_free(font_t *font) {
+    if (!font) return;
+
+    if (font->texture) {
+        glDeleteTextures(1, &font->texture);
+        font->texture = 0;
+    }
+}
+
+void draw_text(font_t *font, float x, float y, const char *text) {
+    if (!font || !font->texture || !text) return;
+
+    glEnable(GL_TEXTURE_2D);
+    glBindTexture(GL_TEXTURE_2D, font->texture);
+
+    glBegin(GL_QUADS);
+
+    float start_x = x;
+
+    for (const char *p = text; *p; p++) {
+        unsigned char c = (unsigned char)*p;
+
+        if (c == '\n') {
+            x = start_x;
+            y += font->line_height;
+            continue;
+        }
+
+        if (c == '\t') {
+            x += font->size_px * 4.0f;
+            continue;
+        }
+
+        if (c < ECEX_FONT_FIRST_CHAR ||
+            c >= ECEX_FONT_FIRST_CHAR + ECEX_FONT_CHAR_COUNT) {
+            c = '?';
+        }
+
+        stbtt_aligned_quad q;
+
+        stbtt_GetBakedQuad(font->chars,
+                           ECEX_FONT_BITMAP_W,
+                           ECEX_FONT_BITMAP_H,
+                           c - ECEX_FONT_FIRST_CHAR,
+                           &x,
+                           &y,
+                           &q,
+                           1);
+
+        glTexCoord2f(q.s0, q.t0);
+        glVertex2f(q.x0, q.y0);
+
+        glTexCoord2f(q.s1, q.t0);
+        glVertex2f(q.x1, q.y0);
+
+        glTexCoord2f(q.s1, q.t1);
+        glVertex2f(q.x1, q.y1);
+
+        glTexCoord2f(q.s0, q.t1);
+        glVertex2f(q.x0, q.y1);
+    }
+
+    glEnd();
+
+    glDisable(GL_TEXTURE_2D);
+}
+
+float text_width(font_t *font, const char *text) {
+    if (!font || !text) return 0.0f;
+
+    float x = 0.0f;
+    float y = 0.0f;
+
+    for (const char *p = text; *p; p++) {
+        unsigned char c = (unsigned char)*p;
+
+        if (c == '\n') break;
+
+        if (c == '\t') {
+            x += font->size_px * 4.0f;
+            continue;
+        }
+
+        if (c < ECEX_FONT_FIRST_CHAR ||
+            c >= ECEX_FONT_FIRST_CHAR + ECEX_FONT_CHAR_COUNT) {
+            c = '?';
+        }
+
+        stbtt_aligned_quad q;
+
+        stbtt_GetBakedQuad(font->chars,
+                           ECEX_FONT_BITMAP_W,
+                           ECEX_FONT_BITMAP_H,
+                           c - ECEX_FONT_FIRST_CHAR,
+                           &x,
+                           &y,
+                           &q,
+                           1);
+    }
+
+    return x;
+}
diff --git a/src/main.c b/src/main.c
new file mode 100644
index 0000000..9f388a0
--- /dev/null
+++ b/src/main.c
@@ -0,0 +1,164 @@
+#include "app.h"
+#include "config.h"
+#include "font.h"
+#include "render.h"
+
+#include <GLFW/glfw3.h>
+
+#include <stdio.h>
+#include <string.h>
+
+#define WINDOW_WIDTH 1000
+#define WINDOW_HEIGHT 700
+
+static void print_usage(const char *argv0) {
+    fprintf(stderr, "usage:\n");
+    fprintf(stderr, "  %s [--config path/to/ecexrc.c] [--font path/to/font.ttf]\n", argv0);
+    fprintf(stderr, "\n");
+    fprintf(stderr, "keys:\n");
+    fprintf(stderr, "  F1 opens M-x\n");
+    fprintf(stderr, "  Tab completes M-x command names\n");
+    fprintf(stderr, "  Alt+x opens M-x when the OS/window-manager allows it\n");
+    fprintf(stderr, "  C-x is reserved for prefix maps\n");
+    fprintf(stderr, "\n");
+    fprintf(stderr, "env:\n");
+    fprintf(stderr, "  ECEX_FONT=/path/to/font.ttf\n");
+    fprintf(stderr, "  ECEX_INCLUDE=/path/to/ecex/include\n");
+}
+
+static int parse_args(int argc,
+                      char **argv,
+                      const char **config_path,
+                      const char **font_path_arg) {
+    *config_path = NULL;
+    *font_path_arg = NULL;
+
+    for (int i = 1; i < argc; i++) {
+        if (strcmp(argv[i], "--config") == 0) {
+            if (i + 1 >= argc) {
+                print_usage(argv[0]);
+                return -1;
+            }
+
+            *config_path = argv[++i];
+        } else if (strcmp(argv[i], "--font") == 0) {
+            if (i + 1 >= argc) {
+                print_usage(argv[0]);
+                return -1;
+            }
+
+            *font_path_arg = argv[++i];
+        } else if (strcmp(argv[i], "--help") == 0 ||
+                   strcmp(argv[i], "-h") == 0) {
+            print_usage(argv[0]);
+            return 1;
+        } else {
+            *font_path_arg = argv[i];
+        }
+    }
+
+    return 0;
+}
+
+static const char *select_font_path(ecex_t *ed, const char *font_path_arg) {
+    if (font_path_arg) return font_path_arg;
+    if (ed && ed->theme.font_path) return ed->theme.font_path;
+    return font_choose_path(NULL);
+}
+
+int main(int argc, char **argv) {
+    const char *config_path = NULL;
+    const char *font_path_arg = NULL;
+
+    int args_result = parse_args(argc, argv, &config_path, &font_path_arg);
+    if (args_result != 0) {
+        return args_result < 0 ? 1 : 0;
+    }
+
+    ecex_t *ed = ecex_new();
+    if (!ed) {
+        fprintf(stderr, "failed to create editor\n");
+        return 1;
+    }
+
+    if (config_path) {
+        if (ecex_load_c_config(ed, config_path) != 0) {
+            fprintf(stderr, "ecex: continuing without config\n");
+        }
+    }
+
+    if (!glfwInit()) {
+        fprintf(stderr, "failed to initialize GLFW\n");
+        ecex_free(ed);
+        return 1;
+    }
+
+    GLFWwindow *window = glfwCreateWindow(
+        WINDOW_WIDTH,
+        WINDOW_HEIGHT,
+        "ecex",
+        NULL,
+        NULL
+    );
+
+    if (!window) {
+        fprintf(stderr, "failed to create GLFW window\n");
+        glfwTerminate();
+        ecex_free(ed);
+        return 1;
+    }
+
+    glfwMakeContextCurrent(window);
+    glfwSwapInterval(1);
+
+    app_t app;
+    app_init(&app, ed);
+    app_set_window(&app, window);
+
+    const char *font_path = select_font_path(ed, font_path_arg);
+    if (!font_path) {
+        fprintf(stderr, "ecex: could not find a font automatically\n");
+        fprintf(stderr, "try:\n");
+        fprintf(stderr, "  export ECEX_FONT=/path/to/font.ttf\n");
+        fprintf(stderr, "  %s --font /path/to/font.ttf\n", argv[0]);
+
+        glfwDestroyWindow(window);
+        glfwTerminate();
+        ecex_free(ed);
+        return 1;
+    }
+
+    if (font_load(&app.font, font_path, ed->theme.font_size) != 0) {
+        fprintf(stderr, "ecex: could not load font\n");
+        fprintf(stderr, "try an explicit font path:\n");
+        fprintf(stderr, "  %s --font /path/to/font.ttf\n", argv[0]);
+
+        glfwDestroyWindow(window);
+        glfwTerminate();
+        ecex_free(ed);
+        return 1;
+    }
+
+    snprintf(app.font_path, sizeof(app.font_path), "%s", font_path);
+
+    app_install_callbacks(&app);
+    app_message(&app, "F1 for M-x. Tab completes commands.");
+
+    while (!glfwWindowShouldClose(window) && !ed->should_quit) {
+        if (app.dirty) {
+            render(&app);
+            glfwSwapBuffers(window);
+            app.dirty = 0;
+        }
+
+        glfwWaitEvents();
+    }
+
+    font_free(&app.font);
+
+    glfwDestroyWindow(window);
+    glfwTerminate();
+
+    ecex_free(ed);
+    return 0;
+}
diff --git a/src/render.c b/src/render.c
new file mode 100644
index 0000000..64a85f1
--- /dev/null
+++ b/src/render.c
@@ -0,0 +1,613 @@
+#include "render.h"
+
+#include "common.h"
+
+#include <GLFW/glfw3.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * All UI measurements are derived from the active font.  draw_text() uses a
+ * baseline y coordinate, so render.c keeps both line-top and baseline values
+ * explicit.  This avoids the old fixed 24/28/34 pixel constants drifting when
+ * font size changes.
+ */
+typedef struct view_rect {
+    float x;
+    float y;
+    float w;
+    float h;
+} view_rect_t;
+
+typedef struct ui_metrics {
+    float pad_x;
+    float pad_y;
+
+    float content_x;
+    float content_top;
+    float content_bottom_pad;
+
+    float status_h;
+    float minibuffer_h;
+
+    float cursor_w;
+    float cursor_h;
+} ui_metrics_t;
+
+static float ecex_maxf(float a, float b) {
+    return a > b ? a : b;
+}
+
+static ui_metrics_t ui_metrics(app_t *app) {
+    float size = app && app->font.size_px > 1.0f ? app->font.size_px : 16.0f;
+    float line_h = app && app->font.line_height > 1.0f
+        ? app->font.line_height
+        : size * 1.20f;
+
+    ui_metrics_t m;
+
+    m.pad_x = ecex_maxf(8.0f, size * 0.75f);
+    m.pad_y = ecex_maxf(4.0f, size * 0.35f);
+
+    m.content_x = m.pad_x;
+    m.content_top = m.pad_y;
+    m.content_bottom_pad = m.pad_y;
+
+    m.status_h = line_h + m.pad_y * 2.0f;
+    m.minibuffer_h = line_h + m.pad_y * 2.0f;
+
+    m.cursor_w = ecex_maxf(2.0f, size * 0.10f);
+    m.cursor_h = ecex_maxf(1.0f, app ? app->font.ascent_px + app->font.descent_px : size);
+
+    return m;
+}
+
+static float line_baseline(app_t *app, float line_top) {
+    float ascent = app->font.ascent_px > 1.0f
+        ? app->font.ascent_px
+        : app->font.size_px * 0.80f;
+
+    return line_top + ascent;
+}
+
+static void setup_2d(int width, int height) {
+    glViewport(0, 0, width, height);
+
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glOrtho(0, width, height, 0, -1, 1);
+
+    glMatrixMode(GL_MODELVIEW);
+    glLoadIdentity();
+}
+
+static void draw_rect(float x, float y, float w, float h) {
+    glBegin(GL_QUADS);
+    glVertex2f(x, y);
+    glVertex2f(x + w, y);
+    glVertex2f(x + w, y + h);
+    glVertex2f(x, y + h);
+    glEnd();
+}
+
+static float mono_cell_width(app_t *app) {
+    float w = text_width(&app->font, "M");
+    return w > 1.0f ? w : app->font.size_px * 0.6f;
+}
+
+static int minibuffer_visible(app_t *app) {
+    return app->mode == APP_MODE_MX ||
+           app->mode == APP_MODE_PREFIX ||
+           app->mode == APP_MODE_PROMPT ||
+           app->mode == APP_MODE_ISEARCH ||
+           app->message[0] != '\0';
+}
+
+static size_t visible_row_count_for_rect(app_t *app, view_rect_t r) {
+    ui_metrics_t m = ui_metrics(app);
+    float usable = r.h - m.content_top - m.content_bottom_pad;
+
+    if (usable <= app->font.line_height || app->font.line_height <= 1.0f) {
+        return 1;
+    }
+
+    size_t rows = (size_t)(usable / app->font.line_height);
+    return rows ? rows : 1;
+}
+
+static float gutter_width(app_t *app, buffer_t *buf) {
+    if (!app || !app->ed || !buf || !app->ed->theme.line_numbers_enabled) return 0.0f;
+    char tmp[32];
+    snprintf(tmp, sizeof(tmp), "%zu ", buffer_line_count(buf));
+    return text_width(&app->font, tmp) + ui_metrics(app).pad_x * 0.5f;
+}
+
+static size_t visible_col_count_for_rect(app_t *app, view_rect_t r) {
+    ui_metrics_t m = ui_metrics(app);
+    float cell = mono_cell_width(app);
+    buffer_t *buf = ecex_current_buffer(app->ed);
+    float width = r.w - m.content_x * 2.0f - gutter_width(app, buf);
+
+    if (width <= cell) return 1;
+    return (size_t)(width / cell);
+}
+
+static size_t offset_for_line(buffer_t *buf, size_t target_line) {
+    if (!buf || target_line == 0) return 0;
+
+    size_t line = 0;
+    for (size_t i = 0; i < buf->len; i++) {
+        if (buf->data[i] == '\n') {
+            line++;
+            if (line == target_line) {
+                return i + 1;
+            }
+        }
+    }
+
+    return buf->len;
+}
+
+static void ensure_cursor_visible(app_t *app, buffer_t *buf, view_rect_t rect) {
+    if (!app || !buf) return;
+
+    size_t rows = visible_row_count_for_rect(app, rect);
+    size_t cols = visible_col_count_for_rect(app, rect);
+
+    size_t cursor_line = buffer_current_line_number(buf);
+    if (cursor_line > 0) cursor_line--;
+
+    size_t cursor_col = buffer_current_column(buf);
+
+    if (cursor_line < buf->scroll_line) {
+        buf->scroll_line = cursor_line;
+    } else if (cursor_line >= buf->scroll_line + rows) {
+        buf->scroll_line = cursor_line - rows + 1;
+    }
+
+    if (cursor_col < buf->scroll_col) {
+        buf->scroll_col = cursor_col;
+    } else if (cursor_col >= buf->scroll_col + cols) {
+        buf->scroll_col = cursor_col - cols + 1;
+    }
+}
+
+static void render_status_bar(app_t *app) {
+    buffer_t *buf = ecex_current_buffer(app->ed);
+    if (!buf) return;
+
+    ui_metrics_t m = ui_metrics(app);
+    float y = (float)app->height - m.status_h;
+    float text_x = m.pad_x;
+    float text_y = line_baseline(app, y + m.pad_y);
+
+    glDisable(GL_TEXTURE_2D);
+
+    glColor3f(app->ed->theme.status_bg.r,
+              app->ed->theme.status_bg.g,
+              app->ed->theme.status_bg.b);
+    draw_rect(0.0f, y, (float)app->width, m.status_h);
+
+    glColor3f(app->ed->theme.status_border.r,
+              app->ed->theme.status_border.g,
+              app->ed->theme.status_border.b);
+    draw_rect(0.0f, y, (float)app->width, 1.0f);
+
+    char status[768];
+    snprintf(status,
+             sizeof(status),
+             " %s%s   %s   line:%zu col:%zu   top:%zu   size:%zu   buffers:%zu   windows:%zu   commands:%zu%s%s",
+             buf->name ? buf->name : "(unnamed)",
+             buf->modified ? " *" : "",
+             ecex_buffer_major_mode_name(app->ed, buf),
+             buffer_current_line_number(buf),
+             buffer_current_column(buf),
+             buf->scroll_line + 1,
+             buf->len,
+             app->ed->buffer_count,
+             ecex_window_count(app->ed),
+             app->ed->command_count,
+             buf->path ? "   " : "",
+             buf->path ? buf->path : "");
+
+    glColor3f(app->ed->theme.status_fg.r,
+              app->ed->theme.status_fg.g,
+              app->ed->theme.status_fg.b);
+    draw_text(&app->font, text_x, text_y, status);
+}
+
+static void render_command_completion(app_t *app,
+                                      const char *line,
+                                      float x,
+                                      float y) {
+    const char *completion = ecex_complete_command(app->ed, app->minibuffer);
+    if (!completion || !completion[0]) return;
+
+    size_t input_len = strlen(app->minibuffer);
+    if (input_len == 0) return;
+
+    float ghost_x = x + text_width(&app->font, line);
+
+    glColor3f(app->ed->theme.completion_fg.r,
+              app->ed->theme.completion_fg.g,
+              app->ed->theme.completion_fg.b);
+
+    if (strncmp(completion, app->minibuffer, input_len) == 0 &&
+        completion[input_len] != '\0') {
+        draw_text(&app->font, ghost_x, y, completion + input_len);
+    } else if (strcmp(completion, app->minibuffer) != 0) {
+        char hint[ECEX_MINIBUFFER_SIZE + 16];
+        snprintf(hint, sizeof(hint), "  -> %s", completion);
+        draw_text(&app->font, ghost_x, y, hint);
+    }
+}
+
+static void render_minibuffer(app_t *app) {
+    if (!minibuffer_visible(app)) {
+        return;
+    }
+
+    ui_metrics_t m = ui_metrics(app);
+    float h = m.minibuffer_h;
+    float y = (float)app->height - m.status_h - h;
+    float text_x = m.pad_x;
+    float text_y = line_baseline(app, y + m.pad_y);
+
+    glDisable(GL_TEXTURE_2D);
+
+    glColor3f(app->ed->theme.minibuffer_bg.r,
+              app->ed->theme.minibuffer_bg.g,
+              app->ed->theme.minibuffer_bg.b);
+    draw_rect(0.0f, y, (float)app->width, h);
+
+    glColor3f(app->ed->theme.minibuffer_fg.r,
+              app->ed->theme.minibuffer_fg.g,
+              app->ed->theme.minibuffer_fg.b);
+
+    if (app->mode == APP_MODE_ISEARCH) {
+        char line[ECEX_MINIBUFFER_SIZE + 64];
+        snprintf(line,
+                 sizeof(line),
+                 "%s%s%s",
+                 app->isearch_backward ? "I-search backward: " : "I-search: ",
+                 app->isearch_query,
+                 app->isearch_has_match || app->isearch_len == 0 ? "" : " [failing]");
+        draw_text(&app->font, text_x, text_y, line);
+    } else if (app->mode == APP_MODE_MX) {
+        char line[ECEX_MINIBUFFER_SIZE + 8];
+        snprintf(line, sizeof(line), "M-x %s", app->minibuffer);
+
+        draw_text(&app->font, text_x, text_y, line);
+        render_command_completion(app, line, text_x, text_y);
+    } else if (app->mode == APP_MODE_PROMPT) {
+        char line[1200];
+        snprintf(line,
+                 sizeof(line),
+                 "%s%s",
+                 app->prompt_label,
+                 app->prompt_input);
+        draw_text(&app->font, text_x, text_y, line);
+
+        if (app->prompt_completion_active && app->prompt_completion_count > 0) {
+            char hint[128];
+            snprintf(hint,
+                     sizeof(hint),
+                     "  [%zu/%zu]",
+                     app->prompt_completion_index + 1,
+                     app->prompt_completion_count);
+
+            glColor3f(app->ed->theme.completion_fg.r,
+                      app->ed->theme.completion_fg.g,
+                      app->ed->theme.completion_fg.b);
+            draw_text(&app->font,
+                      text_x + text_width(&app->font, line),
+                      text_y,
+                      hint);
+
+            if (app->prompt_completion_preview_count > 0) {
+                float row_h = app->font.line_height;
+                float popup_pad = m.pad_y;
+                float popup_h = row_h * (float)app->prompt_completion_preview_count + popup_pad * 2.0f;
+                float popup_y = y - popup_h;
+
+                glDisable(GL_TEXTURE_2D);
+                glColor3f(app->ed->theme.minibuffer_bg.r,
+                          app->ed->theme.minibuffer_bg.g,
+                          app->ed->theme.minibuffer_bg.b);
+                draw_rect(0.0f, popup_y, (float)app->width, popup_h);
+
+                for (size_t i = 0; i < app->prompt_completion_preview_count; i++) {
+                    size_t absolute = app->prompt_completion_preview_start + i;
+                    char row[1100];
+                    snprintf(row,
+                             sizeof(row),
+                             "%c %s",
+                             absolute == app->prompt_completion_index ? '>' : ' ',
+                             app->prompt_completion_preview[i]);
+
+                    if (absolute == app->prompt_completion_index) {
+                        glColor3f(app->ed->theme.minibuffer_fg.r,
+                                  app->ed->theme.minibuffer_fg.g,
+                                  app->ed->theme.minibuffer_fg.b);
+                    } else {
+                        glColor3f(app->ed->theme.completion_fg.r,
+                                  app->ed->theme.completion_fg.g,
+                                  app->ed->theme.completion_fg.b);
+                    }
+
+                    draw_text(&app->font,
+                              text_x,
+                              line_baseline(app, popup_y + popup_pad + row_h * (float)i),
+                              row);
+                }
+            }
+        }
+    } else if (app->mode == APP_MODE_PREFIX) {
+        char line[ECEX_PREFIX_SIZE + 8];
+        snprintf(line, sizeof(line), "%s-", app->prefix);
+        draw_text(&app->font, text_x, text_y, line);
+    } else {
+        draw_text(&app->font, text_x, text_y, app->message);
+    }
+}
+
+static int should_highlight_interactive_line(buffer_t *buf, size_t zero_based_line) {
+    if (!buf || !buffer_is_interactive(buf)) return 0;
+
+    size_t current_line = buffer_current_line_number(buf);
+    if (current_line > 0) current_line--;
+
+    return current_line == zero_based_line;
+}
+
+static void set_editor_text_color(app_t *app, int highlighted) {
+    if (highlighted) {
+        glColor3f(app->ed->theme.interactive_highlight_fg.r,
+                  app->ed->theme.interactive_highlight_fg.g,
+                  app->ed->theme.interactive_highlight_fg.b);
+    } else {
+        glColor3f(app->ed->theme.fg.r,
+                  app->ed->theme.fg.g,
+                  app->ed->theme.fg.b);
+    }
+}
+
+static float text_width_range(app_t *app, buffer_t *buf, size_t start, size_t end) {
+    char *text = buffer_substring(buf, start, end);
+    if (!text) return 0.0f;
+
+    float width = text_width(&app->font, text);
+    free(text);
+    return width;
+}
+
+static void draw_selection_for_line(app_t *app,
+                                    buffer_t *buf,
+                                    view_rect_t rect,
+                                    size_t visible_start,
+                                    size_t line_end,
+                                    float line_top) {
+    if (!buffer_has_selection(buf)) return;
+
+    size_t sel_start = 0;
+    size_t sel_end = 0;
+    buffer_selection_range(buf, &sel_start, &sel_end);
+
+    if (sel_end <= visible_start || sel_start > line_end) return;
+
+    size_t draw_start = ECEX_MAX(sel_start, visible_start);
+    size_t draw_end = ECEX_MIN(sel_end, line_end);
+
+    float x = rect.x + ui_metrics(app).content_x + gutter_width(app, buf) + text_width_range(app, buf, visible_start, draw_start);
+    float w = text_width_range(app, buf, draw_start, draw_end);
+
+    /* If the selection contains only this line's newline, show a visible sliver
+     * at end-of-line instead of making the active region appear to vanish. */
+    if (w < 1.0f && sel_end > line_end && draw_start == line_end) {
+        w = mono_cell_width(app) * 0.5f;
+    }
+
+    if (w < 1.0f) return;
+
+    glDisable(GL_TEXTURE_2D);
+    glColor3f(app->ed->theme.region_bg.r,
+              app->ed->theme.region_bg.g,
+              app->ed->theme.region_bg.b);
+    draw_rect(x, line_top, w, app->font.line_height);
+}
+
+static void draw_buffer_line(app_t *app,
+                             buffer_t *buf,
+                             view_rect_t rect,
+                             size_t zero_based_line,
+                             size_t line_start,
+                             size_t line_end,
+                             float line_top) {
+    if (line_start > line_end) return;
+
+    ui_metrics_t m = ui_metrics(app);
+    int highlighted = should_highlight_interactive_line(buf, zero_based_line);
+    size_t current_zero = buffer_current_line_number(buf);
+    if (current_zero > 0) current_zero--;
+
+    if (app->ed->theme.current_line_enabled && current_zero == zero_based_line) {
+        glDisable(GL_TEXTURE_2D);
+        glColor3f(app->ed->theme.current_line_bg.r,
+                  app->ed->theme.current_line_bg.g,
+                  app->ed->theme.current_line_bg.b);
+        draw_rect(rect.x, line_top, rect.w, app->font.line_height);
+    }
+
+    if (highlighted) {
+        glDisable(GL_TEXTURE_2D);
+        glColor3f(app->ed->theme.interactive_highlight_bg.r,
+                  app->ed->theme.interactive_highlight_bg.g,
+                  app->ed->theme.interactive_highlight_bg.b);
+        draw_rect(rect.x,
+                  line_top,
+                  rect.w,
+                  app->font.line_height);
+    }
+
+    size_t line_len = line_end - line_start;
+    size_t col = ECEX_MIN(buf->scroll_col, line_len);
+    size_t start = line_start + col;
+
+    draw_selection_for_line(app, buf, rect, start, line_end, line_top);
+
+    float gutter = gutter_width(app, buf);
+    if (gutter > 0.0f) {
+        char nbuf[32];
+        snprintf(nbuf, sizeof(nbuf), "%zu", zero_based_line + 1);
+        glColor3f(app->ed->theme.completion_fg.r,
+                  app->ed->theme.completion_fg.g,
+                  app->ed->theme.completion_fg.b);
+        draw_text(&app->font, rect.x + m.pad_x * 0.5f, line_baseline(app, line_top), nbuf);
+    }
+
+    char *line = buffer_substring(buf, start, line_end);
+    if (!line) return;
+
+    set_editor_text_color(app, highlighted);
+    draw_text(&app->font, rect.x + m.content_x + gutter, line_baseline(app, line_top), line);
+    free(line);
+}
+
+static void render_cursor(app_t *app, buffer_t *buf, view_rect_t rect) {
+    ui_metrics_t m = ui_metrics(app);
+
+    size_t cursor_line = buffer_current_line_number(buf);
+    if (cursor_line > 0) cursor_line--;
+
+    if (cursor_line < buf->scroll_line) return;
+
+    size_t visible_row = cursor_line - buf->scroll_line;
+    if (visible_row >= visible_row_count_for_rect(app, rect)) return;
+
+    size_t line_start = buffer_current_line_start(buf);
+    size_t cursor_col = buffer_current_column(buf);
+
+    size_t visible_start = line_start + ECEX_MIN(buf->scroll_col, cursor_col);
+    char *prefix = buffer_substring(buf, visible_start, buf->point);
+    float x = rect.x + m.content_x + gutter_width(app, buf) + (prefix ? text_width(&app->font, prefix) : 0.0f);
+    float line_top = rect.y + m.content_top + (float)visible_row * app->font.line_height;
+    float cursor_top = line_top + (app->font.line_height - m.cursor_h) * 0.5f;
+
+    free(prefix);
+
+    glDisable(GL_TEXTURE_2D);
+    glColor3f(app->ed->theme.cursor.r,
+              app->ed->theme.cursor.g,
+              app->ed->theme.cursor.b);
+    draw_rect(x, cursor_top, m.cursor_w, m.cursor_h);
+}
+
+static void draw_window_border(app_t *app, view_rect_t rect, int active) {
+    glDisable(GL_TEXTURE_2D);
+
+    if (active) {
+        glColor3f(app->ed->theme.cursor.r,
+                  app->ed->theme.cursor.g,
+                  app->ed->theme.cursor.b);
+    } else {
+        glColor3f(app->ed->theme.status_border.r,
+                  app->ed->theme.status_border.g,
+                  app->ed->theme.status_border.b);
+    }
+
+    draw_rect(rect.x, rect.y, rect.w, 1.0f);
+    draw_rect(rect.x, rect.y + rect.h - 1.0f, rect.w, 1.0f);
+    draw_rect(rect.x, rect.y, 1.0f, rect.h);
+    draw_rect(rect.x + rect.w - 1.0f, rect.y, 1.0f, rect.h);
+}
+
+static void render_buffer_window(app_t *app, ecex_window_t *win, size_t index, float editor_h) {
+    if (!app || !win || !win->buffer) return;
+
+    view_rect_t rect;
+    rect.x = win->x * (float)app->width;
+    rect.y = win->y * editor_h;
+    rect.w = win->w * (float)app->width;
+    rect.h = win->h * editor_h;
+
+    if (rect.w < 2.0f || rect.h < 2.0f) return;
+
+    buffer_t *buf = win->buffer;
+    ui_metrics_t m = ui_metrics(app);
+
+    int sx = (int)rect.x;
+    int sy = app->height - (int)(rect.y + rect.h);
+    int sw = (int)rect.w;
+    int sh = (int)rect.h;
+    if (sw < 1 || sh < 1) return;
+
+    glEnable(GL_SCISSOR_TEST);
+    glScissor(sx, sy, sw, sh);
+
+    if (index == app->ed->current_window_index) {
+        ensure_cursor_visible(app, buf, rect);
+    }
+
+    size_t rows = visible_row_count_for_rect(app, rect);
+    size_t pos = offset_for_line(buf, buf->scroll_line);
+    float line_top = rect.y + m.content_top;
+
+    for (size_t row = 0; row < rows; row++) {
+        size_t line_start = pos;
+        size_t line_end = buffer_line_end_at(buf, line_start);
+
+        draw_buffer_line(app,
+                         buf,
+                         rect,
+                         buf->scroll_line + row,
+                         line_start,
+                         line_end,
+                         line_top);
+
+        if (line_end >= buf->len) break;
+        pos = line_end + 1;
+        line_top += app->font.line_height;
+    }
+
+    if (index == app->ed->current_window_index) {
+        render_cursor(app, buf, rect);
+    }
+
+    glDisable(GL_SCISSOR_TEST);
+    draw_window_border(app, rect, index == app->ed->current_window_index);
+}
+
+static void render_windows(app_t *app) {
+    ui_metrics_t m = ui_metrics(app);
+    float editor_h = (float)app->height - m.status_h;
+    if (minibuffer_visible(app)) editor_h -= m.minibuffer_h;
+    if (editor_h < 1.0f) editor_h = 1.0f;
+
+    if (app->ed->window_count == 0) return;
+
+    for (size_t i = 0; i < app->ed->window_count; i++) {
+        render_buffer_window(app, &app->ed->windows[i], i, editor_h);
+    }
+}
+
+void render(app_t *app) {
+    if (!app || !app->window || !app->ed) return;
+
+    glfwGetFramebufferSize(app->window, &app->width, &app->height);
+
+    setup_2d(app->width, app->height);
+
+    glClearColor(app->ed->theme.bg.r,
+                 app->ed->theme.bg.g,
+                 app->ed->theme.bg.b,
+                 1.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    render_windows(app);
+    render_minibuffer(app);
+    render_status_bar(app);
+}
diff --git a/src/util.c b/src/util.c
new file mode 100644
index 0000000..feb3c0e
--- /dev/null
+++ b/src/util.c
@@ -0,0 +1,71 @@
+#include "util.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int ecex_file_exists(const char *path) {
+    if (!path || !path[0]) return 0;
+
+    FILE *file = fopen(path, "rb");
+    if (!file) return 0;
+
+    fclose(file);
+    return 1;
+}
+
+char *ecex_read_entire_file(const char *path, size_t *out_size) {
+    FILE *file = fopen(path, "rb");
+    if (!file) return NULL;
+
+    if (fseek(file, 0, SEEK_END) != 0) {
+        fclose(file);
+        return NULL;
+    }
+
+    long size = ftell(file);
+    if (size < 0) {
+        fclose(file);
+        return NULL;
+    }
+
+    rewind(file);
+
+    char *data = malloc((size_t)size + 1);
+    if (!data) {
+        fclose(file);
+        return NULL;
+    }
+
+    size_t read_count = fread(data, 1, (size_t)size, file);
+    fclose(file);
+
+    if (read_count != (size_t)size) {
+        free(data);
+        return NULL;
+    }
+
+    data[size] = '\0';
+
+    if (out_size) {
+        *out_size = (size_t)size;
+    }
+
+    return data;
+}
+
+
+char *ecex_strdup(const char *s) {
+    if (!s) return NULL;
+
+    size_t len = 0;
+    while (s[len]) len++;
+
+    char *out = malloc(len + 1);
+    if (!out) return NULL;
+
+    for (size_t i = 0; i <= len; i++) {
+        out[i] = s[i];
+    }
+
+    return out;
+}