WIP LSP client

This contains the start of an LSP client.
Nothing (except starting the LSP server) works
at the moment and the feature is disabled by default.

49 files changed, 1447 insertions, 477 deletions

diff --git a/src/dged/binding.c b/src/dged/binding.c
index 5111548..636e694 100644
--- a/src/dged/binding.c
+++ b/src/dged/binding.c
@@ -50,21 +50,22 @@ struct lookup_result lookup_key(struct keymap *keymaps, uint32_t nkeymaps,
           return (struct lookup_result){
               .found = true,
               .type = BindingType_Command,
-              .command = lookup_command_by_hash(commands, binding->command),
+              .data.command =
+                  lookup_command_by_hash(commands, binding->data.command),
           };
         }
         case BindingType_Keymap: {
           return (struct lookup_result){
               .found = true,
               .type = BindingType_Keymap,
-              .keymap = binding->keymap,
+              .data.keymap = binding->data.keymap,
           };
         }
         case BindingType_DirectCommand:
           return (struct lookup_result){
               .found = true,
               .type = BindingType_Command,
-              .command = binding->direct_command,
+              .data.command = binding->data.direct_command,
           };
         }
       }
diff --git a/src/dged/binding.h b/src/dged/binding.h
index 79f8c47..93de02d 100644
--- a/src/dged/binding.h
+++ b/src/dged/binding.h
@@ -37,19 +37,19 @@ enum binding_type {
 #define BINDING_INNER(mod_, c_, command_)                                      \
   (struct binding) {                                                           \
     .key = {.mod = mod_, .key = c_}, .type = BindingType_Command,              \
-    .command = hash_name(command_)                                             \
+    .data.command = hash_name(command_)                                        \
   }
 
 #define ANONYMOUS_BINDING_INNER(mod_, c_, command_)                            \
   (struct binding) {                                                           \
     .key = {.mod = mod_, .key = c_}, .type = BindingType_DirectCommand,        \
-    .direct_command = command_                                                 \
+    .data.direct_command = command_                                            \
   }
 
 #define PREFIX_INNER(mod_, c_, keymap_)                                        \
   (struct binding) {                                                           \
     .key = {.mod = mod_, .key = c_}, .type = BindingType_Keymap,               \
-    .keymap = keymap_                                                          \
+    .data.keymap = keymap_                                                     \
   }
 
 /**
@@ -89,14 +89,14 @@ struct binding {
   /** Type of this binding, see @ref binding_type */
   uint8_t type;
 
-  union {
+  union binding_data {
     /** A hash of a command name */
     uint32_t command;
     /** A command */
     struct command *direct_command;
     /** A keymap */
     struct keymap *keymap;
-  };
+  } data;
 };
 
 /**
@@ -109,12 +109,12 @@ struct lookup_result {
   /** Type of binding in the result */
   uint8_t type;
 
-  union {
+  union lookup_data {
     /** A command */
     struct command *command;
     /** A keymap */
     struct keymap *keymap;
-  };
+  } data;
 };
 
 struct commands;
diff --git a/src/dged/buffer.c b/src/dged/buffer.c
index 1062a47..c537fb3 100644
--- a/src/dged/buffer.c
+++ b/src/dged/buffer.c
@@ -31,7 +31,7 @@ static struct kill_ring {
   uint32_t curr_idx;
   uint32_t paste_idx;
 } g_kill_ring = {.curr_idx = 0,
-                 .buffer = {0},
+                 .buffer = {{0}},
                  .last_paste = {0},
                  .paste_idx = 0,
                  .paste_up_to_date = false};
@@ -58,7 +58,7 @@ static struct kill_ring {
                                                                                \
   static void remove_##name##_hook(vec_type *hooks, uint32_t id,               \
                                    remove_hook_cb callback) {                  \
-    uint64_t found_at = -1;                                                    \
+    uint64_t found_at = (uint64_t)-1;                                          \
     VEC_FOR_EACH_INDEXED(hooks, struct name##_hook *h, idx) {                  \
       if (h->id == id) {                                                       \
         if (callback != NULL) {                                                \
@@ -68,11 +68,12 @@ static struct kill_ring {
         break;                                                                 \
       }                                                                        \
     }                                                                          \
-    if (found_at != -1) {                                                      \
+    if (found_at != (uint64_t)-1) {                                            \
       if (found_at < VEC_SIZE(hooks) - 1) {                                    \
         VEC_SWAP(hooks, found_at, VEC_SIZE(hooks) - 1);                        \
       }                                                                        \
       VEC_POP(hooks, struct name##_hook removed);                              \
+      (void)removed;                                                           \
     }                                                                          \
   }
 
@@ -84,13 +85,13 @@ typedef VEC(struct reload_hook) reload_hook_vec;
 typedef VEC(struct delete_hook) delete_hook_vec;
 typedef VEC(struct render_hook) render_hook_vec;
 
-DECLARE_HOOK(create, create_hook_cb, create_hook_vec);
-DECLARE_HOOK(destroy, destroy_hook_cb, destroy_hook_vec);
-DECLARE_HOOK(insert, insert_hook_cb, insert_hook_vec);
-DECLARE_HOOK(update, update_hook_cb, update_hook_vec);
-DECLARE_HOOK(reload, reload_hook_cb, reload_hook_vec);
-DECLARE_HOOK(render, render_hook_cb, render_hook_vec);
-DECLARE_HOOK(delete, delete_hook_cb, delete_hook_vec);
+DECLARE_HOOK(create, create_hook_cb, create_hook_vec)
+DECLARE_HOOK(destroy, destroy_hook_cb, destroy_hook_vec)
+DECLARE_HOOK(insert, insert_hook_cb, insert_hook_vec)
+DECLARE_HOOK(update, update_hook_cb, update_hook_vec)
+DECLARE_HOOK(reload, reload_hook_cb, reload_hook_vec)
+DECLARE_HOOK(render, render_hook_cb, render_hook_vec)
+DECLARE_HOOK(delete, delete_hook_cb, delete_hook_vec)
 
 static create_hook_vec g_create_hooks;
 uint32_t g_create_hook_id;
@@ -136,19 +137,19 @@ void buffer_remove_destroy_hook(struct buffer *buffer, uint32_t hook_id,
   remove_destroy_hook(&buffer->hooks->destroy_hooks, hook_id, callback);
 }
 
-void buffer_static_init() {
+void buffer_static_init(void) {
   VEC_INIT(&g_create_hooks, 8);
 
   settings_set_default(
       "editor.tab-width",
-      (struct setting_value){.type = Setting_Number, .number_value = 4});
+      (struct setting_value){.type = Setting_Number, .data.number_value = 4});
 
   settings_set_default(
       "editor.show-whitespace",
-      (struct setting_value){.type = Setting_Bool, .bool_value = true});
+      (struct setting_value){.type = Setting_Bool, .data.bool_value = true});
 }
 
-void buffer_static_teardown() {
+void buffer_static_teardown(void) {
   VEC_DESTROY(&g_create_hooks);
   for (uint32_t i = 0; i < KILL_RING_SZ; ++i) {
     if (g_kill_ring.buffer[i].allocated) {
@@ -165,7 +166,7 @@ static uint32_t get_tab_width(struct buffer *buffer) {
 
   uint32_t tab_width = 4;
   if (tw != NULL && tw->value.type == Setting_Number) {
-    tab_width = tw->value.number_value;
+    tab_width = tw->value.data.number_value;
   }
   return tab_width;
 }
@@ -178,7 +179,7 @@ static bool use_tabs(struct buffer *buffer) {
 
   bool use_tabs = false;
   if (ut != NULL && ut->value.type == Setting_Bool) {
-    use_tabs = ut->value.bool_value;
+    use_tabs = ut->value.data.bool_value;
   }
 
   return use_tabs;
@@ -664,14 +665,14 @@ struct location buffer_previous_word(struct buffer *buffer,
 
 struct location buffer_previous_line(struct buffer *buffer,
                                      struct location dot) {
-  if (dot.line == 0) {
+  (void)buffer;
+
+  if (dot.line <= 0) {
+    dot.line = 0;
     return dot;
   }
 
   --dot.line;
-  uint32_t nchars = buffer_line_length(buffer, dot.line);
-  uint32_t new_col = dot.col > nchars ? nchars : dot.col;
-
   return dot;
 }
 
@@ -842,7 +843,7 @@ struct location buffer_undo(struct buffer *buffer, struct location dot) {
     switch (rec->type) {
 
     case Undo_Boundary: {
-      struct undo_boundary *b = &rec->boundary;
+      struct undo_boundary *b = &rec->data.boundary;
       if (b->save_point) {
         buffer->modified = false;
       }
@@ -850,7 +851,7 @@ struct location buffer_undo(struct buffer *buffer, struct location dot) {
     }
 
     case Undo_Add: {
-      struct undo_add *add = &rec->add;
+      struct undo_add *add = &rec->data.add;
 
       pos = buffer_delete(buffer,
                           (struct region){
@@ -864,7 +865,7 @@ struct location buffer_undo(struct buffer *buffer, struct location dot) {
     }
 
     case Undo_Delete: {
-      struct undo_delete *del = &rec->delete;
+      struct undo_delete *del = &rec->data.delete;
       pos = buffer_add(buffer,
                        (struct location){
                            .line = del->pos.row,
@@ -934,7 +935,7 @@ void buffer_find(struct buffer *buffer, const char *pattern,
 
 struct location buffer_copy(struct buffer *buffer, struct region region) {
   if (region_has_size(region)) {
-    struct text_chunk *curr = copy_region(buffer, region);
+    copy_region(buffer, region);
   }
 
   return region.begin;
@@ -1024,7 +1025,6 @@ struct location buffer_paste_older(struct buffer *buffer, struct location at) {
   if (g_kill_ring.paste_up_to_date) {
 
     // remove previous paste
-    struct text_chunk *curr = &g_kill_ring.buffer[g_kill_ring.curr_idx];
     buffer_delete(buffer, region_new(g_kill_ring.last_paste, at));
 
     // paste older
@@ -1124,7 +1124,7 @@ static void apply_properties(struct command_list *cmds,
 
     switch (prop->type) {
     case TextProperty_Colors: {
-      struct text_property_colors *colors = &prop->colors;
+      struct text_property_colors *colors = &prop->data.colors;
       if (colors->set_bg) {
         command_list_set_index_color_bg(cmds, colors->bg);
       }
@@ -1221,7 +1221,7 @@ void render_line(struct text_chunk *line, void *userdata) {
   }
 }
 
-void buffer_update(struct buffer *buffer, struct buffer_update_params *params) {
+void buffer_update(struct buffer *buffer) {
   VEC_FOR_EACH(&buffer->hooks->update_hooks, struct update_hook * h) {
     h->callback(buffer, h->userdata);
   }
@@ -1244,7 +1244,7 @@ void buffer_render(struct buffer *buffer, struct buffer_render_params *params) {
       .origin = params->origin,
       .width = params->width,
       .height = params->height,
-      .show_ws = (show_ws != NULL ? show_ws->value.bool_value : true) &&
+      .show_ws = (show_ws != NULL ? show_ws->value.data.bool_value : true) &&
                  !buffer->force_show_ws_off,
       .buffer = buffer,
   };
diff --git a/src/dged/buffer.h b/src/dged/buffer.h
index c9fe2ca..0e45b98 100644
--- a/src/dged/buffer.h
+++ b/src/dged/buffer.h
@@ -65,8 +65,8 @@ struct buffer {
   bool force_show_ws_off;
 };
 
-void buffer_static_init();
-void buffer_static_teardown();
+void buffer_static_init(void);
+void buffer_static_teardown(void);
 
 /**
  * Create a new buffer.
@@ -690,11 +690,6 @@ uint32_t buffer_add_create_hook(create_hook_cb callback, void *userdata);
 void buffer_remove_create_hook(uint32_t hook_id, remove_hook_cb callback);
 
 /**
- * Parameters for updating a buffer.
- */
-struct buffer_update_params {};
-
-/**
  * Parameters for rendering a buffer.
  */
 struct buffer_render_params {
@@ -716,11 +711,8 @@ struct buffer_render_params {
  * Update a buffer.
  *
  * @param [in] buffer The buffer to update.
- * @param [inout] params The parameters for the update. The @ref commands field
- * in @p params will be modified with the rendering commands needed for this
- * buffer.
  */
-void buffer_update(struct buffer *buffer, struct buffer_update_params *params);
+void buffer_update(struct buffer *buffer);
 
 /**
  * Render a buffer.
diff --git a/src/dged/buffer_view.c b/src/dged/buffer_view.c
index f3dd2b9..0c587a6 100644
--- a/src/dged/buffer_view.c
+++ b/src/dged/buffer_view.c
@@ -386,8 +386,7 @@ void buffer_view_update(struct buffer_view *view,
 
   struct timer *buffer_update_timer =
       timer_start("update-windows.buffer-update");
-  struct buffer_update_params update_params = {};
-  buffer_update(view->buffer, &update_params);
+  buffer_update(view->buffer);
   timer_stop(buffer_update_timer);
 
   uint32_t height = params->height;
@@ -446,7 +445,7 @@ void buffer_view_update(struct buffer_view *view,
       buffer_add_text_property(view->buffer, reg.begin, reg.end,
                                (struct text_property){
                                    .type = TextProperty_Colors,
-                                   .colors =
+                                   .data.colors =
                                        (struct text_property_colors){
                                            .set_bg = true,
                                            .bg = 5,
diff --git a/src/dged/command.c b/src/dged/command.c
index 2775286..5f2551f 100644
--- a/src/dged/command.c
+++ b/src/dged/command.c
@@ -79,7 +79,7 @@ void command_ctx_push_arg(struct command_ctx *ctx, const char *argv) {
 }
 
 void command_ctx_free(struct command_ctx *ctx) {
-  for (uint32_t i = 0; i < ctx->saved_argc; ++i) {
+  for (uint32_t i = 0; i < (uint32_t)ctx->saved_argc; ++i) {
     free((char *)ctx->saved_argv[i]);
   }
 
diff --git a/src/dged/display.c b/src/dged/display.c
index ea3f459..0c3c47c 100644
--- a/src/dged/display.c
+++ b/src/dged/display.c
@@ -35,13 +35,13 @@ enum render_cmd_type {
 
 struct render_command {
   enum render_cmd_type type;
-  union {
+  union render_cmd_data {
     struct draw_text_cmd *draw_txt;
     struct push_fmt_cmd *push_fmt;
     struct repeat_cmd *repeat;
     struct show_ws_cmd *show_ws;
     struct draw_list_cmd *draw_list;
-  };
+  } data;
 };
 
 struct draw_text_cmd {
@@ -87,13 +87,13 @@ struct command_list {
   struct command_list *next_list;
 };
 
-struct winsize getsize() {
+struct winsize getsize(void) {
   struct winsize ws;
   ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws);
   return ws;
 }
 
-struct display *display_create() {
+struct display *display_create(void) {
 
   struct winsize ws = getsize();
 
@@ -182,6 +182,8 @@ void put_ansiparm(int n) {
 }
 
 void display_move_cursor(struct display *display, uint32_t row, uint32_t col) {
+  (void)display;
+
   putc(ESC, stdout);
   putc('[', stdout);
   put_ansiparm(row + 1);
@@ -192,7 +194,6 @@ void display_move_cursor(struct display *display, uint32_t row, uint32_t col) {
 
 void display_clear(struct display *display) {
   display_move_cursor(display, 0, 0);
-  uint8_t bytes[] = {ESC, '[', 'J'};
   putc(ESC, stdout);
   putc('[', stdout);
   putc('J', stdout);
@@ -239,21 +240,21 @@ struct render_command *add_command(struct command_list *list,
   cmd->type = tp;
   switch (tp) {
   case RenderCommand_DrawText:
-    cmd->draw_txt = l->allocator(sizeof(struct draw_text_cmd));
+    cmd->data.draw_txt = l->allocator(sizeof(struct draw_text_cmd));
     break;
   case RenderCommand_Repeat:
-    cmd->repeat = l->allocator(sizeof(struct repeat_cmd));
+    cmd->data.repeat = l->allocator(sizeof(struct repeat_cmd));
     break;
   case RenderCommand_PushFormat:
-    cmd->push_fmt = l->allocator(sizeof(struct push_fmt_cmd));
+    cmd->data.push_fmt = l->allocator(sizeof(struct push_fmt_cmd));
     break;
   case RenderCommand_SetShowWhitespace:
-    cmd->show_ws = l->allocator(sizeof(struct show_ws_cmd));
+    cmd->data.show_ws = l->allocator(sizeof(struct show_ws_cmd));
     break;
   case RenderCommand_ClearFormat:
     break;
   case RenderCommand_DrawList:
-    cmd->draw_list = l->allocator(sizeof(struct draw_list_cmd));
+    cmd->data.draw_list = l->allocator(sizeof(struct draw_list_cmd));
     break;
   default:
     assert(false);
@@ -266,7 +267,7 @@ struct render_command *add_command(struct command_list *list,
 void command_list_draw_text(struct command_list *list, uint32_t col,
                             uint32_t row, uint8_t *data, uint32_t len) {
   struct draw_text_cmd *cmd =
-      add_command(list, RenderCommand_DrawText)->draw_txt;
+      add_command(list, RenderCommand_DrawText)->data.draw_txt;
   cmd->data = data;
   cmd->col = col;
   cmd->row = row;
@@ -283,7 +284,7 @@ void command_list_draw_text_copy(struct command_list *list, uint32_t col,
 
 void command_list_draw_repeated(struct command_list *list, uint32_t col,
                                 uint32_t row, uint32_t c, uint32_t nrepeat) {
-  struct repeat_cmd *cmd = add_command(list, RenderCommand_Repeat)->repeat;
+  struct repeat_cmd *cmd = add_command(list, RenderCommand_Repeat)->data.repeat;
   cmd->col = col;
   cmd->row = row;
   cmd->c = c;
@@ -293,14 +294,14 @@ void command_list_draw_repeated(struct command_list *list, uint32_t col,
 void command_list_draw_command_list(struct command_list *list,
                                     struct command_list *to_draw) {
   struct draw_list_cmd *cmd =
-      add_command(list, RenderCommand_DrawList)->draw_list;
+      add_command(list, RenderCommand_DrawList)->data.draw_list;
   cmd->list = to_draw;
 }
 
 void command_list_set_index_color_fg(struct command_list *list,
                                      uint8_t color_idx) {
   struct push_fmt_cmd *cmd =
-      add_command(list, RenderCommand_PushFormat)->push_fmt;
+      add_command(list, RenderCommand_PushFormat)->data.push_fmt;
 
   if (color_idx < 8) {
     cmd->len = snprintf((char *)cmd->fmt, 64, "%d", 30 + color_idx);
@@ -314,14 +315,14 @@ void command_list_set_index_color_fg(struct command_list *list,
 void command_list_set_color_fg(struct command_list *list, uint8_t red,
                                uint8_t green, uint8_t blue) {
   struct push_fmt_cmd *cmd =
-      add_command(list, RenderCommand_PushFormat)->push_fmt;
+      add_command(list, RenderCommand_PushFormat)->data.push_fmt;
   cmd->len = snprintf((char *)cmd->fmt, 64, "38;2;%d;%d;%d", red, green, blue);
 }
 
 void command_list_set_index_color_bg(struct command_list *list,
                                      uint8_t color_idx) {
   struct push_fmt_cmd *cmd =
-      add_command(list, RenderCommand_PushFormat)->push_fmt;
+      add_command(list, RenderCommand_PushFormat)->data.push_fmt;
   if (color_idx < 8) {
     cmd->len = snprintf((char *)cmd->fmt, 64, "%d", 40 + color_idx);
   } else if (color_idx < 16) {
@@ -334,13 +335,13 @@ void command_list_set_index_color_bg(struct command_list *list,
 void command_list_set_color_bg(struct command_list *list, uint8_t red,
                                uint8_t green, uint8_t blue) {
   struct push_fmt_cmd *cmd =
-      add_command(list, RenderCommand_PushFormat)->push_fmt;
+      add_command(list, RenderCommand_PushFormat)->data.push_fmt;
   cmd->len = snprintf((char *)cmd->fmt, 64, "48;2;%d;%d;%d", red, green, blue);
 }
 
 void command_list_set_inverted_colors(struct command_list *list) {
   struct push_fmt_cmd *cmd =
-      add_command(list, RenderCommand_PushFormat)->push_fmt;
+      add_command(list, RenderCommand_PushFormat)->data.push_fmt;
   cmd->fmt[0] = '7';
   cmd->len = 1;
 }
@@ -350,7 +351,7 @@ void command_list_reset_color(struct command_list *list) {
 }
 
 void command_list_set_show_whitespace(struct command_list *list, bool show) {
-  add_command(list, RenderCommand_SetShowWhitespace)->show_ws->show = show;
+  add_command(list, RenderCommand_SetShowWhitespace)->data.show_ws->show = show;
 }
 
 void display_render(struct display *display,
@@ -374,7 +375,7 @@ void display_render(struct display *display,
       struct render_command *cmd = &cl->cmds[cmdi];
       switch (cmd->type) {
       case RenderCommand_DrawText: {
-        struct draw_text_cmd *txt_cmd = cmd->draw_txt;
+        struct draw_text_cmd *txt_cmd = cmd->data.draw_txt;
         display_move_cursor(display, txt_cmd->row + cl->yoffset,
                             txt_cmd->col + cl->xoffset);
         apply_fmt(fmt_stack, fmt_stack_len);
@@ -384,7 +385,7 @@ void display_render(struct display *display,
       }
 
       case RenderCommand_Repeat: {
-        struct repeat_cmd *repeat_cmd = cmd->repeat;
+        struct repeat_cmd *repeat_cmd = cmd->data.repeat;
         display_move_cursor(display, repeat_cmd->row + cl->yoffset,
                             repeat_cmd->col + cl->xoffset);
         apply_fmt(fmt_stack, fmt_stack_len);
@@ -401,7 +402,7 @@ void display_render(struct display *display,
       }
 
       case RenderCommand_PushFormat: {
-        struct push_fmt_cmd *fmt_cmd = cmd->push_fmt;
+        struct push_fmt_cmd *fmt_cmd = cmd->data.push_fmt;
 
         fmt_stack[fmt_stack_len] = ';';
         ++fmt_stack_len;
@@ -416,11 +417,11 @@ void display_render(struct display *display,
         break;
 
       case RenderCommand_SetShowWhitespace:
-        show_whitespace_state = cmd->show_ws->show;
+        show_whitespace_state = cmd->data.show_ws->show;
         break;
 
       case RenderCommand_DrawList:
-        display_render(display, cmd->draw_list->list);
+        display_render(display, cmd->data.draw_list->list);
         break;
       }
     }
@@ -430,7 +431,7 @@ void display_render(struct display *display,
   timer_stop(render_timer);
 }
 
-void hide_cursor() {
+void hide_cursor(void) {
   putc(ESC, stdout);
   putc('[', stdout);
   putc('?', stdout);
@@ -439,7 +440,7 @@ void hide_cursor() {
   putc('l', stdout);
 }
 
-void show_cursor() {
+void show_cursor(void) {
   putc(ESC, stdout);
   putc('[', stdout);
   putc('?', stdout);
@@ -448,8 +449,13 @@ void show_cursor() {
   putc('h', stdout);
 }
 
-void display_begin_render(struct display *display) { hide_cursor(); }
+void display_begin_render(struct display *display) {
+  (void)display;
+  hide_cursor();
+}
 void display_end_render(struct display *display) {
+  (void)display;
+
   show_cursor();
   fflush(stdout);
 }
diff --git a/src/dged/display.h b/src/dged/display.h
index f9c7ef8..950ab3c 100644
--- a/src/dged/display.h
+++ b/src/dged/display.h
@@ -13,7 +13,7 @@ struct command_list;
  * The only implementation of this is currently a termios one.
  * @returns A pointer to the display.
  */
-struct display *display_create();
+struct display *display_create(void);
 
 /**
  * Resize the display
diff --git a/src/dged/hash.c b/src/dged/hash.c
new file mode 100644
index 0000000..fce61af
--- /dev/null
+++ b/src/dged/hash.c
@@ -0,0 +1,20 @@
+#include "hash.h"
+
+uint32_t hash_name(const char *s) {
+  unsigned long hash = 5381;
+  int c;
+
+  while ((c = *s++))
+    hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
+
+  return hash;
+}
+
+uint32_t hash_name_s8(struct s8 s) {
+  unsigned long hash = 5381;
+
+  for (uint64_t i = 0; i < s.l; ++i)
+    hash = ((hash << 5) + hash) + s.s[i]; /* hash * 33 + c */
+
+  return hash;
+}
diff --git a/src/dged/hash.h b/src/dged/hash.h
index 0fd689b..60b6d6a 100644
--- a/src/dged/hash.h
+++ b/src/dged/hash.h
@@ -1,11 +1,11 @@
+#ifndef _HASH_H
+#define _HASH_H
+
 #include <stdint.h>
 
-static uint32_t hash_name(const char *s) {
-  unsigned long hash = 5381;
-  int c;
+#include "s8.h"
 
-  while ((c = *s++))
-    hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
+uint32_t hash_name(const char *s);
+uint32_t hash_name_s8(struct s8 s);
 
-  return hash;
-}
+#endif
diff --git a/src/dged/hashmap.h b/src/dged/hashmap.h
index 405c193..b8475c7 100644
--- a/src/dged/hashmap.h
+++ b/src/dged/hashmap.h
@@ -66,16 +66,16 @@
   }                                                                            \
   var = res != NULL ? &(res->value) : NULL;
 
-#define HASHMAP_CONTAINS_KEY(map, key)                                         \
-  uint32_t needle = (map)->hash_fn(key);                                       \
+#define HASHMAP_CONTAINS_KEY(map, type, k, var)                                \
+  uint32_t needle = (map)->hash_fn(k);                                         \
   bool exists = false;                                                         \
-  VEC_FOR_EACH((map)->entries, struct pair *pair) {                            \
+  VEC_FOR_EACH(&(map)->entries, type *pair) {                                  \
     if (needle == pair->key) {                                                 \
       exists = true;                                                           \
       break;                                                                   \
     }                                                                          \
   }                                                                            \
-  exists
+  var = exists;
 
 #define HASHMAP_FOR_EACH(map, var) VEC_FOR_EACH_INDEXED(&(map)->entries, var, i)
 
diff --git a/src/dged/json.c b/src/dged/json.c
new file mode 100644
index 0000000..24d5c15
--- /dev/null
+++ b/src/dged/json.c
@@ -0,0 +1,234 @@
+#include "json.h"
+
+#include "hash.h"
+#include "hashmap.h"
+#include "utf8.h"
+#include "vec.h"
+
+#include <stddef.h>
+#include <stdio.h>
+
+HASHMAP_ENTRY_TYPE(json_object_member, struct json_value);
+
+struct json_object {
+  HASHMAP(struct json_object_member) members;
+};
+
+struct json_array {
+  VEC(struct json_value) values;
+};
+
+static void setarray(struct json_value *val) {
+  val->type = Json_Array;
+  val->value.array = calloc(1, sizeof(struct json_array));
+  VEC_INIT(&val->value.array->values, 10);
+}
+
+static void setobject(struct json_value *val) {
+  val->type = Json_Object;
+  val->value.object = calloc(1, sizeof(struct json_object));
+  HASHMAP_INIT(&val->value.object->members, 10, hash_name);
+}
+
+static void setstring(struct json_value *val, uint8_t *current) {
+  val->type = Json_String;
+  val->value.string.s = current;
+  val->value.string.l = 0;
+}
+
+static bool is_number(uint8_t byte) { return byte >= '0' && byte <= '9'; }
+
+enum object_parse_state {
+  ObjectParseState_Key,
+  ObjectParseState_Value,
+};
+
+struct json_result json_parse(uint8_t *buf, uint64_t size) {
+  struct json_result res = {
+      .ok = true,
+      .result.document.type = Json_Null,
+  };
+
+  struct json_value *parent = NULL;
+  struct json_value *current = &res.result.document;
+  struct json_value tmp_key = {0};
+  struct json_value tmp_val = {0};
+  uint32_t line = 1, col = 0;
+
+  enum object_parse_state obj_parse_state = ObjectParseState_Key;
+  for (uint64_t bufi = 0; bufi < size; ++bufi) {
+    uint8_t byte = buf[bufi];
+
+    // handle appends to the current scope
+    if (current->type == Json_Array) {
+      VEC_PUSH(&current->value.array->values, tmp_val);
+      parent = current;
+
+      // start looking for next value
+      tmp_val.type = Json_Null;
+      current = &tmp_val;
+    } else if (current->type == Json_Object &&
+               obj_parse_state == ObjectParseState_Key) {
+      // key is in tmp_key, start looking for value
+      obj_parse_state = ObjectParseState_Value;
+      parent = current;
+
+      tmp_val.type = Json_Null;
+      current = &tmp_val;
+    } else if (current->type == Json_Object &&
+               obj_parse_state == ObjectParseState_Value) {
+      // value is in tmp_val
+      // TODO: remove this alloc, should not be needed
+      char *k = s8tocstr(tmp_key.value.string);
+      uint32_t hash = 0;
+      HASHMAP_INSERT(&current->value.object->members, struct json_object_member,
+                     k, tmp_val, hash);
+      (void)hash;
+      free(k);
+
+      // start looking for next key
+      obj_parse_state = ObjectParseState_Key;
+      parent = current;
+
+      tmp_key.type = Json_Null;
+      current = &tmp_key;
+    }
+
+    switch (byte) {
+    case '[':
+      setarray(current);
+      parent = current;
+
+      tmp_val.type = Json_Null;
+      current = &tmp_val;
+      break;
+    case ']':
+      current = parent;
+      break;
+    case '{':
+      setobject(current);
+      obj_parse_state = ObjectParseState_Key;
+      parent = current;
+
+      tmp_key.type = Json_Null;
+      current = &tmp_key;
+      break;
+    case '}':
+      current = parent;
+      break;
+    case '"':
+      if (current->type == Json_String) {
+        // finish off the string
+        current->value.string.l = (buf + bufi) - current->value.string.s;
+        current = parent;
+      } else {
+        setstring(current, buf + bufi + 1 /* skip " */);
+      }
+      break;
+    case '\n':
+      ++line;
+      col = 0;
+      break;
+    default:
+      if (current->type == Json_String) {
+        // append to string
+      } else if (current->type == Json_Number &&
+                 !(is_number(byte) || byte == '-' || byte == '.')) {
+        // end of number
+        current->value.string.l = (buf + bufi) - current->value.string.s;
+        char *nmbr = s8tocstr(current->value.string);
+        current->value.number = atof(nmbr);
+        free(nmbr);
+
+        current = parent;
+
+      } else if (current->type == Json_Null &&
+                 (is_number(byte) || byte == '-' || byte == '.')) {
+        // borrow string storage in the value for storing number
+        // as a string
+        setstring(current, buf + bufi);
+        current->type = Json_Number;
+      } else if (byte == 't') {
+        current->type = Json_Bool;
+        current->value.boolean = true;
+
+        current = parent;
+      } else if (byte == 'f') {
+        current->type = Json_Bool;
+        current->value.boolean = false;
+
+        current = parent;
+      } else if (byte == 'n') {
+        current->type = Json_Null;
+
+        current = parent;
+      }
+      break;
+    }
+
+    // TODO: not entirely correct
+    ++col;
+  }
+  return res;
+}
+
+void json_destroy(struct json_value *value) {
+  switch (value->type) {
+  case Json_Array:
+    struct json_array *arr = value->value.array;
+    VEC_FOR_EACH(&arr->values, struct json_value * val) { json_destroy(val); }
+    VEC_DESTROY(&arr->values);
+    break;
+  case Json_Object:
+    struct json_object *obj = value->value.object;
+    HASHMAP_FOR_EACH(&obj->members, struct json_object_member * memb) {
+      json_destroy(&memb->value);
+    }
+
+    HASHMAP_DESTROY(&obj->members);
+  case Json_Null:
+  case Json_Number:
+  case Json_String:
+  case Json_Bool:
+    break;
+  }
+}
+
+uint64_t json_array_len(struct json_array *arr) {
+  return VEC_SIZE(&arr->values);
+}
+
+struct json_value *json_array_get(struct json_array *arr, uint64_t idx) {
+  struct json_value *ret = NULL;
+
+  if (idx <= VEC_SIZE(&arr->values)) {
+    ret = &VEC_ENTRIES(&arr->values)[idx];
+  }
+
+  return ret;
+}
+
+uint64_t json_len(struct json_object *obj) {
+  return HASHMAP_SIZE(&obj->members);
+}
+
+bool json_contains(struct json_object *obj, struct s8 key) {
+  // TODO: get rid of alloc
+  char *k = s8tocstr(key);
+  HASHMAP_CONTAINS_KEY(&obj->members, struct json_object_member, k, bool res);
+
+  free(k);
+
+  return res;
+}
+
+struct json_value *json_get(struct json_object *obj, struct s8 key) {
+  // TODO: get rid of alloc
+  char *k = s8tocstr(key);
+  HASHMAP_GET(&obj->members, struct json_object_member, k,
+              struct json_value * result);
+
+  free(k);
+
+  return result;
+}
diff --git a/src/dged/json.h b/src/dged/json.h
new file mode 100644
index 0000000..c0428b9
--- /dev/null
+++ b/src/dged/json.h
@@ -0,0 +1,54 @@
+#ifndef _JSON_H
+#define _JSON_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include "s8.h"
+
+enum json_type {
+  Json_Array,
+  Json_Object,
+  Json_Null,
+  Json_Number,
+  Json_String,
+  Json_Bool,
+};
+
+struct json_value {
+  enum json_type type;
+  union {
+    struct s8 string;
+    struct json_object *object;
+    struct json_array *array;
+    double number;
+    bool boolean;
+  } value;
+};
+
+struct json_result {
+  bool ok;
+  union {
+    const char *error;
+    struct json_value document;
+  } result;
+};
+
+struct json_writer;
+
+struct json_result json_parse(uint8_t *buf, uint64_t size);
+void json_destroy(struct json_value *value);
+
+uint64_t json_len(struct json_object *obj);
+bool json_contains(struct json_object *obj, struct s8 key);
+struct json_value *json_get(struct json_object *obj, struct s8 key);
+
+uint64_t json_array_len(struct json_array *arr);
+void json_array_foreach(struct json_array *arr,
+                        void (*cb)(uint64_t, struct json_value));
+struct json_value *json_array_get(struct json_array *arr, uint64_t idx);
+
+struct json_writer *json_writer_create();
+struct s8 json_writer_done(struct json_writer *writer);
+
+#endif
diff --git a/src/dged/lang.c b/src/dged/lang.c
index 070b96e..92b4fbd 100644
--- a/src/dged/lang.c
+++ b/src/dged/lang.c
@@ -19,17 +19,19 @@ void define_lang(const char *name, const char *id, const char *pattern,
   _lang_setting_set_default(
       id, "name",
       (struct setting_value){.type = Setting_String,
-                             .string_value = (char *)name});
+                             .data.string_value = (char *)name});
   _lang_setting_set_default(
       id, "pattern",
       (struct setting_value){.type = Setting_String,
-                             .string_value = (char *)pattern});
-  _lang_setting_set_default(id, "tab-width",
-                            (struct setting_value){.type = Setting_Number,
-                                                   .number_value = tab_width});
+                             .data.string_value = (char *)pattern});
+  _lang_setting_set_default(
+      id, "tab-width",
+      (struct setting_value){.type = Setting_Number,
+                             .data.number_value = tab_width});
   _lang_setting_set_default(
       id, "use-tabs",
-      (struct setting_value){.type = Setting_Bool, .bool_value = use_tabs});
+      (struct setting_value){.type = Setting_Bool,
+                             .data.bool_value = use_tabs});
 }
 
 static struct language g_fundamental = {
@@ -65,7 +67,8 @@ bool lang_is_fundamental(const struct language *lang) {
 
 static struct language lang_from_settings(const char *id) {
   struct setting *name = _lang_setting(id, "name");
-  const char *name_value = name != NULL ? name->value.string_value : "Unknown";
+  const char *name_value =
+      name != NULL ? name->value.data.string_value : "Unknown";
 
   return (struct language){
       .id = strdup(id),
@@ -73,21 +76,6 @@ static struct language lang_from_settings(const char *id) {
   };
 }
 
-static void next_ext(const char *curr, const char **nxt, const char **end) {
-  if (curr == NULL) {
-    *nxt = *end = NULL;
-    return;
-  }
-
-  *nxt = curr;
-  *end = curr + strlen(curr);
-
-  const char *spc = strchr(curr, ' ');
-  if (spc != NULL) {
-    *end = spc;
-  }
-}
-
 void lang_settings(struct language *lang, struct setting **settings[],
                    uint32_t *nsettings) {
   const char *key = setting_join_key("languages", lang->id);
@@ -159,7 +147,7 @@ struct language lang_from_filename(const char *filename) {
     struct setting *setting = settings[i];
     char *setting_name = strrchr(setting->path, '.');
     if (setting_name != NULL && strncmp(setting_name + 1, "pattern", 5) == 0) {
-      const char *val = setting->value.string_value;
+      const char *val = setting->value.data.string_value;
       regex_t regex;
       if (regcomp(&regex, val, REG_EXTENDED) == 0 &&
           regexec(&regex, filename, 0, NULL, 0) == 0) {
diff --git a/src/dged/lsp.c b/src/dged/lsp.c
new file mode 100644
index 0000000..3c699f4
--- /dev/null
+++ b/src/dged/lsp.c
@@ -0,0 +1,163 @@
+#include "lsp.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "buffer.h"
+#include "process.h"
+#include "reactor.h"
+
+struct lsp {
+  const char *name;
+  char *const *command;
+  struct process *process;
+  struct reactor *reactor;
+  struct buffer *stderr_buffer;
+  struct lsp_client client_impl;
+  uint32_t stdin_event;
+  uint32_t stdout_event;
+  uint32_t stderr_event;
+};
+
+struct lsp *lsp_create(char *const command[], struct reactor *reactor,
+                       struct buffer *stderr_buffer,
+                       struct lsp_client client_impl, const char *name) {
+  // check length of command
+  if (command == NULL) {
+    return NULL;
+  }
+
+  uint32_t command_len = 0;
+  while (command[command_len] != NULL) {
+    ++command_len;
+  }
+
+  if (command_len == 0) {
+    return NULL;
+  }
+
+  struct lsp *lsp = calloc(1, sizeof(struct lsp));
+
+  char **cmd = calloc(command_len + 1, sizeof(const char *));
+  memcpy(cmd, command, sizeof(const char *) * command_len);
+  cmd[command_len] = NULL;
+  lsp->command = cmd;
+
+  if (name != NULL) {
+    lsp->name = strdup(name);
+  } else {
+#ifdef __unix__
+    const char *lslash = strrchr(lsp->command[0], '/');
+#elif defined(_WIN32) || defined(WIN32)
+    const char *lslash = strrchr(lsp->command[0], '\\');
+#endif
+    if (lslash == NULL) {
+      lsp->name = strdup(lsp->command[0]);
+    } else {
+      lsp->name = strdup(lslash + 1);
+    }
+  }
+  lsp->stderr_buffer = stderr_buffer;
+  lsp->client_impl = client_impl;
+  lsp->reactor = reactor;
+  lsp->stdin_event = -1;
+  lsp->stdout_event = -1;
+  lsp->stderr_event = -1;
+
+  return lsp;
+}
+
+void lsp_destroy(struct lsp *lsp) {
+  free((void *)lsp->name);
+  if (lsp->process != NULL) {
+    free(lsp->process);
+  }
+  if (lsp->command != NULL) {
+    char *command = lsp->command[0];
+    while (command != NULL) {
+      free(command);
+      ++command;
+    }
+
+    free((void *)lsp->command);
+  }
+  free(lsp);
+}
+
+uint32_t lsp_update(struct lsp *lsp, struct lsp_response **responses,
+                    uint32_t responses_capacity) {
+
+  (void)responses;
+  (void)responses_capacity;
+
+  if (!lsp_server_running(lsp)) {
+    return -1;
+  }
+
+  // read stderr
+  if (lsp->stderr_event != (uint32_t)-1) {
+    uint8_t buf[1024];
+    if (reactor_poll_event(lsp->reactor, lsp->stderr_event)) {
+      ssize_t nb = 0;
+      while ((nb = read(lsp->process->stderr, buf, 1024)) > 0) {
+        buffer_set_readonly(lsp->stderr_buffer, false);
+        buffer_add(lsp->stderr_buffer, buffer_end(lsp->stderr_buffer), buf, nb);
+        buffer_set_readonly(lsp->stderr_buffer, true);
+      }
+    }
+  }
+
+  return 0;
+}
+
+int lsp_start_server(struct lsp *lsp) {
+  struct process p;
+  struct process_create_result res = process_create(lsp->command, &p);
+
+  if (!res.ok) {
+    // TODO: losing error message here
+    return -1;
+  }
+
+  lsp->process = calloc(1, sizeof(struct process));
+  memcpy(lsp->process, &p, sizeof(struct process));
+  lsp->stderr_event = reactor_register_interest(
+      lsp->reactor, lsp->process->stderr, ReadInterest);
+
+  return 0;
+}
+
+int lsp_restart_server(struct lsp *lsp) {
+  if (lsp_server_running(lsp)) {
+    lsp_stop_server(lsp);
+  }
+
+  return lsp_start_server(lsp);
+}
+
+void lsp_stop_server(struct lsp *lsp) {
+  process_kill(lsp->process);
+  process_destroy(lsp->process);
+  free(lsp->process);
+  lsp->process = NULL;
+}
+
+bool lsp_server_running(const struct lsp *lsp) {
+  if (lsp->process == NULL) {
+    return false;
+  }
+
+  return process_running(lsp->process);
+}
+
+uint64_t lsp_server_pid(const struct lsp *lsp) {
+  if (!lsp_server_running(lsp)) {
+    return -1;
+  }
+
+  return lsp->process->id;
+}
+
+const char *lsp_server_name(const struct lsp *lsp) { return lsp->name; }
diff --git a/src/dged/lsp.h b/src/dged/lsp.h
new file mode 100644
index 0000000..3fd6285
--- /dev/null
+++ b/src/dged/lsp.h
@@ -0,0 +1,75 @@
+#ifndef _LSP_H
+#define _LSP_H
+
+#include "location.h"
+#include "s8.h"
+
+struct buffer;
+struct lsp;
+struct reactor;
+
+typedef uint32_t request_id;
+
+struct lsp_response {
+  request_id id;
+  bool ok;
+  union payload_data {
+    void *result;
+    struct s8 error;
+  } payload;
+};
+
+struct lsp_notification {
+  int something;
+};
+
+struct lsp_client {
+  void (*log_message)(int type, struct s8 msg);
+};
+
+struct hover {
+  struct s8 contents;
+
+  bool has_range;
+  struct region *range;
+};
+
+struct text_doc_item {
+  struct s8 uri;
+  struct s8 language_id;
+  uint32_t version;
+  struct s8 text;
+};
+
+struct text_doc_position {
+  struct s8 uri;
+  struct location pos;
+};
+
+struct initialize_params {
+  struct s8 client_name;
+  struct s8 client_version;
+};
+
+// lifecycle functions
+struct lsp *lsp_create(char *const command[], struct reactor *reactor,
+                       struct buffer *stderr_buffer,
+                       struct lsp_client client_impl, const char *name);
+uint32_t lsp_update(struct lsp *lsp, struct lsp_response **responses,
+                    uint32_t responses_capacity);
+void lsp_destroy(struct lsp *lsp);
+
+// process control functions
+int lsp_start_server(struct lsp *lsp);
+int lsp_restart_server(struct lsp *lsp);
+void lsp_stop_server(struct lsp *lsp);
+bool lsp_server_running(const struct lsp *lsp);
+uint64_t lsp_server_pid(const struct lsp *lsp);
+const char *lsp_server_name(const struct lsp *lsp);
+
+// protocol functions
+void lsp_initialize(struct lsp *lsp, struct initialize_params);
+void lsp_did_open_document(struct lsp *lsp, struct text_doc_item document);
+request_id lsp_hover(struct lsp *lsp, struct text_doc_position);
+
+#endif
diff --git a/src/dged/minibuffer.c b/src/dged/minibuffer.c
index d31850b..c16a9bf 100644
--- a/src/dged/minibuffer.c
+++ b/src/dged/minibuffer.c
@@ -39,7 +39,7 @@ uint32_t minibuffer_draw_prompt(struct command_list *commands) {
 
 static void minibuffer_abort_prompt_internal(bool clear);
 
-int32_t minibuffer_execute() {
+int32_t minibuffer_execute(void) {
   if (g_minibuffer.prompt_active) {
     struct command_ctx *c = &g_minibuffer.prompt_command_ctx;
 
@@ -50,7 +50,7 @@ int32_t minibuffer_execute() {
 
     // propagate any saved arguments
     char *argv[64];
-    for (uint32_t i = 0; i < c->saved_argc; ++i) {
+    for (uint32_t i = 0; i < (uint32_t)c->saved_argc; ++i) {
       argv[i] = (char *)c->saved_argv[i];
     }
     argv[c->saved_argc] = l;
@@ -79,6 +79,8 @@ int32_t minibuffer_execute() {
 }
 
 void update(struct buffer *buffer, void *userdata) {
+  (void)buffer;
+
   struct timespec current;
   struct minibuffer *mb = (struct minibuffer *)userdata;
   clock_gettime(CLOCK_MONOTONIC, &current);
@@ -143,15 +145,15 @@ void message(const char *fmt, ...) {
              nbytes > 2048 ? 2048 : nbytes);
 }
 
-void minibuffer_destroy() {
+void minibuffer_destroy(void) {
   command_ctx_free(&g_minibuffer.prompt_command_ctx);
 }
 
-struct text_chunk minibuffer_content() {
+struct text_chunk minibuffer_content(void) {
   return buffer_line(g_minibuffer.buffer, 0);
 }
 
-struct buffer *minibuffer_buffer() {
+struct buffer *minibuffer_buffer(void) {
   return g_minibuffer.buffer;
 }
 
@@ -245,22 +247,22 @@ static void minibuffer_abort_prompt_internal(bool clear) {
   g_minibuffer.prompt_active = false;
 }
 
-void minibuffer_abort_prompt() { minibuffer_abort_prompt_internal(true); }
+void minibuffer_abort_prompt(void) { minibuffer_abort_prompt_internal(true); }
 
-bool minibuffer_empty() { return !minibuffer_displaying(); }
+bool minibuffer_empty(void) { return !minibuffer_displaying(); }
 
-bool minibuffer_displaying() {
+bool minibuffer_displaying(void) {
   return g_minibuffer.buffer != NULL && !buffer_is_empty(g_minibuffer.buffer);
 }
 
-void minibuffer_clear() {
+void minibuffer_clear(void) {
   g_minibuffer.expires.tv_sec = 0;
   g_minibuffer.expires.tv_nsec = 0;
   buffer_clear(g_minibuffer.buffer);
 }
 
-bool minibuffer_focused() { return g_minibuffer.prompt_active; }
+bool minibuffer_focused(void) { return g_minibuffer.prompt_active; }
 
-struct window *minibuffer_target_window() {
+struct window *minibuffer_target_window(void) {
   return g_minibuffer.prev_window;
 }
diff --git a/src/dged/minibuffer.h b/src/dged/minibuffer.h
index 6ac69c1..0b98904 100644
--- a/src/dged/minibuffer.h
+++ b/src/dged/minibuffer.h
@@ -24,11 +24,11 @@ void minibuffer_init(struct buffer *buffer, struct buffers *buffers);
  *
  * Note that this does not release the buffer used.
  */
-void minibuffer_destroy();
+void minibuffer_destroy(void);
 
-struct text_chunk minibuffer_content();
+struct text_chunk minibuffer_content(void);
 
-struct buffer *minibuffer_buffer();
+struct buffer *minibuffer_buffer(void);
 
 void message(const char *fmt, ...);
 
@@ -74,14 +74,14 @@ uint32_t minibuffer_draw_prompt(struct command_list *commands);
  *
  * @returns zero on success, non-zero to indicate failure
  */
-int32_t minibuffer_execute();
+int32_t minibuffer_execute(void);
 
 /**
  * Abort the current minibuffer prompt.
  *
  * This returns focus to the previously focused window.
  */
-void minibuffer_abort_prompt();
+void minibuffer_abort_prompt(void);
 
 /**
  * Minibuffer prompt args
@@ -94,22 +94,22 @@ struct minibuffer_prompt_args {
 /**
  * Clear the current text in the minibuffer.
  */
-void minibuffer_clear();
+void minibuffer_clear(void);
 
-bool minibuffer_empty();
+bool minibuffer_empty(void);
 
 /**
  * Is the minibuffer currently displaying something?
  *
  * @returns True if the minibuffer is displaying anything, false otherwise.
  */
-bool minibuffer_displaying();
+bool minibuffer_displaying(void);
 
 /**
  * Is the minibuffer currently focused?
  *
  * @returns True if the minibuffer is currently focused, receiving user input.
  */
-bool minibuffer_focused();
+bool minibuffer_focused(void);
 
-struct window *minibuffer_target_window();
+struct window *minibuffer_target_window(void);
diff --git a/src/dged/path.c b/src/dged/path.c
new file mode 100644
index 0000000..735ef0c
--- /dev/null
+++ b/src/dged/path.c
@@ -0,0 +1,68 @@
+#include "path.h"
+
+#include <limits.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+char *expanduser(const char *path) {
+  // replace tilde
+  char *res = NULL;
+  char *tilde_pos = strchr(path, '~');
+  if (tilde_pos != NULL) {
+    char *home = getenv("HOME");
+    if (home != NULL) {
+      // allocate a new string based with the new len
+      size_t home_len = strlen(home);
+      size_t path_len = strlen(path);
+      size_t total_len = path_len + home_len;
+      res = malloc(total_len);
+      size_t initial_len = tilde_pos - path;
+      strncpy(res, path, initial_len);
+
+      strncpy(res + initial_len, home, home_len + 1);
+
+      size_t rest_len = path_len - initial_len - 1;
+      strncpy(res + initial_len + home_len, path + initial_len + 1, rest_len);
+      res[total_len - 1] = '\0';
+    }
+  }
+
+  return res != NULL ? res : strdup(path);
+}
+
+char *to_abspath(const char *path) {
+  char *exp = expanduser(path);
+  char *p = realpath(path, NULL);
+  if (p != NULL) {
+    free(exp);
+    return p;
+  } else {
+    return exp;
+  }
+}
+
+const char *join_path_with_delim(const char *p1, const char *p2,
+                                 const char delim) {
+  size_t len1 = strlen(p1);
+  size_t len2 = strlen(p2);
+
+  char *path = malloc(len1 + len2 + 2);
+  uint32_t idx = 0;
+  memcpy(&path[idx], p1, len1);
+  idx += len1;
+  path[idx++] = delim;
+  memcpy(&path[idx], p2, len2);
+  idx += len2;
+  path[idx++] = '\0';
+
+  return path;
+}
+
+const char *join_path(const char *p1, const char *p2) {
+#ifdef __unix__
+  return join_path_with_delim(p1, p2, '/');
+#elif defined(_WIN32) || defined(WIN32)
+  return join_path_with_delim(p1, p2, '\\');
+#endif
+}
diff --git a/src/dged/path.h b/src/dged/path.h
index 8ea9977..6168e42 100644
--- a/src/dged/path.h
+++ b/src/dged/path.h
@@ -1,65 +1,10 @@
-#include <limits.h>
-#include <stdlib.h>
-#include <string.h>
+#ifndef _PATH_H
+#define _PATH_H
 
-static char *expanduser(const char *path) {
-  // replace tilde
-  char *res = NULL;
-  char *tilde_pos = strchr(path, '~');
-  if (tilde_pos != NULL) {
-    char *home = getenv("HOME");
-    if (home != NULL) {
-      // allocate a new string based with the new len
-      size_t home_len = strlen(home);
-      size_t path_len = strlen(path);
-      size_t total_len = path_len + home_len;
-      res = malloc(total_len);
-      size_t initial_len = tilde_pos - path;
-      strncpy(res, path, initial_len);
+char *expanduser(const char *path);
+char *to_abspath(const char *path);
+const char *join_path_with_delim(const char *p1, const char *p2,
+                                 const char delim);
+const char *join_path(const char *p1, const char *p2);
 
-      strncpy(res + initial_len, home, home_len);
-
-      size_t rest_len = path_len - initial_len - 1;
-      strncpy(res + initial_len + home_len, path + initial_len + 1, rest_len);
-      res[total_len - 1] = '\0';
-    }
-  }
-
-  return res != NULL ? res : strdup(path);
-}
-
-static char *to_abspath(const char *path) {
-  char *exp = expanduser(path);
-  char *p = realpath(path, NULL);
-  if (p != NULL) {
-    free(exp);
-    return p;
-  } else {
-    return exp;
-  }
-}
-
-static const char *join_path_with_delim(const char *p1, const char *p2,
-                                        const char delim) {
-  size_t len1 = strlen(p1);
-  size_t len2 = strlen(p2);
-
-  char *path = malloc(len1 + len2 + 2);
-  uint32_t idx = 0;
-  memcpy(&path[idx], p1, len1);
-  idx += len1;
-  path[idx++] = '/';
-  memcpy(&path[idx], p2, len2);
-  idx += len2;
-  path[idx++] = '\0';
-
-  return path;
-}
-
-static const char *join_path(const char *p1, const char *p2) {
-#ifdef __unix__
-  return join_path_with_delim(p1, p2, '/');
-#elif defined(_WIN32) || defined(WIN32)
-  return join_path_with_delim(p1, p2, '\\');
 #endif
-}
diff --git a/src/dged/process-posix.c b/src/dged/process-posix.c
new file mode 100644
index 0000000..94ceb5f
--- /dev/null
+++ b/src/dged/process-posix.c
@@ -0,0 +1,126 @@
+#include "process.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <sys/types.h>
+#include <sys/wait.h>
+
+static int create_pipe(int *read_end, int *write_end, bool read_nonblock,
+                       bool write_nonblock) {
+  int pipes[2] = {0};
+  if (pipe(pipes) < 0) {
+    return -1;
+  }
+
+  if (write_nonblock) {
+    int flags = fcntl(pipes[1], F_GETFL, 0);
+    if (flags < 0) {
+      return -1;
+    }
+
+    flags |= O_NONBLOCK;
+    if (fcntl(pipes[1], F_SETFL, flags) < 0) {
+      return -1;
+    }
+  }
+
+  if (read_nonblock) {
+    int flags = fcntl(pipes[0], F_GETFL, 0);
+    if (flags < 0) {
+      return -1;
+    }
+
+    flags |= O_NONBLOCK;
+    if (fcntl(pipes[0], F_SETFL, flags) < 0) {
+      return -1;
+    }
+  }
+
+  *read_end = pipes[0];
+  *write_end = pipes[1];
+
+  return 0;
+}
+
+struct process_create_result process_create(char *const command[],
+                                            struct process *result) {
+
+  int stdin_read, stdin_write;
+  if (create_pipe(&stdin_read, &stdin_write, false, true) < 0) {
+    return (struct process_create_result){
+        .ok = false,
+        .error_message = strerror(errno),
+    };
+  }
+
+  int stdout_read, stdout_write;
+  if (create_pipe(&stdout_read, &stdout_write, true, false) < 0) {
+    return (struct process_create_result){
+        .ok = false,
+        .error_message = strerror(errno),
+    };
+  }
+
+  int stderr_read, stderr_write;
+  if (create_pipe(&stderr_read, &stderr_write, true, false) < 0) {
+    return (struct process_create_result){
+        .ok = false,
+        .error_message = strerror(errno),
+    };
+  }
+
+  pid_t pid = fork();
+  if (pid == -1) {
+    return (struct process_create_result){
+        .ok = false,
+        .error_message = strerror(errno),
+    };
+  } else if (pid == 0) {
+    close(stdin_write);
+    close(stdout_read);
+    close(stderr_read);
+
+    if (dup2(stdin_read, STDIN_FILENO) < 0) {
+      exit(16);
+    }
+
+    if (dup2(stdout_write, STDOUT_FILENO) < 0) {
+      exit(16);
+    }
+
+    if (dup2(stderr_write, STDERR_FILENO) < 0) {
+      exit(16);
+    }
+
+    if (execvp(command[0], command) < 0) {
+      exit(16);
+    }
+  } else {
+    close(stdin_read);
+    close(stdout_write);
+    close(stderr_write);
+
+    result->stdin = stdin_write;
+    result->stdout = stdout_read;
+    result->stderr = stderr_read;
+    result->id = (fd_t)pid;
+    result->impl = NULL;
+  }
+
+  return (struct process_create_result){
+      .ok = true,
+  };
+}
+
+void process_destroy(struct process *p) { (void)p; }
+
+bool process_running(const struct process *p) {
+  return waitpid(p->id, NULL, WNOHANG) == 0;
+}
+
+bool process_kill(const struct process *p) { return kill(p->id, SIGTERM) == 0; }
diff --git a/src/dged/process.h b/src/dged/process.h
new file mode 100644
index 0000000..cefec8c
--- /dev/null
+++ b/src/dged/process.h
@@ -0,0 +1,35 @@
+#ifndef _PROCESS_H
+#define _PROCESS_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifdef _WIN32
+typedef HANDLE fd_t;
+#else
+typedef int fd_t;
+#endif
+
+struct platform_process;
+struct process {
+  uint64_t id;
+  fd_t stdin;
+  fd_t stdout;
+  fd_t stderr;
+  struct platform_process *impl;
+};
+
+struct process_create_result {
+  bool ok;
+  const char *error_message;
+};
+
+struct process_create_result process_create(char *const command[],
+                                            struct process *result);
+
+void process_destroy(struct process *p);
+
+bool process_running(const struct process *p);
+bool process_kill(const struct process *p);
+
+#endif
diff --git a/src/dged/reactor-epoll.c b/src/dged/reactor-epoll.c
index 4c83b49..beee7ec 100644
--- a/src/dged/reactor-epoll.c
+++ b/src/dged/reactor-epoll.c
@@ -22,15 +22,15 @@ struct events {
   uint32_t nevents;
 };
 
-struct reactor *reactor_create() {
+struct reactor *reactor_create(void) {
   int epollfd = epoll_create1(0);
   if (epollfd == -1) {
-    perror("epoll_create1");
+    return NULL;
   }
 
   int inotifyfd = inotify_init1(IN_NONBLOCK);
   if (inotifyfd == -1) {
-    perror("inotify_init1");
+    return NULL;
   }
 
   struct reactor *r = (struct reactor *)calloc(1, sizeof(struct reactor));
@@ -55,7 +55,6 @@ uint32_t reactor_register_interest(struct reactor *reactor, int fd,
   ev.events |= (interest & WriteInterest) != 0 ? EPOLLOUT : 0;
   ev.data.fd = fd;
   if (epoll_ctl(reactor->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) {
-    perror("epoll_ctl");
     return -1;
   }
 
@@ -71,7 +70,7 @@ bool reactor_poll_event(struct reactor *reactor, uint32_t ev_id) {
   for (uint32_t ei = 0; ei < events->nevents; ++ei) {
     struct epoll_event *ev = &events->events[ei];
 
-    if (ev->data.fd == ev_id) {
+    if ((uint32_t)ev->data.fd == ev_id) {
       return true;
     }
   }
@@ -118,7 +117,8 @@ void reactor_update(struct reactor *reactor) {
   int nfds = epoll_wait(reactor->epoll_fd, events->events, 10, -1);
 
   if (nfds == -1) {
-    // TODO: log failure
+    events->nevents = 0;
+    message("failed update epoll reactor: %s", strerror(errno));
   }
 
   events->nevents = nfds;
diff --git a/src/dged/reactor-kqueue.c b/src/dged/reactor-kqueue.c
index 58ab7af..f30cb9a 100644
--- a/src/dged/reactor-kqueue.c
+++ b/src/dged/reactor-kqueue.c
@@ -16,7 +16,7 @@ struct reactor {
   uint32_t nevents;
 };
 
-struct reactor *reactor_create() {
+struct reactor *reactor_create(void) {
   int queue = kqueue();
   if (queue < 0) {
     return NULL;
diff --git a/src/dged/reactor.h b/src/dged/reactor.h
index 39a94a9..82ff3fe 100644
--- a/src/dged/reactor.h
+++ b/src/dged/reactor.h
@@ -18,7 +18,7 @@ struct file_event {
 
 struct reactor;
 
-struct reactor *reactor_create();
+struct reactor *reactor_create(void);
 void reactor_destroy(struct reactor *reactor);
 void reactor_update(struct reactor *reactor);
 bool reactor_poll_event(struct reactor *reactor, uint32_t ev_id);
diff --git a/src/dged/settings.c b/src/dged/settings.c
index e63862f..68256e8 100644
--- a/src/dged/settings.c
+++ b/src/dged/settings.c
@@ -20,11 +20,11 @@ void settings_init(uint32_t initial_capacity) {
   HASHMAP_INIT(&g_settings.settings, initial_capacity, hash_name);
 }
 
-void settings_destroy() {
+void settings_destroy(void) {
   HASHMAP_FOR_EACH(&g_settings.settings, struct setting_entry * entry) {
     struct setting *setting = &entry->value;
     if (setting->value.type == Setting_String) {
-      free(setting->value.string_value);
+      free(setting->value.data.string_value);
     }
   }
 
@@ -33,8 +33,9 @@ void settings_destroy() {
 
 void setting_set_value(struct setting *setting, struct setting_value val) {
   if (setting->value.type == val.type) {
-    if (setting->value.type == Setting_String && val.string_value != NULL) {
-      setting->value.string_value = strdup(val.string_value);
+    if (setting->value.type == Setting_String &&
+        val.data.string_value != NULL) {
+      setting->value.data.string_value = strdup(val.data.string_value);
     } else {
       setting->value = val;
     }
@@ -99,13 +100,13 @@ void settings_set_default(const char *path, struct setting_value value) {
 void setting_to_string(struct setting *setting, char *buf, size_t n) {
   switch (setting->value.type) {
   case Setting_Bool:
-    snprintf(buf, n, "%s", setting->value.bool_value ? "true" : "false");
+    snprintf(buf, n, "%s", setting->value.data.bool_value ? "true" : "false");
     break;
   case Setting_Number:
-    snprintf(buf, n, "%" PRId64, setting->value.number_value);
+    snprintf(buf, n, "%" PRId64, setting->value.data.number_value);
     break;
   case Setting_String:
-    snprintf(buf, n, "%s", setting->value.string_value);
+    snprintf(buf, n, "%s", setting->value.data.string_value);
     break;
   }
 }
@@ -113,7 +114,6 @@ void setting_to_string(struct setting *setting, char *buf, size_t n) {
 static int32_t parse_toml(struct parser *state, char **errmsgs[]) {
   char *curtbl = NULL;
   char *curkey = NULL;
-  uint32_t errcnt = 0;
 
   VEC(char *) errs;
   VEC_INIT(&errs, 16);
@@ -160,20 +160,20 @@ static int32_t parse_toml(struct parser *state, char **errmsgs[]) {
     case Token_IntValue:
       i = *((int64_t *)t.data);
       settings_set(curkey, (struct setting_value){.type = Setting_Number,
-                                                  .number_value = i});
+                                                  .data.number_value = i});
       break;
 
     case Token_BoolValue:
       b = *((bool *)t.data);
       settings_set(curkey, (struct setting_value){.type = Setting_Bool,
-                                                  .bool_value = b});
+                                                  .data.bool_value = b});
       break;
 
     case Token_StringValue:
       v = calloc(t.len + 1, 1);
       strncpy(v, (char *)t.data, t.len);
       settings_set(curkey, (struct setting_value){.type = Setting_String,
-                                                  .string_value = v});
+                                                  .data.string_value = v});
       free(v);
       break;
 
diff --git a/src/dged/settings.h b/src/dged/settings.h
index b88e483..fb79c75 100644
--- a/src/dged/settings.h
+++ b/src/dged/settings.h
@@ -26,7 +26,7 @@ struct setting_value {
   /** Type of setting. */
   enum setting_type type;
 
-  union {
+  union setting_data {
     /** String setting. */
     char *string_value;
 
@@ -35,7 +35,7 @@ struct setting_value {
 
     /** Boolean setting value. */
     bool bool_value;
-  };
+  } data;
 };
 
 /**
@@ -73,7 +73,7 @@ void settings_init(uint32_t initial_capacity);
 /**
  * Destroy the global collection of settings.
  */
-void settings_destroy();
+void settings_destroy(void);
 
 /**
  * Retrieve a single setting by path.
diff --git a/src/dged/syntax.c b/src/dged/syntax.c
index 569dc70..67ab3a2 100644
--- a/src/dged/syntax.c
+++ b/src/dged/syntax.c
@@ -48,6 +48,8 @@ struct highlight {
 };
 
 static void delete_parser(struct buffer *buffer, void *userdata) {
+  (void)buffer;
+
   struct highlight *highlight = (struct highlight *)userdata;
 
   if (highlight->query != NULL) {
@@ -72,6 +74,7 @@ static void delete_parser(struct buffer *buffer, void *userdata) {
 
 static const char *read_text(void *payload, uint32_t byte_offset,
                              TSPoint position, uint32_t *bytes_read) {
+  (void)byte_offset;
 
   struct text *text = (struct text *)payload;
 
@@ -97,7 +100,7 @@ static const char *read_text(void *payload, uint32_t byte_offset,
 static const char *grammar_name_from_buffer(struct buffer *buffer) {
   struct setting *s = lang_setting(&buffer->lang, "grammar");
   if (s != NULL && s->value.type == Setting_String) {
-    return s->value.string_value;
+    return s->value.data.string_value;
   }
 
   return buffer->lang.name;
@@ -124,6 +127,10 @@ static const char *lang_folder(struct buffer *buffer, const char *path) {
 
 static bool eval_eq(struct s8 capname, uint32_t argc, struct s8 argv[],
                     struct s8 value, void *data) {
+  (void)capname;
+  (void)argc;
+  (void)argv;
+
   const struct s8 *cmp_to = (const struct s8 *)data;
   if (data == NULL) {
     return false;
@@ -143,6 +150,10 @@ static void cleanup_eq(void *data) {
 
 static bool eval_match(struct s8 capname, uint32_t argc, struct s8 argv[],
                        struct s8 value, void *data) {
+  (void)capname;
+  (void)argc;
+  (void)argv;
+
   regex_t *regex = (regex_t *)data;
   if (regex == NULL) {
     return false;
@@ -325,6 +336,8 @@ static void update_parser(struct buffer *buffer, void *userdata,
                           struct location origin, uint32_t width,
                           uint32_t height) {
 
+  (void)width;
+
   struct highlight *h = (struct highlight *)userdata;
 
   if (h->query == NULL) {
@@ -411,7 +424,7 @@ static void update_parser(struct buffer *buffer, void *userdata,
                         end.column > 0 ? end.column - 1 : 0,
                         (struct text_property){
                             .type = TextProperty_Colors,
-                            .colors =
+                            .data.colors =
                                 (struct text_property_colors){
                                     .set_fg = true,
                                     .fg = color,
@@ -509,8 +522,9 @@ static void text_inserted(struct buffer *buffer, struct edit_location inserted,
 }
 
 static void create_parser(struct buffer *buffer, void *userdata) {
+  (void)userdata;
 
-  TSLanguage *(*langsym)() = NULL;
+  TSLanguage *(*langsym)(void) = NULL;
   const char *lang_root = NULL, *langname = NULL;
   void *h = NULL;
 
@@ -601,7 +615,7 @@ void syntax_init(uint32_t grammar_path_len, const char *grammar_path[]) {
     lang_setting_set_default(
         &l, "grammar",
         (struct setting_value){.type = Setting_String,
-                               .string_value = "gitcommit"});
+                               .data.string_value = "gitcommit"});
     lang_destroy(&l);
   }
 
@@ -609,14 +623,15 @@ void syntax_init(uint32_t grammar_path_len, const char *grammar_path[]) {
   if (!lang_is_fundamental(&l)) {
     lang_setting_set_default(
         &l, "grammar",
-        (struct setting_value){.type = Setting_String, .string_value = "cpp"});
+        (struct setting_value){.type = Setting_String,
+                               .data.string_value = "cpp"});
     lang_destroy(&l);
   }
 
   buffer_add_create_hook(create_parser, NULL);
 }
 
-void syntax_teardown() {
+void syntax_teardown(void) {
   for (uint32_t i = 0; i < treesitter_path_len; ++i) {
     free((void *)treesitter_path[i]);
   }
diff --git a/src/dged/syntax.h b/src/dged/syntax.h
index 488406b..015f5be 100644
--- a/src/dged/syntax.h
+++ b/src/dged/syntax.h
@@ -4,6 +4,6 @@
 #include <stdint.h>
 
 void syntax_init(uint32_t grammar_path_len, const char *grammar_path[]);
-void syntax_teardown();
+void syntax_teardown(void);
 
 #endif
diff --git a/src/dged/text.h b/src/dged/text.h
index 28bd325..505c86a 100644
--- a/src/dged/text.h
+++ b/src/dged/text.h
@@ -66,10 +66,10 @@ struct text_property_colors {
 
 struct text_property {
   enum text_property_type type;
-  union {
+  union property_data {
     struct text_property_colors colors;
     void *userdata;
-  };
+  } data;
 };
 
 void text_add_property(struct text *text, uint32_t start_line,
diff --git a/src/dged/timers.c b/src/dged/timers.c
index 798c003..2fd5fc9 100644
--- a/src/dged/timers.c
+++ b/src/dged/timers.c
@@ -23,21 +23,21 @@ static struct timers {
   HASHMAP(struct timer_entry) timers;
 } g_timers;
 
-void timers_init() {
+void timers_init(void) {
   HASHMAP_INIT(&g_timers.timers, 32, hash_name);
   g_timers.frame_index = 0;
 }
 
-void timers_destroy() { HASHMAP_DESTROY(&g_timers.timers); }
+void timers_destroy(void) { HASHMAP_DESTROY(&g_timers.timers); }
 
-void timers_start_frame() {
+void timers_start_frame(void) {
   HASHMAP_FOR_EACH(&g_timers.timers, struct timer_entry * entry) {
     struct timer *timer = &entry->value;
     timer->samples[g_timers.frame_index] = 0;
   }
 }
 
-void timers_end_frame() {
+void timers_end_frame(void) {
   g_timers.frame_index = (g_timers.frame_index + 1) % NUM_FRAME_SAMPLES;
 }
 
diff --git a/src/dged/timers.h b/src/dged/timers.h
index ae79a8b..03ec742 100644
--- a/src/dged/timers.h
+++ b/src/dged/timers.h
@@ -5,8 +5,8 @@
 
 struct timer;
 
-void timers_init();
-void timers_start_frame();
+void timers_init(void);
+void timers_start_frame(void);
 
 struct timer *timer_start(const char *name);
 uint64_t timer_stop(struct timer *timer);
@@ -19,7 +19,7 @@ const char *timer_name(const struct timer *timer);
 typedef void (*timer_callback)(const struct timer *timer, void *userdata);
 void timers_for_each(timer_callback callback, void *userdata);
 
-void timers_end_frame();
-void timers_destroy();
+void timers_end_frame(void);
+void timers_destroy(void);
 
 #endif
diff --git a/src/dged/undo.c b/src/dged/undo.c
index 8f00f0f..ad167c3 100644
--- a/src/dged/undo.c
+++ b/src/dged/undo.c
@@ -18,9 +18,9 @@ void undo_clear(struct undo_stack *undo) {
 
 void undo_destroy(struct undo_stack *undo) {
   VEC_FOR_EACH(&undo->records, struct undo_record * rec) {
-    if (rec->type == Undo_Delete && rec->delete.data != NULL &&
-        rec->delete.nbytes > 0) {
-      free(rec->delete.data);
+    if (rec->type == Undo_Delete && rec->data.delete.data != NULL &&
+        rec->data.delete.nbytes > 0) {
+      free(rec->data.delete.data);
     }
   }
 
@@ -35,15 +35,15 @@ uint32_t undo_push_boundary(struct undo_stack *undo,
   // we can only have one save point
   if (boundary.save_point) {
     VEC_FOR_EACH(&undo->records, struct undo_record * rec) {
-      if (rec->type == Undo_Boundary && rec->boundary.save_point) {
-        rec->boundary.save_point = false;
+      if (rec->type == Undo_Boundary && rec->data.boundary.save_point) {
+        rec->data.boundary.save_point = false;
       }
     }
   }
 
   VEC_APPEND(&undo->records, struct undo_record * rec);
   rec->type = Undo_Boundary;
-  rec->boundary = boundary;
+  rec->data.boundary = boundary;
 
   if (!undo->undo_in_progress) {
     undo->top = VEC_SIZE(&undo->records) - 1;
@@ -61,12 +61,12 @@ uint32_t undo_push_add(struct undo_stack *undo, struct undo_add add) {
   // "compress"
   if (!VEC_EMPTY(&undo->records) &&
       VEC_BACK(&undo->records)->type == Undo_Add &&
-      pos_equal(&VEC_BACK(&undo->records)->add.end, &add.begin)) {
-    VEC_BACK(&undo->records)->add.end = add.end;
+      pos_equal(&VEC_BACK(&undo->records)->data.add.end, &add.begin)) {
+    VEC_BACK(&undo->records)->data.add.end = add.end;
   } else {
     VEC_APPEND(&undo->records, struct undo_record * rec);
     rec->type = Undo_Add;
-    rec->add = add;
+    rec->data.add = add;
   }
 
   if (!undo->undo_in_progress) {
@@ -79,7 +79,7 @@ uint32_t undo_push_add(struct undo_stack *undo, struct undo_add add) {
 uint32_t undo_push_delete(struct undo_stack *undo, struct undo_delete delete) {
   VEC_APPEND(&undo->records, struct undo_record * rec);
   rec->type = Undo_Delete;
-  rec->delete = delete;
+  rec->data.delete = delete;
 
   if (!undo->undo_in_progress) {
     undo->top = VEC_SIZE(&undo->records) - 1;
@@ -150,15 +150,15 @@ size_t rec_to_str(struct undo_record *rec, char *buffer, size_t n) {
   switch (rec->type) {
   case Undo_Add:
     return snprintf(buffer, n, "add { begin: (%d, %d) end: (%d, %d)}",
-                    rec->add.begin.row, rec->add.begin.col, rec->add.end.row,
-                    rec->add.end.col);
+                    rec->data.add.begin.row, rec->data.add.begin.col,
+                    rec->data.add.end.row, rec->data.add.end.col);
   case Undo_Delete:
     return snprintf(buffer, n, "delete { pos: (%d, %d), ptr: 0x%p, nbytes: %d}",
-                    rec->delete.pos.row, rec->delete.pos.col, rec->delete.data,
-                    rec->delete.nbytes);
+                    rec->data.delete.pos.row, rec->data.delete.pos.col,
+                    (void *)rec->data.delete.data, rec->data.delete.nbytes);
   default:
     return snprintf(buffer, n, "boundary { save_point: %s }",
-                    rec->boundary.save_point ? "yes" : "no");
+                    rec->data.boundary.save_point ? "yes" : "no");
   }
 }
 
diff --git a/src/dged/undo.h b/src/dged/undo.h
index 1ce3a8a..2f308f9 100644
--- a/src/dged/undo.h
+++ b/src/dged/undo.h
@@ -31,14 +31,14 @@ struct undo_delete {
 struct undo_record {
   enum undo_record_type type;
 
-  union {
+  union undo_record_data {
     struct undo_boundary boundary;
     struct undo_add add;
     struct undo_delete delete;
-  };
+  } data;
 };
 
-#define INVALID_TOP -1
+#define INVALID_TOP (uint32_t) - 1
 
 struct undo_stack {
   VEC(struct undo_record) records;
diff --git a/src/dged/utf8.c b/src/dged/utf8.c
index ede4fb1..01dcdbd 100644
--- a/src/dged/utf8.c
+++ b/src/dged/utf8.c
@@ -112,7 +112,6 @@ uint32_t utf8_nchars(uint8_t *bytes, uint32_t nbytes) {
 uint32_t utf8_nbytes(uint8_t *bytes, uint32_t nbytes, uint32_t nchars) {
   uint32_t bi = 0;
   uint32_t chars = 0;
-  uint32_t expected = 0;
 
   while (chars < nchars && bi < nbytes) {
     struct codepoint codepoint = next_utf8_codepoint(bytes + bi, nbytes - bi);
@@ -127,7 +126,7 @@ uint32_t utf8_nbytes(uint8_t *bytes, uint32_t nbytes, uint32_t nchars) {
 uint32_t unicode_visual_char_width(const struct codepoint *codepoint) {
   if (codepoint->nbytes > 0) {
     // TODO: use unicode classification instead
-    size_t w = wcwidth(codepoint->codepoint);
+    int w = wcwidth(codepoint->codepoint);
     return w >= 0 ? w : 2;
   } else {
     return 0;
diff --git a/src/dged/vec.h b/src/dged/vec.h
index 929c8d5..1289a08 100644
--- a/src/dged/vec.h
+++ b/src/dged/vec.h
@@ -48,8 +48,7 @@
   }
 
 #define VEC_SWAP(vec, idx1, idx2)                                              \
-  if (idx1 < (vec)->nentries && idx2 < (vec)->nentries && idx1 >= 0 &&         \
-      idx2 >= 0) {                                                             \
+  if (idx1 < (vec)->nentries && idx2 < (vec)->nentries) {                      \
     *((vec)->temp) = (vec)->entries[idx1];                                     \
     (vec)->entries[idx1] = (vec)->entries[idx2];                               \
     (vec)->entries[idx2] = *((vec)->temp);                                     \
diff --git a/src/dged/window.c b/src/dged/window.c
index 20cb22f..702f97a 100644
--- a/src/dged/window.c
+++ b/src/dged/window.c
@@ -124,25 +124,25 @@ static void window_tree_clear_sub(struct window_node *root_node) {
   BINTREE_FREE_NODES(root_node, window_node);
 }
 
-static void window_tree_clear() {
+static void window_tree_clear(void) {
   window_tree_clear_sub(BINTREE_ROOT(&g_windows.windows));
 }
 
-void windows_destroy() { window_tree_clear(); }
+void windows_destroy(void) { window_tree_clear(); }
 
-struct window *root_window() {
+struct window *root_window(void) {
   return &BINTREE_VALUE(BINTREE_ROOT(&g_windows.windows));
 }
 
-struct window *minibuffer_window() {
+struct window *minibuffer_window(void) {
   return &g_minibuffer_window;
 }
 
-struct window *popup_window() {
+struct window *popup_window(void) {
   return &g_popup_window;
 }
 
-bool popup_window_visible() { return g_popup_visible; }
+bool popup_window_visible(void) { return g_popup_visible; }
 
 static void window_tree_resize(struct window_node *root, uint32_t height,
                                uint32_t width) {
@@ -412,7 +412,7 @@ struct window *window_find_by_buffer(struct buffer *b) {
   return NULL;
 }
 
-struct window *windows_get_active() {
+struct window *windows_get_active(void) {
   return g_windows.active;
 }
 
@@ -630,7 +630,7 @@ void window_split(struct window *window, struct window **new_window_a,
       : window_vsplit(window, new_window_a, new_window_b);
 }
 
-struct window *windows_focus_next() {
+struct window *windows_focus_next(void) {
   struct window *active = windows_get_active();
   struct window_node *n = find_window(active);
   BINTREE_NEXT(n);
@@ -693,4 +693,4 @@ void windows_show_popup(uint32_t row, uint32_t col, uint32_t width,
   g_popup_visible = true;
 }
 
-void windows_close_popup() { g_popup_visible = false; }
+void windows_close_popup(void) { g_popup_visible = false; }
diff --git a/src/dged/window.h b/src/dged/window.h
index e1b1d25..7738e16 100644
--- a/src/dged/window.h
+++ b/src/dged/window.h
@@ -25,20 +25,20 @@ void windows_init(uint32_t height, uint32_t width,
                   struct buffer *initial_buffer, struct buffer *minibuffer,
                   struct buffers *buffers);
 
-void windows_destroy();
+void windows_destroy(void);
 void windows_resize(uint32_t height, uint32_t width);
 void windows_update(void *(*frame_alloc)(size_t), float frame_time);
 void windows_render(struct display *display);
 
-struct window *root_window();
-struct window *minibuffer_window();
-struct window *popup_window();
-bool popup_window_visible();
+struct window *root_window(void);
+struct window *minibuffer_window(void);
+struct window *popup_window(void);
+bool popup_window_visible(void);
 
 void windows_set_active(struct window *window);
 struct window *windows_focus(uint32_t id);
-struct window *windows_get_active();
-struct window *windows_focus_next();
+struct window *windows_get_active(void);
+struct window *windows_focus_next(void);
 struct window *window_find_by_buffer(struct buffer *b);
 
 void window_set_buffer(struct window *window, struct buffer *buffer);
@@ -63,6 +63,6 @@ void window_vsplit(struct window *window, struct window **new_window_a,
 
 void windows_show_popup(uint32_t row, uint32_t col, uint32_t width,
                         uint32_t height);
-void windows_close_popup();
+void windows_close_popup(void);
 
 #endif
diff --git a/src/main/bindings.c b/src/main/bindings.c
index 7b25c7b..889c32b 100644
--- a/src/main/bindings.c
+++ b/src/main/bindings.c
@@ -72,6 +72,10 @@ void set_default_buffer_bindings(struct keymap *keymap) {
 }
 
 int32_t execute(struct command_ctx ctx, int argc, const char *argv[]) {
+  (void)ctx;
+  (void)argc;
+  (void)argv;
+
   // TODO: this should be more lib-like
   return minibuffer_execute();
 }
@@ -82,7 +86,7 @@ static struct command execute_minibuffer_command = {
     .userdata = NULL,
 };
 
-void init_bindings() {
+void init_bindings(void) {
   g_global_keymap = keymap_create("global", 32);
   g_ctrlx_map = keymap_create("c-x", 32);
   g_windows_keymap = keymap_create("c-x w", 32);
@@ -203,7 +207,7 @@ uint32_t buffer_keymaps(struct buffer *buffer, struct keymap *keymaps[],
   return nkeymaps;
 }
 
-void destroy_bindings() {
+void destroy_bindings(void) {
   keymap_destroy(&g_windows_keymap);
   keymap_destroy(&g_global_keymap);
   keymap_destroy(&g_ctrlx_map);
diff --git a/src/main/bindings.h b/src/main/bindings.h
index 4fd760a..96f20fd 100644
--- a/src/main/bindings.h
+++ b/src/main/bindings.h
@@ -4,7 +4,7 @@ struct keymap;
 struct buffer;
 struct binding;
 
-void init_bindings();
+void init_bindings(void);
 
 typedef uint64_t buffer_keymap_id;
 buffer_keymap_id buffer_add_keymap(struct buffer *buffer, struct keymap keymap);
@@ -12,4 +12,4 @@ void buffer_remove_keymap(buffer_keymap_id id);
 uint32_t buffer_keymaps(struct buffer *buffer, struct keymap *keymaps[],
                         uint32_t max_nkeymaps);
 
-void destroy_bindings();
+void destroy_bindings(void);
diff --git a/src/main/cmds.c b/src/main/cmds.c
index 18f333d..40983a2 100644
--- a/src/main/cmds.c
+++ b/src/main/cmds.c
@@ -20,7 +20,12 @@
 #include "completion.h"
 #include "search-replace.h"
 
-int32_t _abort(struct command_ctx ctx, int argc, const char *argv[]) {
+static void (*g_terminate_cb)(void) = NULL;
+
+static int32_t _abort(struct command_ctx ctx, int argc, const char *argv[]) {
+  (void)argc;
+  (void)argv;
+
   abort_replace();
   abort_search();
   abort_completion();
@@ -33,16 +38,27 @@ int32_t _abort(struct command_ctx ctx, int argc, const char *argv[]) {
 
 int32_t unimplemented_command(struct command_ctx ctx, int argc,
                               const char *argv[]) {
+  (void)argc;
+  (void)argv;
   minibuffer_echo("TODO: %s is not implemented", (const char *)ctx.userdata);
   return 0;
 }
 
-int32_t exit_editor(struct command_ctx ctx, int argc, const char *argv[]) {
-  ((void (*)())ctx.userdata)();
+static int32_t exit_editor(struct command_ctx ctx, int argc,
+                           const char *argv[]) {
+  (void)ctx;
+  (void)argc;
+  (void)argv;
+
+  if (g_terminate_cb != NULL) {
+    g_terminate_cb();
+  }
+
   return 0;
 }
 
-int32_t write_file(struct command_ctx ctx, int argc, const char *argv[]) {
+static int32_t write_file(struct command_ctx ctx, int argc,
+                          const char *argv[]) {
   const char *pth = NULL;
   if (argc == 0) {
     return minibuffer_prompt(ctx, "write to file: ");
@@ -55,7 +71,7 @@ int32_t write_file(struct command_ctx ctx, int argc, const char *argv[]) {
   return 0;
 }
 
-static void run_interactive_comp_inserted() { minibuffer_execute(); }
+static void run_interactive_comp_inserted(void) { minibuffer_execute(); }
 
 int32_t run_interactive(struct command_ctx ctx, int argc, const char *argv[]) {
   if (argc == 0) {
@@ -63,7 +79,7 @@ int32_t run_interactive(struct command_ctx ctx, int argc, const char *argv[]) {
     enable_completion(minibuffer_buffer(),
                       ((struct completion_trigger){
                           .kind = CompletionTrigger_Input,
-                          .input =
+                          .data.input =
                               (struct completion_trigger_input){
                                   .nchars = 0, .trigger_initially = false}}),
                       providers, 1, run_interactive_comp_inserted);
@@ -106,9 +122,9 @@ int32_t do_switch_buffer(struct command_ctx ctx, int argc, const char *argv[]) {
   }
 }
 
-COMMAND_FN("do-switch-buffer", do_switch_buffer, do_switch_buffer, NULL);
+COMMAND_FN("do-switch-buffer", do_switch_buffer, do_switch_buffer, NULL)
 
-static void switch_buffer_comp_inserted() { minibuffer_execute(); }
+static void switch_buffer_comp_inserted(void) { minibuffer_execute(); }
 
 int32_t switch_buffer(struct command_ctx ctx, int argc, const char *argv[]) {
   if (argc == 0) {
@@ -117,7 +133,7 @@ int32_t switch_buffer(struct command_ctx ctx, int argc, const char *argv[]) {
     enable_completion(minibuffer_buffer(),
                       ((struct completion_trigger){
                           .kind = CompletionTrigger_Input,
-                          .input =
+                          .data.input =
                               (struct completion_trigger_input){
                                   .nchars = 0, .trigger_initially = false}}),
                       providers, 1, switch_buffer_comp_inserted);
@@ -156,9 +172,9 @@ int32_t do_kill_buffer(struct command_ctx ctx, int argc, const char *argv[]) {
   }
 }
 
-COMMAND_FN("do-kill-buffer", do_kill_buffer, do_kill_buffer, NULL);
+COMMAND_FN("do-kill-buffer", do_kill_buffer, do_kill_buffer, NULL)
 
-static void kill_buffer_comp_inserted() { minibuffer_execute(); }
+static void kill_buffer_comp_inserted(void) { minibuffer_execute(); }
 
 int32_t kill_buffer(struct command_ctx ctx, int argc, const char *argv[]) {
   if (argc == 0) {
@@ -167,7 +183,7 @@ int32_t kill_buffer(struct command_ctx ctx, int argc, const char *argv[]) {
     enable_completion(minibuffer_buffer(),
                       ((struct completion_trigger){
                           .kind = CompletionTrigger_Input,
-                          .input =
+                          .data.input =
                               (struct completion_trigger_input){
                                   .nchars = 0, .trigger_initially = false}}),
                       providers, 1, kill_buffer_comp_inserted);
@@ -188,7 +204,6 @@ void timer_to_list_line(const struct timer *timer, void *userdata) {
 
   static char buf[128];
   const char *name = timer_name(timer);
-  size_t namelen = strlen(name);
   size_t len =
       snprintf(buf, 128, "%s - %.2f ms (min: %.2f, max: %.2f)", name,
                (timer_average(timer) / 1e6), timer_min(timer) / (float)1e6,
@@ -197,6 +212,8 @@ void timer_to_list_line(const struct timer *timer, void *userdata) {
 }
 
 void timers_refresh(struct buffer *buffer, void *userdata) {
+  (void)userdata;
+
   buffer_set_readonly(buffer, false);
   buffer_clear(buffer);
   timers_for_each(timer_to_list_line, buffer);
@@ -208,6 +225,9 @@ void timers_refresh(struct buffer *buffer, void *userdata) {
 }
 
 int32_t timers(struct command_ctx ctx, int argc, const char *argv[]) {
+  (void)argc;
+  (void)argv;
+
   struct buffer *b = buffers_find(ctx.buffers, "*timers*");
   if (b == NULL) {
     b = buffers_add(ctx.buffers, buffer_create("*timers*"));
@@ -236,7 +256,7 @@ void buffer_to_list_line(struct buffer *buffer, void *userdata) {
         listbuf, begin,
         (struct location){.line = begin.line, .col = begin.col + nchars},
         (struct text_property){.type = TextProperty_Colors,
-                               .colors = (struct text_property_colors){
+                               .data.colors = (struct text_property_colors){
                                    .set_bg = false,
                                    .set_fg = true,
                                    .fg = Color_Green,
@@ -249,7 +269,7 @@ void buffer_to_list_line(struct buffer *buffer, void *userdata) {
         (struct location){.line = begin.line,
                           .col = begin.col + 24 + nchars_path},
         (struct text_property){.type = TextProperty_Colors,
-                               .colors = (struct text_property_colors){
+                               .data.colors = (struct text_property_colors){
                                    .set_bg = false,
                                    .set_fg = true,
                                    .fg = Color_Blue,
@@ -259,12 +279,16 @@ void buffer_to_list_line(struct buffer *buffer, void *userdata) {
         listbuf, (struct location){.line = begin.line, .col = 0},
         (struct location){.line = begin.line,
                           .col = buffer_line_length(listbuf, begin.line)},
-        (struct text_property){.type = TextProperty_Data, .userdata = buffer});
+        (struct text_property){.type = TextProperty_Data,
+                               .data.userdata = buffer});
   }
 }
 
 int32_t buflist_visit_cmd(struct command_ctx ctx, int argc,
                           const char *argv[]) {
+  (void)argc;
+  (void)argv;
+
   struct window *w = ctx.active_window;
 
   struct buffer_view *bv = window_buffer_view(w);
@@ -275,7 +299,7 @@ int32_t buflist_visit_cmd(struct command_ctx ctx, int argc,
   for (uint32_t propi = 0; propi < nprops; ++propi) {
     struct text_property *p = props[propi];
     if (p->type == TextProperty_Data) {
-      window_set_buffer(w, p->userdata);
+      window_set_buffer(w, p->data.userdata);
       return 0;
     }
   }
@@ -300,6 +324,8 @@ void buflist_refresh(struct buffer *buffer, void *userdata) {
 
 int32_t buflist_refresh_cmd(struct command_ctx ctx, int argc,
                             const char *argv[]) {
+  (void)argc;
+  (void)argv;
   buflist_refresh(window_buffer(ctx.active_window), ctx.buffers);
   return 0;
 }
@@ -310,6 +336,9 @@ static struct command buflist_refresh_command = {
 };
 
 int32_t buflist_kill_cmd(struct command_ctx ctx, int argc, const char *argv[]) {
+  (void)argc;
+  (void)argv;
+
   struct window *w = ctx.active_window;
 
   struct buffer_view *bv = window_buffer_view(w);
@@ -333,6 +362,9 @@ int32_t buflist_kill_cmd(struct command_ctx ctx, int argc, const char *argv[]) {
 }
 
 int32_t buffer_list(struct command_ctx ctx, int argc, const char *argv[]) {
+  (void)argc;
+  (void)argv;
+
   struct buffer *b = buffers_find(ctx.buffers, "*buffers*");
   if (b == NULL) {
     b = buffers_add(ctx.buffers, buffer_create("*buffers*"));
@@ -373,7 +405,7 @@ int32_t buffer_list(struct command_ctx ctx, int argc, const char *argv[]) {
   return 0;
 }
 
-static void find_file_comp_inserted() { minibuffer_execute(); }
+static void find_file_comp_inserted(void) { minibuffer_execute(); }
 
 static int32_t open_file(struct buffers *buffers, struct window *active_window,
                          const char *pth) {
@@ -412,14 +444,13 @@ static int32_t open_file(struct buffers *buffers, struct window *active_window,
 }
 
 int32_t find_file(struct command_ctx ctx, int argc, const char *argv[]) {
-  const char *pth = NULL;
   if (argc == 0) {
     minibuffer_clear();
     struct completion_provider providers[] = {path_provider()};
     enable_completion(minibuffer_buffer(),
                       ((struct completion_trigger){
                           .kind = CompletionTrigger_Input,
-                          .input =
+                          .data.input =
                               (struct completion_trigger_input){
                                   .nchars = 0, .trigger_initially = true}}),
                       providers, 1, find_file_comp_inserted);
@@ -432,7 +463,7 @@ int32_t find_file(struct command_ctx ctx, int argc, const char *argv[]) {
   return 0;
 }
 
-COMMAND_FN("find-file-internal", find_file, find_file, NULL);
+COMMAND_FN("find-file-internal", find_file, find_file, NULL)
 int32_t find_file_relative(struct command_ctx ctx, int argc,
                            const char *argv[]) {
   struct buffer *b = window_buffer(ctx.active_window);
@@ -450,7 +481,7 @@ int32_t find_file_relative(struct command_ctx ctx, int argc,
     enable_completion(minibuffer_buffer(),
                       ((struct completion_trigger){
                           .kind = CompletionTrigger_Input,
-                          .input =
+                          .data.input =
                               (struct completion_trigger_input){
                                   .nchars = 0, .trigger_initially = true}}),
                       providers, 1, find_file_comp_inserted);
@@ -481,7 +512,8 @@ int32_t find_file_relative(struct command_ctx ctx, int argc,
 }
 
 void register_global_commands(struct commands *commands,
-                              void (*terminate_cb)()) {
+                              void (*terminate_cb)(void)) {
+  g_terminate_cb = terminate_cb;
   struct command global_commands[] = {
       {.name = "find-file", .fn = find_file},
       {.name = "find-file-relative", .fn = find_file_relative},
@@ -492,7 +524,7 @@ void register_global_commands(struct commands *commands,
       {.name = "abort", .fn = _abort},
       {.name = "timers", .fn = timers},
       {.name = "buffer-list", .fn = buffer_list},
-      {.name = "exit", .fn = exit_editor, .userdata = terminate_cb}};
+      {.name = "exit", .fn = exit_editor}};
 
   register_commands(commands, global_commands,
                     sizeof(global_commands) / sizeof(global_commands[0]));
@@ -505,6 +537,8 @@ void teardown_global_commands(void) { cleanup_search_replace(); }
 #define BUFFER_VIEW_WRAPCMD(fn)                                                \
   static int32_t fn##_cmd(struct command_ctx ctx, int argc,                    \
                           const char *argv[]) {                                \
+    (void)argc;                                                                \
+    (void)argv;                                                                \
     buffer_view_##fn(window_buffer_view(ctx.active_window));                   \
     return 0;                                                                  \
   }
@@ -512,51 +546,59 @@ void teardown_global_commands(void) { cleanup_search_replace(); }
 #define BUFFER_WRAPCMD(fn)                                                     \
   static int32_t fn##_cmd(struct command_ctx ctx, int argc,                    \
                           const char *argv[]) {                                \
+    (void)argc;                                                                \
+    (void)argv;                                                                \
     buffer_##fn(window_buffer(ctx.active_window));                             \
     return 0;                                                                  \
   }
 
-BUFFER_WRAPCMD(to_file);
-BUFFER_WRAPCMD(reload);
-BUFFER_VIEW_WRAPCMD(kill_line);
-BUFFER_VIEW_WRAPCMD(forward_delete_char);
-BUFFER_VIEW_WRAPCMD(backward_delete_char);
-BUFFER_VIEW_WRAPCMD(delete_word);
-BUFFER_VIEW_WRAPCMD(backward_char);
-BUFFER_VIEW_WRAPCMD(backward_word);
-BUFFER_VIEW_WRAPCMD(forward_char);
-BUFFER_VIEW_WRAPCMD(forward_word);
-BUFFER_VIEW_WRAPCMD(backward_line);
-BUFFER_VIEW_WRAPCMD(forward_line);
-BUFFER_VIEW_WRAPCMD(goto_end_of_line);
-BUFFER_VIEW_WRAPCMD(goto_beginning_of_line);
-BUFFER_VIEW_WRAPCMD(newline);
-BUFFER_VIEW_WRAPCMD(indent);
-BUFFER_VIEW_WRAPCMD(indent_alt);
-BUFFER_VIEW_WRAPCMD(set_mark);
-BUFFER_VIEW_WRAPCMD(clear_mark);
-BUFFER_VIEW_WRAPCMD(copy);
-BUFFER_VIEW_WRAPCMD(cut);
-BUFFER_VIEW_WRAPCMD(paste);
-BUFFER_VIEW_WRAPCMD(paste_older);
-BUFFER_VIEW_WRAPCMD(goto_beginning);
-BUFFER_VIEW_WRAPCMD(goto_end);
-BUFFER_VIEW_WRAPCMD(undo);
-BUFFER_VIEW_WRAPCMD(sort_lines);
+BUFFER_WRAPCMD(to_file)
+BUFFER_WRAPCMD(reload)
+BUFFER_VIEW_WRAPCMD(kill_line)
+BUFFER_VIEW_WRAPCMD(forward_delete_char)
+BUFFER_VIEW_WRAPCMD(backward_delete_char)
+BUFFER_VIEW_WRAPCMD(delete_word)
+BUFFER_VIEW_WRAPCMD(backward_char)
+BUFFER_VIEW_WRAPCMD(backward_word)
+BUFFER_VIEW_WRAPCMD(forward_char)
+BUFFER_VIEW_WRAPCMD(forward_word)
+BUFFER_VIEW_WRAPCMD(backward_line)
+BUFFER_VIEW_WRAPCMD(forward_line)
+BUFFER_VIEW_WRAPCMD(goto_end_of_line)
+BUFFER_VIEW_WRAPCMD(goto_beginning_of_line)
+BUFFER_VIEW_WRAPCMD(newline)
+BUFFER_VIEW_WRAPCMD(indent)
+BUFFER_VIEW_WRAPCMD(indent_alt)
+BUFFER_VIEW_WRAPCMD(set_mark)
+BUFFER_VIEW_WRAPCMD(clear_mark)
+BUFFER_VIEW_WRAPCMD(copy)
+BUFFER_VIEW_WRAPCMD(cut)
+BUFFER_VIEW_WRAPCMD(paste)
+BUFFER_VIEW_WRAPCMD(paste_older)
+BUFFER_VIEW_WRAPCMD(goto_beginning)
+BUFFER_VIEW_WRAPCMD(goto_end)
+BUFFER_VIEW_WRAPCMD(undo)
+BUFFER_VIEW_WRAPCMD(sort_lines)
 
 static int32_t scroll_up_cmd(struct command_ctx ctx, int argc,
                              const char *argv[]) {
+  (void)argc;
+  (void)argv;
+
   buffer_view_backward_nlines(window_buffer_view(ctx.active_window),
                               window_height(ctx.active_window) - 1);
   return 0;
-};
+}
 
 static int32_t scroll_down_cmd(struct command_ctx ctx, int argc,
                                const char *argv[]) {
+  (void)argc;
+  (void)argv;
+
   buffer_view_forward_nlines(window_buffer_view(ctx.active_window),
                              window_height(ctx.active_window) - 1);
   return 0;
-};
+}
 
 static int32_t goto_line(struct command_ctx ctx, int argc, const char *argv[]) {
   // don't want to goto line in minibuffer
@@ -574,7 +616,7 @@ static int32_t goto_line(struct command_ctx ctx, int argc, const char *argv[]) {
   if (line < 0) {
     uint32_t nlines = buffer_num_lines(v->buffer);
     line = -line;
-    line = line >= nlines ? 0 : nlines - line;
+    line = (uint32_t)line >= nlines ? 0 : nlines - line;
   } else if (line > 0) {
     line = line - 1;
   }
@@ -623,12 +665,18 @@ void register_buffer_commands(struct commands *commands) {
 
 static int32_t window_close_cmd(struct command_ctx ctx, int argc,
                                 const char *argv[]) {
+  (void)argc;
+  (void)argv;
+
   window_close(ctx.active_window);
   return 0;
 }
 
 static int32_t window_split_cmd(struct command_ctx ctx, int argc,
                                 const char *argv[]) {
+  (void)argc;
+  (void)argv;
+
   struct window *resa, *resb;
   window_split(ctx.active_window, &resa, &resb);
   return 0;
@@ -636,6 +684,9 @@ static int32_t window_split_cmd(struct command_ctx ctx, int argc,
 
 static int32_t window_hsplit_cmd(struct command_ctx ctx, int argc,
                                  const char *argv[]) {
+  (void)argc;
+  (void)argv;
+
   struct window *resa, *resb;
   window_hsplit(ctx.active_window, &resa, &resb);
   return 0;
@@ -643,6 +694,9 @@ static int32_t window_hsplit_cmd(struct command_ctx ctx, int argc,
 
 static int32_t window_vsplit_cmd(struct command_ctx ctx, int argc,
                                  const char *argv[]) {
+  (void)argc;
+  (void)argv;
+
   struct window *resa, *resb;
   window_vsplit(ctx.active_window, &resa, &resb);
   return 0;
@@ -650,12 +704,19 @@ static int32_t window_vsplit_cmd(struct command_ctx ctx, int argc,
 
 static int32_t window_close_others_cmd(struct command_ctx ctx, int argc,
                                        const char *argv[]) {
+  (void)argc;
+  (void)argv;
+
   window_close_others(ctx.active_window);
   return 0;
 }
 
 static int32_t window_focus_next_cmd(struct command_ctx ctx, int argc,
                                      const char *argv[]) {
+  (void)ctx;
+  (void)argc;
+  (void)argv;
+
   windows_focus_next();
   return 0;
 }
@@ -676,6 +737,9 @@ static int32_t window_focus_cmd(struct command_ctx ctx, int argc,
 
 static int32_t window_focus_n_cmd(struct command_ctx ctx, int argc,
                                   const char *argv[]) {
+  (void)argc;
+  (void)argv;
+
   char *window_id = (char *)ctx.userdata;
   const char *argv_[] = {window_id};
   return window_focus_cmd(ctx, 1, argv_);
@@ -730,15 +794,15 @@ int32_t settings_set_cmd(struct command_ctx ctx, int argc, const char *argv[]) {
     struct setting_value new_value = {.type = setting->value.type};
     switch (setting->value.type) {
     case Setting_Bool:
-      new_value.bool_value = strncmp("true", value, 4) == 0 ||
-                             strncmp("yes", value, 3) == 0 ||
-                             strncmp("on", value, 2) == 0;
+      new_value.data.bool_value = strncmp("true", value, 4) == 0 ||
+                                  strncmp("yes", value, 3) == 0 ||
+                                  strncmp("on", value, 2) == 0;
       break;
     case Setting_Number:
-      new_value.number_value = atol(value);
+      new_value.data.number_value = atol(value);
       break;
     case Setting_String:
-      new_value.string_value = (char *)value;
+      new_value.data.string_value = (char *)value;
       break;
     }
 
diff --git a/src/main/cmds.h b/src/main/cmds.h
index a258ce5..324842d 100644
--- a/src/main/cmds.h
+++ b/src/main/cmds.h
@@ -1,7 +1,7 @@
 struct commands;
 
 void register_global_commands(struct commands *commands,
-                              void (*terminate_cb)());
+                              void (*terminate_cb)(void));
 void teardown_global_commands(void);
 
 void register_buffer_commands(struct commands *commands);
diff --git a/src/main/completion.c b/src/main/completion.c
index 4ffbc46..7a002ac 100644
--- a/src/main/completion.c
+++ b/src/main/completion.c
@@ -38,7 +38,7 @@ struct completion_state {
 
 static struct buffer *g_target_buffer = NULL;
 
-static void hide_completion();
+static void hide_completion(void);
 
 static bool is_space(const struct codepoint *c) {
   // TODO: utf8 whitespace and other whitespace
@@ -67,15 +67,15 @@ static struct completion_provider g_commands_provider = {
     .userdata = NULL,
 };
 
-struct completion_provider path_provider() {
+struct completion_provider path_provider(void) {
   return g_path_provider;
 }
 
-struct completion_provider buffer_provider() {
+struct completion_provider buffer_provider(void) {
   return g_buffer_provider;
 }
 
-struct completion_provider commands_provider() {
+struct completion_provider commands_provider(void) {
   return g_commands_provider;
 }
 
@@ -89,6 +89,10 @@ VEC(struct active_completion) g_active_completions;
 
 static int32_t goto_next_completion(struct command_ctx ctx, int argc,
                                     const char *argv[]) {
+  (void)ctx;
+  (void)argc;
+  (void)argv;
+
   if (g_state.current_completion < g_state.ncompletions - 1) {
     ++g_state.current_completion;
   }
@@ -104,6 +108,10 @@ static int32_t goto_next_completion(struct command_ctx ctx, int argc,
 
 static int32_t goto_prev_completion(struct command_ctx ctx, int argc,
                                     const char *argv[]) {
+  (void)ctx;
+  (void)argc;
+  (void)argv;
+
   if (g_state.current_completion > 0) {
     --g_state.current_completion;
   }
@@ -119,6 +127,10 @@ static int32_t goto_prev_completion(struct command_ctx ctx, int argc,
 
 static int32_t insert_completion(struct command_ctx ctx, int argc,
                                  const char *argv[]) {
+  (void)ctx;
+  (void)argc;
+  (void)argv;
+
   // is it in the popup?
   struct completion *comp = &g_state.completions[g_state.current_completion];
   bool done = comp->complete;
@@ -135,7 +147,7 @@ static int32_t insert_completion(struct command_ctx ctx, int argc,
   return 0;
 }
 
-static void clear_completions() {
+static void clear_completions(void) {
   for (uint32_t ci = 0; ci < g_state.ncompletions; ++ci) {
     free((void *)g_state.completions[ci].display);
     free((void *)g_state.completions[ci].insert);
@@ -146,9 +158,9 @@ static void clear_completions() {
   g_state.ncompletions = 0;
 }
 
-COMMAND_FN("next-completion", next_completion, goto_next_completion, NULL);
-COMMAND_FN("prev-completion", prev_completion, goto_prev_completion, NULL);
-COMMAND_FN("insert-completion", insert_completion, insert_completion, NULL);
+COMMAND_FN("next-completion", next_completion, goto_next_completion, NULL)
+COMMAND_FN("prev-completion", prev_completion, goto_prev_completion, NULL)
+COMMAND_FN("insert-completion", insert_completion, insert_completion, NULL)
 
 static void update_completions(struct buffer *buffer,
                                struct active_completion_ctx *ctx,
@@ -246,7 +258,7 @@ static void on_buffer_insert(struct buffer *buffer,
 
       ctx->trigger_current_nchars += nchars;
 
-      if (ctx->trigger_current_nchars < ctx->trigger.input.nchars) {
+      if (ctx->trigger_current_nchars < ctx->trigger.data.input.nchars) {
         return;
       }
 
@@ -267,6 +279,9 @@ static void on_buffer_insert(struct buffer *buffer,
 }
 
 static void update_completion_buffer(struct buffer *buffer, void *userdata) {
+  (void)buffer;
+  (void)userdata;
+
   buffer_add_text_property(
       g_target_buffer,
       (struct location){.line = g_state.current_completion, .col = 0},
@@ -274,7 +289,7 @@ static void update_completion_buffer(struct buffer *buffer, void *userdata) {
                         .col = buffer_line_length(g_target_buffer,
                                                   g_state.current_completion)},
       (struct text_property){.type = TextProperty_Colors,
-                             .colors = (struct text_property_colors){
+                             .data.colors = (struct text_property_colors){
                                  .set_bg = false,
                                  .bg = 0,
                                  .set_fg = true,
@@ -352,7 +367,7 @@ void enable_completion(struct buffer *source, struct completion_trigger trigger,
 
   // do we want to trigger initially?
   if (ctx->trigger.kind == CompletionTrigger_Input &&
-      ctx->trigger.input.trigger_initially) {
+      ctx->trigger.data.input.trigger_initially) {
     struct oneshot_completion *comp =
         calloc(1, sizeof(struct oneshot_completion));
     comp->ctx = ctx;
@@ -361,7 +376,7 @@ void enable_completion(struct buffer *source, struct completion_trigger trigger,
   }
 }
 
-static void hide_completion() {
+static void hide_completion(void) {
   windows_close_popup();
   if (g_state.active) {
     buffer_remove_keymap(g_state.keymap_id);
@@ -369,13 +384,13 @@ static void hide_completion() {
   }
 }
 
-void abort_completion() {
+void abort_completion(void) {
   hide_completion();
   g_state.active = false;
   clear_completions();
 }
 
-bool completion_active() {
+bool completion_active(void) {
   return popup_window_visible() &&
          window_buffer(popup_window()) == g_target_buffer && g_state.active;
 }
@@ -391,7 +406,7 @@ static void cleanup_active_comp_ctx(void *userdata) {
   free(ctx);
 }
 
-static void do_nothing(void *userdata) {}
+static void do_nothing(void *userdata) { (void)userdata; }
 
 static void cleanup_active_completion(struct active_completion *comp) {
   buffer_remove_delete_hook(comp->buffer, comp->remove_hook_id, do_nothing);
@@ -410,7 +425,7 @@ void disable_completion(struct buffer *buffer) {
   }
 }
 
-void destroy_completion() {
+void destroy_completion(void) {
   // clean up any active completions we might have
   VEC_FOR_EACH(&g_active_completions, struct active_completion * comp) {
     cleanup_active_completion(comp);
@@ -429,10 +444,10 @@ static int cmp_completions(const void *comp_a, const void *comp_b) {
 }
 
 static uint32_t complete_path(struct completion_context ctx, void *userdata) {
+  (void)userdata;
 
   // obtain path from the buffer
   struct text_chunk txt = {0};
-  uint32_t start_idx = 0;
   if (ctx.buffer == minibuffer_buffer()) {
     txt = minibuffer_content();
   } else {
@@ -455,7 +470,6 @@ static uint32_t complete_path(struct completion_context ctx, void *userdata) {
 
   uint32_t n = 0;
   char *p1 = to_abspath(path);
-  size_t len = strlen(p1);
   char *p2 = strdup(p1);
 
   size_t inlen = strlen(path);
@@ -553,7 +567,6 @@ static uint32_t complete_buffers(struct completion_context ctx,
   }
 
   struct text_chunk txt = {0};
-  uint32_t start_idx = 0;
   if (ctx.buffer == minibuffer_buffer()) {
     txt = minibuffer_content();
   } else {
@@ -608,7 +621,6 @@ static uint32_t complete_commands(struct completion_context ctx,
     return 0;
   }
   struct text_chunk txt = {0};
-  uint32_t start_idx = 0;
   if (ctx.buffer == minibuffer_buffer()) {
     txt = minibuffer_content();
   } else {
diff --git a/src/main/completion.h b/src/main/completion.h
index 28871b9..f2ce186 100644
--- a/src/main/completion.h
+++ b/src/main/completion.h
@@ -97,10 +97,10 @@ struct completion_trigger_input {
 struct completion_trigger {
   /** Type of trigger. */
   enum completion_trigger_kind kind;
-  union {
+  union completion_trigger_data {
     uint32_t c;
     struct completion_trigger_input input;
-  };
+  } data;
 };
 
 /**
@@ -114,12 +114,12 @@ void init_completion(struct buffers *buffers, struct commands *commands);
 /**
  * Tear down the completion system.
  */
-void destroy_completion();
+void destroy_completion(void);
 
 /**
  * Callback for completion inserted.
  */
-typedef void (*insert_cb)();
+typedef void (*insert_cb)(void);
 
 /**
  * Enable completions in the buffer @p source.
@@ -141,7 +141,7 @@ void enable_completion(struct buffer *source, struct completion_trigger trigger,
  * This provider completes filesystem paths.
  * @returns A filesystem path @ref completion_provider.
  */
-struct completion_provider path_provider();
+struct completion_provider path_provider(void);
 
 /**
  * Create a new buffer completion provider.
@@ -150,7 +150,7 @@ struct completion_provider path_provider();
  * buffer list.
  * @returns A buffer name @ref completion_provider.
  */
-struct completion_provider buffer_provider();
+struct completion_provider buffer_provider(void);
 
 /**
  * Create a new command completion provider.
@@ -158,19 +158,19 @@ struct completion_provider buffer_provider();
  * This provider completes registered command names.
  * @returns A command name @ref completion_provider.
  */
-struct completion_provider commands_provider();
+struct completion_provider commands_provider(void);
 
 /**
  * Abort any active completion.
  */
-void abort_completion();
+void abort_completion(void);
 
 /**
  * Is a completion currently showing?
  *
  * @returns True if the completion window is showing completions.
  */
-bool completion_active();
+bool completion_active(void);
 
 /**
  * Disable completion for @ref buffer.
diff --git a/src/main/lsp.c b/src/main/lsp.c
new file mode 100644
index 0000000..d56ca07
--- /dev/null
+++ b/src/main/lsp.c
@@ -0,0 +1,108 @@
+#include "lsp.h"
+
+#include "dged/buffer.h"
+#include "dged/buffers.h"
+#include "dged/hash.h"
+#include "dged/hashmap.h"
+#include "dged/lsp.h"
+#include "dged/minibuffer.h"
+#include "dged/reactor.h"
+#include "dged/settings.h"
+
+HASHMAP_ENTRY_TYPE(lsp_entry, struct lsp *);
+
+HASHMAP(struct lsp_entry) g_lsp_clients;
+
+static struct create_data {
+  struct reactor *reactor;
+  struct buffers *buffers;
+} g_create_data;
+
+static void log_message(int type, struct s8 msg) {
+  (void)type;
+  message("%s", msg);
+}
+
+static void create_lsp_client(struct buffer *buffer, void *userdata) {
+  (void)userdata;
+
+  struct create_data *data = &g_create_data;
+  const char *id = buffer->lang.id;
+  HASHMAP_GET(&g_lsp_clients, struct lsp_entry, id, struct lsp * *lsp);
+  if (lsp == NULL) {
+    // we need to start a new server
+    struct setting *s = lang_setting(&buffer->lang, "language-server");
+    if (!s) { // no language server set
+      return;
+    }
+
+    char *const command[] = {s->value.data.string_value, NULL};
+
+    char bufname[1024] = {0};
+    snprintf(bufname, 1024, "*%s-lsp-stderr*", command[0]);
+    struct buffer *stderr_buf = buffers_find(data->buffers, bufname);
+    if (stderr_buf == NULL) {
+      struct buffer buf = buffer_create(bufname);
+      buf.lazy_row_add = false;
+      stderr_buf = buffers_add(data->buffers, buf);
+      buffer_set_readonly(stderr_buf, true);
+    }
+
+    struct lsp_client client_impl = {
+        .log_message = log_message,
+    };
+    struct lsp *new_lsp =
+        lsp_create(command, data->reactor, stderr_buf, client_impl, NULL);
+
+    if (new_lsp == NULL) {
+      minibuffer_echo("failed to create language server %s", command[0]);
+      buffers_remove(data->buffers, bufname);
+      return;
+    }
+
+    HASHMAP_APPEND(&g_lsp_clients, struct lsp_entry, id,
+                   struct lsp_entry * new);
+    new->value = new_lsp;
+
+    if (lsp_start_server(new_lsp) < 0) {
+      minibuffer_echo("failed to start language server %s process.",
+                      lsp_server_name(new_lsp));
+      return;
+    }
+  }
+}
+
+static void set_default_lsp(const char *lang_id, const char *server) {
+  struct language l = lang_from_id(lang_id);
+  if (!lang_is_fundamental(&l)) {
+    lang_setting_set_default(
+        &l, "language-server",
+        (struct setting_value){.type = Setting_String,
+                               .data.string_value = (char *)server});
+    lang_destroy(&l);
+  }
+}
+
+void lang_servers_init(struct reactor *reactor, struct buffers *buffers) {
+  HASHMAP_INIT(&g_lsp_clients, 32, hash_name);
+
+  set_default_lsp("c", "clangd");
+  set_default_lsp("rs", "rust-analyzer");
+  set_default_lsp("python", "pylsp");
+
+  g_create_data.reactor = reactor;
+  g_create_data.buffers = buffers;
+  buffer_add_create_hook(create_lsp_client, NULL);
+}
+
+void lang_servers_update(void) {
+  HASHMAP_FOR_EACH(&g_lsp_clients, struct lsp_entry * e) {
+    lsp_update(e->value, NULL, 0);
+  }
+}
+
+void lang_servers_teardown(void) {
+  HASHMAP_FOR_EACH(&g_lsp_clients, struct lsp_entry * e) {
+    lsp_stop_server(e->value);
+  }
+}
diff --git a/src/main/lsp.h b/src/main/lsp.h
new file mode 100644
index 0000000..736282d
--- /dev/null
+++ b/src/main/lsp.h
@@ -0,0 +1,11 @@
+#ifndef _MAIN_LSP_H
+#define _MAIN_LSP_H
+
+struct reactor;
+struct buffers;
+
+void lang_servers_init(struct reactor *reactor, struct buffers *buffers);
+void lang_servers_update(void);
+void lang_servers_teardown(void);
+
+#endif
diff --git a/src/main/main.c b/src/main/main.c
index 45f72cb..fa740e8 100644
--- a/src/main/main.c
+++ b/src/main/main.c
@@ -9,6 +9,8 @@
 #include <time.h>
 #include <unistd.h>
 
+#include "config.h"
+
 #include "dged/allocator.h"
 #include "dged/binding.h"
 #include "dged/buffer.h"
@@ -29,6 +31,10 @@
 #define str(s) #s
 #endif
 
+#ifdef LSP_ENABLE
+#include "lsp.h"
+#endif
+
 #include "bindings.h"
 #include "cmds.h"
 #include "completion.h"
@@ -48,11 +54,16 @@ void *frame_alloc(size_t sz) {
 
 static bool running = true;
 
-void terminate() { running = false; }
+void terminate(void) { running = false; }
+void terminate2(int sig) {
+  (void)sig;
+  running = false;
+}
 
 static struct display *display = NULL;
 static bool display_resized = false;
-void resized() {
+void resized(int sig) {
+  (void)sig;
   if (display != NULL) {
     display_resize(display);
   }
@@ -61,7 +72,9 @@ void resized() {
   signal(SIGWINCH, resized);
 }
 
-void segfault() {
+void segfault(int sig) {
+  (void)sig;
+
   // make an effort to restore the
   // terminal to its former glory
   if (display != NULL) {
@@ -73,7 +86,7 @@ void segfault() {
   abort();
 }
 
-#define INVALID_WATCH -1
+#define INVALID_WATCH (uint32_t) - 1
 
 static void clear_buffer_props(struct buffer *buffer, void *userdata) {
   (void)userdata;
@@ -139,13 +152,13 @@ void update_file_watches(struct reactor *reactor) {
   }
 }
 
-static void usage() {
+static void usage(void) {
   printf("dged - a text editor for datagubbar/datagummor!\n");
   printf("usage: dged [-l/--line line_number] [-e/--end] [-h/--help] "
          "[filename]\n");
 }
 
-static void version() {
+static void version(void) {
   printf("dged - %s\n© Albert Cervin 2024\n", DGED_VERSION);
 }
 
@@ -194,7 +207,7 @@ int main(int argc, char *argv[]) {
 
   setlocale(LC_ALL, "");
 
-  signal(SIGTERM, terminate);
+  signal(SIGTERM, terminate2);
   signal(SIGSEGV, segfault);
 
   struct commands commands = command_registry_create(32);
@@ -212,7 +225,8 @@ int main(int argc, char *argv[]) {
     int32_t ret = settings_from_file(settings_file_abs, &errmsgs);
     if (ret > 0) {
       fprintf(stderr, "Error reading settings from %s:\n", settings_file_abs);
-      for (uint32_t erri = 0; erri < ret; ++erri) {
+      uint32_t nerrors = (uint32_t)ret;
+      for (uint32_t erri = 0; erri < nerrors; ++erri) {
         fprintf(stderr, "  - %s", errmsgs[erri]);
         free(errmsgs[erri]);
       }
@@ -266,7 +280,7 @@ int main(int argc, char *argv[]) {
   struct setting *path_setting = settings_get("editor.grammars-path");
   char *settings_path = NULL;
   if (path_setting != NULL && path_setting->value.type == Setting_String) {
-    settings_path = path_setting->value.string_value;
+    settings_path = path_setting->value.data.string_value;
   }
   const char *builtin_path = join_path(xstr(DATADIR), "grammars");
 
@@ -309,6 +323,10 @@ int main(int argc, char *argv[]) {
   free((void *)builtin_path);
 #endif
 
+#ifdef LSP_ENABLE
+  lang_servers_init(reactor, &buflist);
+#endif
+
   struct buffer initial_buffer = buffer_create("welcome");
   if (filename != NULL) {
     buffer_destroy(&initial_buffer);
@@ -394,7 +412,6 @@ int main(int argc, char *argv[]) {
     struct keyboard_update kbd_upd =
         keyboard_update(&kbd, reactor, frame_alloc);
 
-    uint32_t input_data_idx = 0;
     for (uint32_t ki = 0; ki < kbd_upd.nkeys; ++ki) {
       struct key *k = &kbd_upd.keys[ki];
 
@@ -416,15 +433,15 @@ int main(int argc, char *argv[]) {
       if (res.found) {
         switch (res.type) {
         case BindingType_Command: {
-          if (res.command == NULL) {
+          if (res.data.command == NULL) {
             minibuffer_echo_timeout(
                 4, "binding found for key %s but not command", k);
           } else {
-            int32_t ec = execute_command(res.command, &commands, active_window,
-                                         &buflist, 0, NULL);
+            int32_t ec = execute_command(res.data.command, &commands,
+                                         active_window, &buflist, 0, NULL);
             if (ec != 0 && !minibuffer_displaying()) {
               minibuffer_echo_timeout(4, "command %s failed with exit code %d",
-                                      res.command->name, ec);
+                                      res.data.command->name, ec);
             }
           }
           current_keymap = NULL;
@@ -443,7 +460,7 @@ int main(int argc, char *argv[]) {
             minibuffer_echo("%s", keyname);
           }
 
-          current_keymap = res.keymap;
+          current_keymap = res.data.keymap;
           break;
         }
         }
@@ -469,6 +486,10 @@ int main(int argc, char *argv[]) {
 
     update_file_watches(reactor);
 
+#if defined(LSP_ENABLE)
+    lang_servers_update();
+#endif
+
     // calculate frame time
     frame_time = timer_average(update_windows) +
                  timer_average(update_keyboard) + timer_average(update_display);
@@ -489,6 +510,10 @@ int main(int argc, char *argv[]) {
   syntax_teardown();
 #endif
 
+#ifdef LSP_ENABLE
+  lang_servers_teardown();
+#endif
+
   display_clear(display);
   display_destroy(display);
   destroy_bindings();
diff --git a/src/main/search-replace.c b/src/main/search-replace.c
index 50beb1e..32c514c 100644
--- a/src/main/search-replace.c
+++ b/src/main/search-replace.c
@@ -45,6 +45,55 @@ static struct search {
   buffer_keymap_id keymap_id;
 } g_current_search = {0};
 
+static void highlight_match(struct buffer *buffer, struct region match,
+                            bool current) {
+  if (current) {
+    buffer_add_text_property(
+        buffer, match.begin, match.end,
+        (struct text_property){.type = TextProperty_Colors,
+                               .data.colors = (struct text_property_colors){
+                                   .set_bg = true,
+                                   .bg = 3,
+                                   .set_fg = true,
+                                   .fg = 0,
+                               }});
+
+  } else {
+    buffer_add_text_property(
+        buffer, match.begin, match.end,
+        (struct text_property){.type = TextProperty_Colors,
+                               .data.colors = (struct text_property_colors){
+                                   .set_bg = true,
+                                   .bg = 6,
+                                   .set_fg = true,
+                                   .fg = 0,
+                               }});
+  }
+}
+
+static void search_highlight_hook(struct buffer *buffer, void *userdata) {
+  (void)userdata;
+
+  for (uint32_t matchi = 0; matchi < g_current_search.nmatches; ++matchi) {
+    highlight_match(buffer, g_current_search.matches[matchi],
+                    matchi == g_current_search.current_match);
+  }
+}
+
+static void replace_highlight_hook(struct buffer *buffer, void *userdata) {
+  (void)userdata;
+
+  for (uint32_t matchi = 0; matchi < g_current_replace.nmatches; ++matchi) {
+    struct match *m = &g_current_replace.matches[matchi];
+    if (m->state != Todo) {
+      continue;
+    }
+
+    highlight_match(buffer, m->region,
+                    matchi == g_current_replace.current_match);
+  }
+}
+
 static void clear_replace(void) {
   buffer_remove_keymap(g_current_replace.keymap_id);
   free(g_current_replace.matches);
@@ -89,6 +138,36 @@ void abort_search(void) {
   minibuffer_abort_prompt();
 }
 
+static void start_search(struct buffer *buffer, const char *pattern) {
+  if (buffer != g_current_search.buffer) {
+    clear_search();
+  }
+
+  g_current_search.buffer = buffer;
+  g_current_search.active = true;
+
+  // if we are in a new buffer, add the update hook for it.
+  if (g_current_search.highlight_hook == (uint32_t)-1) {
+    g_current_search.highlight_hook =
+        buffer_add_update_hook(buffer, search_highlight_hook, NULL);
+  }
+
+  // replace the pattern if needed
+  if (g_current_search.pattern == NULL ||
+      !s8eq(s8(g_current_search.pattern), s8(pattern))) {
+    char *new_pattern = strdup(pattern);
+    free(g_current_search.pattern);
+    g_current_search.pattern = new_pattern;
+  }
+
+  // clear out any old search results
+  if (g_current_search.matches != NULL) {
+    free(g_current_search.matches);
+    g_current_search.matches = NULL;
+    g_current_search.nmatches = 0;
+  }
+}
+
 uint64_t matchdist(struct region *match, struct location loc) {
   struct location begin = match->begin;
 
@@ -98,64 +177,21 @@ uint64_t matchdist(struct region *match, struct location loc) {
   // into the line it is, otherwise check the distance from location
   int64_t coldist = begin.col;
   if (linedist == 0) {
-    int64_t coldist = (int64_t)begin.col - (int64_t)loc.col;
+    coldist = (int64_t)begin.col - (int64_t)loc.col;
   }
 
   // arbitrary row scaling, best effort to avoid counting line length
+  // this is not technically correct if you have lines longer than
+  // 1e6 but otoh, that seems excessive
   return (linedist * linedist) * 1e6 + coldist * coldist;
 }
 
-static void highlight_match(struct buffer *buffer, struct region match,
-                            bool current) {
-  if (current) {
-    buffer_add_text_property(
-        buffer, match.begin, match.end,
-        (struct text_property){.type = TextProperty_Colors,
-                               .colors = (struct text_property_colors){
-                                   .set_bg = true,
-                                   .bg = 3,
-                                   .set_fg = true,
-                                   .fg = 0,
-                               }});
-
-  } else {
-    buffer_add_text_property(
-        buffer, match.begin, match.end,
-        (struct text_property){.type = TextProperty_Colors,
-                               .colors = (struct text_property_colors){
-                                   .set_bg = true,
-                                   .bg = 6,
-                                   .set_fg = true,
-                                   .fg = 0,
-                               }});
-  }
-}
-
-static void search_highlight_hook(struct buffer *buffer, void *userdata) {
-  (void)userdata;
-
-  for (uint32_t matchi = 0; matchi < g_current_search.nmatches; ++matchi) {
-    highlight_match(buffer, g_current_search.matches[matchi],
-                    matchi == g_current_search.current_match);
-  }
-}
-
-static void replace_highlight_hook(struct buffer *buffer, void *userdata) {
-  (void)userdata;
-
-  for (uint32_t matchi = 0; matchi < g_current_replace.nmatches; ++matchi) {
-    struct match *m = &g_current_replace.matches[matchi];
-    if (m->state != Todo) {
-      continue;
-    }
-
-    highlight_match(buffer, m->region,
-                    matchi == g_current_replace.current_match);
-  }
-}
-
 static int32_t replace_next(struct command_ctx ctx, int argc,
                             const char *argv[]) {
+  (void)ctx;
+  (void)argc;
+  (void)argv;
+
   struct replace *state = &g_current_replace;
   struct buffer_view *buffer_view = window_buffer_view(state->window);
   struct buffer *buffer = buffer_view->buffer;
@@ -207,6 +243,10 @@ static int32_t replace_next(struct command_ctx ctx, int argc,
 }
 
 static int32_t skip_next(struct command_ctx ctx, int argc, const char *argv[]) {
+  (void)ctx;
+  (void)argc;
+  (void)argv;
+
   struct replace *state = &g_current_replace;
 
   struct buffer_view *buffer_view = window_buffer_view(state->window);
@@ -230,8 +270,8 @@ static int32_t skip_next(struct command_ctx ctx, int argc, const char *argv[]) {
   return 0;
 }
 
-COMMAND_FN("replace-next", replace_next, replace_next, NULL);
-COMMAND_FN("skip-next", skip_next, skip_next, NULL);
+COMMAND_FN("replace-next", replace_next, replace_next, NULL)
+COMMAND_FN("skip-next", skip_next, skip_next, NULL)
 
 static int cmp_matches(const void *m1, const void *m2) {
   struct region *match1 = (struct region *)m1;
@@ -350,35 +390,9 @@ static struct region *find_closest(struct region *matches, uint32_t nmatches,
   return closest;
 }
 
-static void do_search(struct buffer_view *view, const char *pattern,
+static bool do_search(struct buffer_view *view, const char *pattern,
                       bool reverse) {
-  if (view->buffer != g_current_search.buffer) {
-    clear_search();
-  }
-
-  g_current_search.buffer = view->buffer;
-  g_current_search.active = true;
-
-  // if we are in a new buffer, add the update hook for it.
-  if (g_current_search.highlight_hook == (uint32_t)-1) {
-    g_current_search.highlight_hook =
-        buffer_add_update_hook(view->buffer, search_highlight_hook, NULL);
-  }
-
-  // replace the pattern if needed
-  if (g_current_search.pattern == NULL ||
-      !s8eq(s8(g_current_search.pattern), s8(pattern))) {
-    char *new_pattern = strdup(pattern);
-    free(g_current_search.pattern);
-    g_current_search.pattern = new_pattern;
-  }
-
-  // clear out any old search results first
-  if (g_current_search.matches != NULL) {
-    free(g_current_search.matches);
-    g_current_search.matches = NULL;
-    g_current_search.nmatches = 0;
-  }
+  start_search(view->buffer, pattern);
 
   buffer_find(view->buffer, g_current_search.pattern, &g_current_search.matches,
               &g_current_search.nmatches);
@@ -391,10 +405,10 @@ static void do_search(struct buffer_view *view, const char *pattern,
                      view->dot, reverse, &closest_idx);
     buffer_view_goto(view, closest->begin);
     g_current_search.current_match = closest_idx;
-  } else {
-    abort_search();
-    minibuffer_echo_timeout(4, "%s not found", pattern);
+    return true;
   }
+
+  return false;
 }
 
 static const char *get_pattern() {
@@ -424,12 +438,18 @@ int32_t search_interactive(struct command_ctx ctx, int argc,
   }
 
   minibuffer_set_prompt(search_prompt(*(bool *)ctx.userdata));
+  buffer_view_goto_end(window_buffer_view(minibuffer_window()));
 
   if (pattern != NULL) {
-    do_search(window_buffer_view(minibuffer_target_window()), pattern,
-              *(bool *)ctx.userdata);
+    if (!do_search(window_buffer_view(minibuffer_target_window()), pattern,
+                   *(bool *)ctx.userdata)) {
+      abort_search();
+      minibuffer_echo_timeout(4, "%s not found", pattern);
+    }
+
     free((char *)pattern);
   }
+
   return 0;
 }
 
@@ -437,11 +457,13 @@ static bool search_dir_backward = true;
 static bool search_dir_forward = false;
 
 COMMAND_FN("search-forward", search_forward, search_interactive,
-           &search_dir_forward);
+           &search_dir_forward)
 COMMAND_FN("search-backward", search_backward, search_interactive,
-           &search_dir_backward);
+           &search_dir_backward)
 
 int32_t find(struct command_ctx ctx, int argc, const char *argv[]) {
+  (void)argv;
+
   bool reverse = *(bool *)ctx.userdata;
   if (argc == 0) {
     struct binding bindings[] = {
@@ -454,17 +476,21 @@ int32_t find(struct command_ctx ctx, int argc, const char *argv[]) {
     return minibuffer_prompt(ctx, search_prompt(reverse));
   }
 
+  // allow enter to end the interactive search
   if (g_current_search.active) {
     abort_search();
     return 0;
   }
 
   buffer_remove_keymap(g_current_search.keymap_id);
-  do_search(window_buffer_view(ctx.active_window), argv[0], reverse);
+  bool found =
+      do_search(window_buffer_view(ctx.active_window), argv[0], reverse);
 
-  if (g_current_search.active) {
-    abort_search();
+  abort_search();
+  if (!found) {
+    minibuffer_echo_timeout(4, "%s not found", argv[0]);
   }
+
   return 0;
 }
 
@@ -481,11 +507,10 @@ void register_search_replace_commands(struct commands *commands) {
 }
 
 void cleanup_search_replace(void) {
+  clear_replace();
   clear_search();
   if (g_current_search.pattern != NULL) {
     free(g_current_search.pattern);
     g_current_search.pattern = NULL;
   }
-
-  clear_replace();
 }
diff --git a/src/main/search-replace.h b/src/main/search-replace.h
index 16869fc..ef5e0dc 100644
--- a/src/main/search-replace.h
+++ b/src/main/search-replace.h
@@ -3,7 +3,7 @@ struct commands;
 /**
  * Abort a replace currently in progress.
  */
-void abort_replace();
+void abort_replace(void);
 
 /**
  * Abort a search currently in progress.