diff --git a/.clang-format b/.clang-format
index f4edc74..d456f16 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,2 +1,4 @@
-BasedOnStyle: LLVM
+BasedOnStyle: Chromium
 IndentWidth: 2
+SpacesBeforeTrailingComments: 1
+AllowShortIfStatementsOnASingleLine: WithoutElse
diff --git a/include/auth.h b/include/auth.h
index 8f7b850..c3ef186 100644
--- a/include/auth.h
+++ b/include/auth.h
@@ -6,7 +6,10 @@
 #include "config.h"
 #include "sessions.h"
 
-bool launch(char *user, char *passwd, struct session session, void (*cb)(void),
-            struct behavior *behavior);
+bool launch(char* user,
+            char* passwd,
+            struct session session,
+            void (*cb)(void),
+            struct behavior* behavior);
 
 #endif
diff --git a/include/chvt.h b/include/chvt.h
index 0637b22..a39af33 100644
--- a/include/chvt.h
+++ b/include/chvt.h
@@ -20,6 +20,6 @@ int chvt(int n);
  * @param str virtual terminal number (string)
  * @return int non-negative value on success
  */
-int chvt_str(char *str);
+int chvt_str(char* str);
 
 #endif
diff --git a/include/config.h b/include/config.h
index a9fa05d..5ad3fd0 100644
--- a/include/config.h
+++ b/include/config.h
@@ -10,32 +10,32 @@
 // should be ansi escape codes under \x1b[...m
 // if not prepared accordingly, it might break
 struct theme_colors {
-  char *bg;
-  char *fg;
-  char *err;
-  char *s_wayland;
-  char *s_xorg;
-  char *s_shell;
-  char *e_hostname;
-  char *e_date;
-  char *e_box;
-  char *e_header;
-  char *e_user;
-  char *e_passwd;
-  char *e_badpasswd;
-  char *e_key;
+  char* bg;
+  char* fg;
+  char* err;
+  char* s_wayland;
+  char* s_xorg;
+  char* s_shell;
+  char* e_hostname;
+  char* e_date;
+  char* e_box;
+  char* e_header;
+  char* e_user;
+  char* e_passwd;
+  char* e_badpasswd;
+  char* e_key;
 };
 
 // even if they're multiple bytes long
 // they should only take up 1 char size on display
 struct theme_chars {
-  char *hb;
-  char *vb;
+  char* hb;
+  char* vb;
 
-  char *ctl;
-  char *ctr;
-  char *cbl;
-  char *cbr;
+  char* ctl;
+  char* ctr;
+  char* cbl;
+  char* cbr;
 };
 
 struct theme {
@@ -50,14 +50,14 @@ struct functions {
 };
 
 struct strings {
-  char *f_poweroff;
-  char *f_reboot;
-  char *f_refresh;
-  char *e_user;
-  char *e_passwd;
-  char *s_wayland;
-  char *s_xorg;
-  char *s_shell;
+  char* f_poweroff;
+  char* f_reboot;
+  char* f_refresh;
+  char* e_user;
+  char* e_passwd;
+  char* s_wayland;
+  char* s_xorg;
+  char* s_shell;
 };
 
 struct behavior {
@@ -74,9 +74,10 @@ struct config {
 };
 
 bool line_parser(
-    FILE *fd, ssize_t *blksize,
-    u_char (*cb)(char *key,
-                 char *value)); // might use this for parsing .desktop files too
-struct config *parse_config(char *path);
+    FILE* fd,
+    ssize_t* blksize,
+    u_char (*cb)(char* key,
+                 char* value)); // might use this for parsing .desktop files too
+struct config* parse_config(char* path);
 
 #endif
diff --git a/include/efield.h b/include/efield.h
index 68b1db0..ed03c32 100644
--- a/include/efield.h
+++ b/include/efield.h
@@ -10,9 +10,9 @@ struct editable_field {
   char content[255];
 };
 
-struct editable_field field_new(char *);
-void field_trim(struct editable_field *, u_char);
-void field_update(struct editable_field *, char *);
-bool field_seek(struct editable_field *, char);
+struct editable_field field_new(char*);
+void field_trim(struct editable_field*, u_char);
+void field_update(struct editable_field*, char*);
+bool field_seek(struct editable_field*, char);
 
 #endif
diff --git a/include/keys.h b/include/keys.h
index cd34031..51aaacc 100644
--- a/include/keys.h
+++ b/include/keys.h
@@ -34,7 +34,7 @@ enum keys {
   PAGE_DOWN,
 };
 
-static const char *const key_names[] = {
+static const char* const key_names[] = {
     [ESC] = "ESC",
     [F1] = "F1",
     [F2] = "F2",
@@ -67,7 +67,7 @@ static const char *const key_names[] = {
 
 struct key_mapping {
   enum keys key;
-  const char *sequences[3];
+  const char* sequences[3];
 };
 
 static const struct key_mapping key_mappings[] = {
diff --git a/include/sessions.h b/include/sessions.h
index c632a88..108c0bc 100644
--- a/include/sessions.h
+++ b/include/sessions.h
@@ -12,9 +12,9 @@ enum session_type {
 };
 
 struct session {
-  char *name;
-  char *exec;
-  char *tryexec;
+  char* name;
+  char* exec;
+  char* tryexec;
   enum session_type type;
 };
 
diff --git a/include/ui.h b/include/ui.h
index 5798850..a7f7bec 100644
--- a/include/ui.h
+++ b/include/ui.h
@@ -5,8 +5,8 @@
 #include "util.h"
 
 void setup(struct config);
-int load(struct Vector *users, struct Vector *sessions);
-void print_err(const char *);
-void print_errno(const char *);
+int load(struct Vector* users, struct Vector* sessions);
+void print_err(const char*);
+void print_errno(const char*);
 
 #endif
diff --git a/include/users.h b/include/users.h
index 8344833..0a2eda0 100644
--- a/include/users.h
+++ b/include/users.h
@@ -6,9 +6,9 @@
 #include "util.h"
 
 struct user {
-  char *shell;
-  char *username;
-  char *display_name;
+  char* shell;
+  char* username;
+  char* display_name;
 };
 
 struct Vector get_human_users();
diff --git a/include/util.h b/include/util.h
index a868865..5965a31 100644
--- a/include/util.h
+++ b/include/util.h
@@ -8,26 +8,26 @@
 
 #include "keys.h"
 
-enum keys find_keyname(char *);
-enum keys find_ansi(char *);
-void read_press(u_char *, char *);
-void strcln(char **dest, const char *source);
+enum keys find_keyname(char*);
+enum keys find_ansi(char*);
+void read_press(u_char*, char*);
+void strcln(char** dest, const char* source);
 
 struct Vector {
   uint32_t length;
   uint32_t capacity;
-  void **pages;
+  void** pages;
 };
 
 struct Vector vec_new();
-int vec_resize(struct Vector *, size_t size);
-int vec_reserve(struct Vector *, size_t size);
-int vec_reserve_exact(struct Vector *, size_t size);
-int vec_push(struct Vector *, void *item);
-void vec_free(struct Vector *);
-void vec_clear(struct Vector *);
-void vec_reset(struct Vector *);
-void *vec_pop(struct Vector *); // won't free it, nor shrink vec list space
-void *vec_get(struct Vector *, size_t index);
+int vec_resize(struct Vector*, size_t size);
+int vec_reserve(struct Vector*, size_t size);
+int vec_reserve_exact(struct Vector*, size_t size);
+int vec_push(struct Vector*, void* item);
+void vec_free(struct Vector*);
+void vec_clear(struct Vector*);
+void vec_reset(struct Vector*);
+void* vec_pop(struct Vector*); // won't free it, nor shrink vec list space
+void* vec_get(struct Vector*, size_t index);
 
 #endif
diff --git a/src/auth.c b/src/auth.c
index e041a89..01bdaa2 100644
--- a/src/auth.c
+++ b/src/auth.c
@@ -15,16 +15,18 @@
 #include "unistd.h"
 #include "util.h"
 
-int pam_conversation(int num_msg, const struct pam_message **msg,
-                     struct pam_response **resp, void *appdata_ptr) {
-  struct pam_response *reply =
-      (struct pam_response *)malloc(sizeof(struct pam_response) * num_msg);
+int pam_conversation(int num_msg,
+                     const struct pam_message** msg,
+                     struct pam_response** resp,
+                     void* appdata_ptr) {
+  struct pam_response* reply =
+      (struct pam_response*)malloc(sizeof(struct pam_response) * num_msg);
   for (size_t i = 0; i < num_msg; i++) {
     reply[i].resp = NULL;
     reply[i].resp_retcode = 0;
     if (msg[i]->msg_style == PAM_PROMPT_ECHO_OFF ||
         msg[i]->msg_style == PAM_PROMPT_ECHO_ON) {
-      char *input = (char *)appdata_ptr;
+      char* input = (char*)appdata_ptr;
       reply[i].resp = strdup(input);
     }
   }
@@ -32,18 +34,20 @@ int pam_conversation(int num_msg, const struct pam_message **msg,
   return PAM_SUCCESS;
 }
 
-#define CHECK_PAM_RET(call)                                                    \
-  ret = (call);                                                                \
-  if (ret != PAM_SUCCESS) {                                                    \
-    pam_end(pamh, ret);                                                        \
-    return NULL;                                                               \
+#define CHECK_PAM_RET(call) \
+  ret = (call);             \
+  if (ret != PAM_SUCCESS) { \
+    pam_end(pamh, ret);     \
+    return NULL;            \
   }
 
-void clear_screen() { printf("\x1b[H\x1b[J"); }
+void clear_screen() {
+  printf("\x1b[H\x1b[J");
+}
 
-pam_handle_t *get_pamh(char *user, char *passwd) {
-  pam_handle_t *pamh = NULL;
-  struct pam_conv pamc = {pam_conversation, (void *)passwd};
+pam_handle_t* get_pamh(char* user, char* passwd) {
+  pam_handle_t* pamh = NULL;
+  struct pam_conv pamc = {pam_conversation, (void*)passwd};
   int ret;
 
   CHECK_PAM_RET(pam_start("login", user, &pamc, &pamh))
@@ -57,25 +61,22 @@ pam_handle_t *get_pamh(char *user, char *passwd) {
 }
 #undef CHECK_PAM_RET
 
-void *shmalloc(size_t size) {
+void* shmalloc(size_t size) {
   return mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS,
               -1, 0);
 }
 
-void sourceFileTry(char *file) {
-  FILE *file2source = fopen(file, "r");
-  if (file2source == NULL)
-    return;
+void sourceFileTry(char* file) {
+  FILE* file2source = fopen(file, "r");
+  if (file2source == NULL) return;
 
-  char *line = NULL;
+  char* line = NULL;
   size_t len = 0;
   ssize_t read;
 
   while ((read = getline(&line, &len, file2source)) != -1) {
-    if (read == 0 || (read > 0 && *line == '#'))
-      continue;
-    if (line[read - 1] == '\n')
-      line[read - 1] = '\0';
+    if (read == 0 || (read > 0 && *line == '#')) continue;
+    if (line[read - 1] == '\n') line[read - 1] = '\0';
 
     /* printf("Retrieved line of length %zu:\n", read); */
     /* printf("%s\n", line); */
@@ -89,15 +90,15 @@ void sourceFileTry(char *file) {
     }
   }
 
-  if (line)
-    free(line);
+  if (line) free(line);
   fclose(file2source);
 }
 
-void moarEnv(char *user, struct session session, struct passwd *pw,
-             struct behavior *behavior) {
-  if (chdir(pw->pw_dir) == -1)
-    print_errno("can't chdir to user home");
+void moarEnv(char* user,
+             struct session session,
+             struct passwd* pw,
+             struct behavior* behavior) {
+  if (chdir(pw->pw_dir) == -1) print_errno("can't chdir to user home");
 
   setenv("HOME", pw->pw_dir, true);
   setenv("USER", pw->pw_name, true);
@@ -108,30 +109,26 @@ void moarEnv(char *user, struct session session, struct passwd *pw,
 
   // PATH?
 
-  char *xdg_session_type;
-  if (session.type == SHELL)
-    xdg_session_type = "tty";
-  if (session.type == XORG)
-    xdg_session_type = "x11";
-  if (session.type == WAYLAND)
-    xdg_session_type = "wayland";
+  char* xdg_session_type;
+  if (session.type == SHELL) xdg_session_type = "tty";
+  if (session.type == XORG) xdg_session_type = "x11";
+  if (session.type == WAYLAND) xdg_session_type = "wayland";
   setenv("XDG_SESSION_TYPE", xdg_session_type, true);
 
   printf("\n\n\n\n\x1b[1m");
   for (size_t i = 0; i < behavior->source.length; i++) {
     /* printf("DEBUG(source)!!!! %d %s\n", i, (char*)vec_get(&behavior->source,
      * i)); */
-    sourceFileTry((char *)vec_get(&behavior->source, i));
+    sourceFileTry((char*)vec_get(&behavior->source, i));
   }
   /* printf("\n"); */
   if (pw->pw_dir) {
     uint home_len = strlen(pw->pw_dir);
     for (size_t i = 0; i < behavior->user_source.length; i++) {
-      char *file2sourcepath = (char *)vec_get(&behavior->user_source, i);
-      char *newbuf =
+      char* file2sourcepath = (char*)vec_get(&behavior->user_source, i);
+      char* newbuf =
           malloc(home_len + strlen(file2sourcepath) + 2); // nullbyte and slash
-      if (newbuf == NULL)
-        continue; // can't bother
+      if (newbuf == NULL) continue;                       // can't bother
       strcpy(newbuf, pw->pw_dir);
       newbuf[home_len] = '/'; // assume pw_dir doesn't start with '/' :P
       strcpy(&newbuf[home_len + 1], file2sourcepath);
@@ -153,21 +150,24 @@ void moarEnv(char *user, struct session session, struct passwd *pw,
   /*setenv("XDG_SEAT", "seat0", true);*/
 }
 
-bool launch(char *user, char *passwd, struct session session, void (*cb)(void),
-            struct behavior *behavior) {
-  struct passwd *pw = getpwnam(user);
+bool launch(char* user,
+            char* passwd,
+            struct session session,
+            void (*cb)(void),
+            struct behavior* behavior) {
+  struct passwd* pw = getpwnam(user);
   if (pw == NULL) {
     print_err("could not get user info");
     return false;
   }
 
-  pam_handle_t *pamh = get_pamh(user, passwd);
+  pam_handle_t* pamh = get_pamh(user, passwd);
   if (pamh == NULL) {
     print_err("error on pam authentication");
     return false;
   }
 
-  bool *reach_session = shmalloc(sizeof(bool));
+  bool* reach_session = shmalloc(sizeof(bool));
   if (reach_session == NULL) {
     perror("error allocating shared memory");
     return false;
@@ -176,16 +176,15 @@ bool launch(char *user, char *passwd, struct session session, void (*cb)(void),
 
   uint pid = fork();
   if (pid == 0) { // child
-    char *TERM = NULL;
-    char *_GETTERM = getenv("TERM");
-    if (_GETTERM != NULL)
-      strcln(&TERM, _GETTERM);
+    char* TERM = NULL;
+    char* _GETTERM = getenv("TERM");
+    if (_GETTERM != NULL) strcln(&TERM, _GETTERM);
     if (clearenv() != 0) {
       print_errno("clearenv");
       _exit(EXIT_FAILURE);
     }
 
-    char **envlist = pam_getenvlist(pamh);
+    char** envlist = pam_getenvlist(pamh);
     if (envlist == NULL) {
       print_errno("pam_getenvlist");
       _exit(EXIT_FAILURE);
@@ -222,8 +221,7 @@ bool launch(char *user, char *passwd, struct session session, void (*cb)(void),
       _exit(EXIT_FAILURE);
     }
 
-    if (cb != NULL)
-      cb();
+    if (cb != NULL) cb();
 
     *reach_session = true;
 
diff --git a/src/chvt.c b/src/chvt.c
index 34b9346..a0c11bb 100644
--- a/src/chvt.c
+++ b/src/chvt.c
@@ -5,11 +5,11 @@
 
 #include "chvt.h"
 
-static char *vterms[] = {"/dev/tty", "/dev/tty0", "/dev/vc/0", "/dev/systty",
+static char* vterms[] = {"/dev/tty", "/dev/tty0", "/dev/vc/0", "/dev/systty",
                          "/dev/console"};
 
-int chvt_str(char *str) {
-  char *err;
+int chvt_str(char* str) {
+  char* err;
   errno = 0;
   long i = strtol(str, &err, 10);
   if (errno) {
@@ -17,8 +17,7 @@ int chvt_str(char *str) {
     return -1;
   }
   // I'm not gonna elaborate on this....
-  if (i > INT_MAX || i < INT_MIN || *err)
-    return -1;
+  if (i > INT_MAX || i < INT_MIN || *err) return -1;
 
   return chvt((int)i);
 }
diff --git a/src/config.c b/src/config.c
index 9488a23..b16efb6 100644
--- a/src/config.c
+++ b/src/config.c
@@ -11,18 +11,18 @@
 //  0b0100: free the key
 //  0b1000: break out of parsing (returning false)
 //
-// This would return true if everything goes fine, false otherwise (malloc error, broke parsing, etc)
-bool line_parser(FILE *fd, ssize_t *blksize,
-                 u_char (*cb)(char *key, char *value)) {
+// This would return true if everything goes fine, false otherwise (malloc
+// error, broke parsing, etc)
+bool line_parser(FILE* fd,
+                 ssize_t* blksize,
+                 u_char (*cb)(char* key, char* value)) {
   size_t opt_size = 4096;
-  if (blksize != NULL)
-    opt_size = *blksize;
+  if (blksize != NULL) opt_size = *blksize;
 
   while (true) {
     size_t alloc_size = opt_size;
-    char *buf = malloc(alloc_size);
-    if (buf == NULL)
-      return false;
+    char* buf = malloc(alloc_size);
+    if (buf == NULL) return false;
     ssize_t read_size = getline(&buf, &alloc_size, fd);
     if (read_size == -1) {
       free(buf);
@@ -30,22 +30,20 @@ bool line_parser(FILE *fd, ssize_t *blksize,
     }
 
     uint read;
-    char *key = malloc(read_size);
+    char* key = malloc(read_size);
     if (key == NULL) {
       free(buf);
       return false;
     }
-    char *value = malloc(read_size);
+    char* value = malloc(read_size);
     if (value == NULL) {
       free(buf);
       return false;
     }
     if ((read = sscanf(buf, "%[^ ] = %[^\n]\n", key, value)) != 0) {
       u_char ret = cb(key, value);
-      if (ret & 0b0100)
-        free(key);
-      if (ret & 0b0010)
-        free(value);
+      if (ret & 0b0100) free(key);
+      if (ret & 0b0010) free(value);
       if (ret & 0b1000) {
         free(buf);
         return false;
@@ -61,9 +59,9 @@ bool line_parser(FILE *fd, ssize_t *blksize,
   return true;
 }
 
-struct config *__config;
+struct config* __config;
 // Yanderedev code (wanna fix this with a table or smth)
-u_char config_line_handler(char *k, char *v) {
+u_char config_line_handler(char* k, char* v) {
   if (strcmp(k, "colors.bg") == 0)
     __config->theme.colors.bg = v;
   else if (strcmp(k, "colors.fg") == 0)
@@ -142,9 +140,9 @@ u_char config_line_handler(char *k, char *v) {
   return 0b0100;
 }
 
-struct config *parse_config(char *path) {
+struct config* parse_config(char* path) {
   struct stat sb;
-  FILE *fd = fopen(path, "r");
+  FILE* fd = fopen(path, "r");
   if (fd == NULL || (stat(path, &sb) == -1)) {
     perror("fopen");
     return NULL;
@@ -154,9 +152,8 @@ struct config *parse_config(char *path) {
   __config->behavior.source = vec_new();
   __config->behavior.user_source = vec_new();
 
-  if (__config == NULL)
-    return NULL;
-  bool ret = line_parser(fd, (ssize_t *)&sb.st_blksize, config_line_handler);
+  if (__config == NULL) return NULL;
+  bool ret = line_parser(fd, (ssize_t*)&sb.st_blksize, config_line_handler);
   if (!ret) {
     free(__config);
     return NULL;
diff --git a/src/efield.c b/src/efield.c
index c76b2e7..d04eaac 100644
--- a/src/efield.c
+++ b/src/efield.c
@@ -3,7 +3,7 @@
 #include "efield.h"
 #include "ui.h"
 
-struct editable_field field_new(char *content) {
+struct editable_field field_new(char* content) {
   struct editable_field __efield;
   if (content != NULL) {
     __efield.length = __efield.pos = strlen(content);
@@ -15,23 +15,20 @@ struct editable_field field_new(char *content) {
   return __efield;
 }
 
-void field_trim(struct editable_field *field, u_char pos) {
+void field_trim(struct editable_field* field, u_char pos) {
   field->length = field->pos = pos;
   field->content[field->length] = '\0';
 }
 
-void field_update(struct editable_field *field, char *update) {
+void field_update(struct editable_field* field, char* update) {
   u_char insert_len = strlen(update);
-  if (insert_len == 0)
-    return;
+  if (insert_len == 0) return;
 
-  if (field->pos > field->length)
-    field->pos = field->length; // WTF
+  if (field->pos > field->length) field->pos = field->length; // WTF
   if (insert_len == 1) {
     // backspace
     if (*update == 127) {
-      if (field->pos == 0)
-        return;
+      if (field->pos == 0) return;
       if (field->pos < field->length) {
         memmove(&field->content[field->pos - 1], &field->content[field->pos],
                 field->length - field->pos);
@@ -60,9 +57,8 @@ void field_update(struct editable_field *field, char *update) {
 }
 
 // returns bool depending if it was able to "use" the seek
-bool field_seek(struct editable_field *field, char seek) {
-  if (field->length == 0)
-    return false;
+bool field_seek(struct editable_field* field, char seek) {
+  if (field->length == 0) return false;
 
   if (seek < 0 && -seek > field->pos)
     field->pos = 0;
@@ -71,8 +67,7 @@ bool field_seek(struct editable_field *field, char seek) {
   else
     field->pos += seek;
 
-  if (field->pos > field->length)
-    field->pos = field->length;
+  if (field->pos > field->length) field->pos = field->length;
 
   return true;
 }
diff --git a/src/main.c b/src/main.c
index dec1037..2096782 100644
--- a/src/main.c
+++ b/src/main.c
@@ -11,12 +11,11 @@
 #include "users.h"
 #include "util.h"
 
-int main(int argc, char *argv[]) {
-  if (argc == 2)
-    chvt_str(argv[1]);
+int main(int argc, char* argv[]) {
+  if (argc == 2) chvt_str(argv[1]);
 
-  char *conf_override = getenv("LIDM_CONF");
-  struct config *config =
+  char* conf_override = getenv("LIDM_CONF");
+  struct config* config =
       parse_config(conf_override == NULL ? "/etc/lidm.ini" : conf_override);
   if (config == NULL) {
     fprintf(stderr, "error parsing config\n");
@@ -28,6 +27,5 @@ int main(int argc, char *argv[]) {
   struct Vector sessions = get_avaliable_sessions();
 
   int ret = load(&users, &sessions);
-  if (ret == 0)
-    execl(argv[0], argv[0], NULL);
+  if (ret == 0) execl(argv[0], argv[0], NULL);
 }
diff --git a/src/sessions.c b/src/sessions.c
index 7ffeaa0..f4e6a12 100644
--- a/src/sessions.c
+++ b/src/sessions.c
@@ -12,15 +12,17 @@
 
 struct source_dir {
   enum session_type type;
-  char *dir;
+  char* dir;
 };
 static const struct source_dir sources[] = {
     {XORG, "/usr/share/xsessions"},
     {WAYLAND, "/usr/share/wayland-sessions"},
 };
 
-static struct session __new_session(enum session_type type, char *name,
-                                    const char *exec, const char *tryexec) {
+static struct session __new_session(enum session_type type,
+                                    char* name,
+                                    const char* exec,
+                                    const char* tryexec) {
   struct session __session;
   __session.type = type;
   strcln(&__session.name, name);
@@ -30,17 +32,16 @@ static struct session __new_session(enum session_type type, char *name,
   return __session;
 }
 
-static struct Vector *cb_sessions = NULL;
+static struct Vector* cb_sessions = NULL;
 
 // NOTE: commented printf's here would be nice to have debug logs if I ever
 // implement it
 static enum session_type session_type;
-static int fn(const char *fpath, const struct stat *sb, int typeflag) {
-  if (sb == NULL || !S_ISREG(sb->st_mode))
-    return 0;
+static int fn(const char* fpath, const struct stat* sb, int typeflag) {
+  if (sb == NULL || !S_ISREG(sb->st_mode)) return 0;
 
   /*printf("gonna open %s\n", fpath);*/
-  FILE *fd = fopen(fpath, "r");
+  FILE* fd = fopen(fpath, "r");
   if (fd == NULL) {
     perror("fopen");
     fprintf(stderr, "error opening file (r) '%s'\n", fpath);
@@ -50,13 +51,14 @@ static int fn(const char *fpath, const struct stat *sb, int typeflag) {
   u_char found = 0;
   size_t alloc_size = sb->st_blksize;
 
-  char *name_buf = NULL;
-  char *exec_buf = NULL;
-  char *tryexec_buf = NULL;
+  char* name_buf = NULL;
+  char* exec_buf = NULL;
+  char* tryexec_buf = NULL;
   // This should be made a specific function
-  // Emm, if anything goes wrong just free the inner loop and `break;` fd and the rest is handled after
+  // Emm, if anything goes wrong just free the inner loop and `break;` fd and
+  // the rest is handled after
   while (true) {
-    char *buf = malloc(sb->st_blksize);
+    char* buf = malloc(sb->st_blksize);
     ssize_t read_size = getline(&buf, &alloc_size, fd);
     if (read_size == -1) {
       free(buf);
@@ -64,14 +66,14 @@ static int fn(const char *fpath, const struct stat *sb, int typeflag) {
     }
 
     uint read;
-    char *key = malloc(read_size + sizeof(char));
-    if(key == NULL) {
+    char* key = malloc(read_size + sizeof(char));
+    if (key == NULL) {
       free(buf);
       // TODO: more sophisticated error handling??
       break;
     }
-    char *value = malloc(read_size + sizeof(char));
-    if(value == NULL) {
+    char* value = malloc(read_size + sizeof(char));
+    if (value == NULL) {
       free(buf);
       free(key);
       // TODO: more sophisticated error handling??
@@ -106,18 +108,15 @@ static int fn(const char *fpath, const struct stat *sb, int typeflag) {
 
   // just add this to the list
   if (name_buf != NULL && exec_buf != NULL) {
-    struct session *session_i = malloc(sizeof(struct session));
+    struct session* session_i = malloc(sizeof(struct session));
     *session_i = __new_session(session_type, name_buf, exec_buf,
                                tryexec_buf == NULL ? "" : tryexec_buf);
     vec_push(cb_sessions, session_i);
   }
 
-  if (name_buf != NULL)
-    free(name_buf);
-  if (exec_buf != NULL)
-    free(exec_buf);
-  if (tryexec_buf != NULL)
-    free(tryexec_buf);
+  if (name_buf != NULL) free(name_buf);
+  if (exec_buf != NULL) free(exec_buf);
+  if (tryexec_buf != NULL) free(tryexec_buf);
 
   return 0;
 }
diff --git a/src/ui.c b/src/ui.c
index f97f276..d4a552f 100644
--- a/src/ui.c
+++ b/src/ui.c
@@ -90,7 +90,7 @@ static struct uint_point box_start() {
   return __start;
 }
 
-static char *fmt_time() {
+static char* fmt_time() {
   time_t t = time(NULL);
   struct tm tm = *localtime(&t);
 
@@ -98,7 +98,7 @@ static char *fmt_time() {
       snprintf(NULL, 0, "%d-%02d-%02d %02d:%02d:%02d", tm.tm_year + 1900,
                tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec) +
       1;
-  char *buf = malloc(bsize);
+  char* buf = malloc(bsize);
   snprintf(buf, bsize, "%d-%02d-%02d %02d:%02d:%02d", tm.tm_year + 1900,
            tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
   return buf;
@@ -116,7 +116,7 @@ struct opt_field {
   uint current_opt; // 0 is edit mode btw
   struct editable_field efield;
 };
-void print_ofield(struct opt_field *focused_input);
+void print_ofield(struct opt_field* focused_input);
 
 static struct opt_field ofield_new(uint opts) {
   struct opt_field __field;
@@ -128,17 +128,16 @@ static struct opt_field ofield_new(uint opts) {
   }
   return __field;
 }
-static void ofield_toedit(struct opt_field *ofield, char *init) {
+static void ofield_toedit(struct opt_field* ofield, char* init) {
   ofield->current_opt = 0;
   ofield->efield = field_new(init);
 }
-static void ofield_type(struct opt_field *ofield, char *new, char *startstr) {
-  if (ofield->current_opt != 0)
-    ofield_toedit(ofield, startstr);
+static void ofield_type(struct opt_field* ofield, char* new, char* startstr) {
+  if (ofield->current_opt != 0) ofield_toedit(ofield, startstr);
   field_update(&ofield->efield, new);
 }
 // true if it changed anything, single opt fields return false
-static bool ofield_opt_seek(struct opt_field *ofield, char seek) {
+static bool ofield_opt_seek(struct opt_field* ofield, char seek) {
   // TODO: think this
   if (ofield->opts == 0 || (ofield->opts == 1 && ofield->current_opt != 0))
     return false;
@@ -151,22 +150,21 @@ static bool ofield_opt_seek(struct opt_field *ofield, char seek) {
 }
 // true in case it was able to "use" the seek (a empty only editable field
 // wouldn't)
-static bool ofield_seek(struct opt_field *ofield, char seek) {
+static bool ofield_seek(struct opt_field* ofield, char seek) {
   if (ofield->current_opt == 0) {
     if (field_seek(&ofield->efield, seek)) {
       return true;
     }
   }
 
-  if (ofield->opts == 0)
-    return false;
+  if (ofield->opts == 0) return false;
 
   ofield_opt_seek(ofield, seek);
 
   return true;
 }
 
-static u_char ofield_max_displ_pos(struct opt_field *ofield) {
+static u_char ofield_max_displ_pos(struct opt_field* ofield) {
   // TODO: set max cursor pos too
   // keep in mind that also have to keep in mind scrolling and ughhh, mentally
   // blocked, but this is complex
@@ -181,17 +179,14 @@ struct opt_field of_session;
 struct opt_field of_user;
 struct opt_field of_passwd;
 
-struct Vector *gusers;
-struct Vector *gsessions;
+struct Vector* gusers;
+struct Vector* gsessions;
 
 // not *that* OF tho
-struct opt_field *get_of(enum input from) {
-  if (from == SESSION)
-    return &of_session;
-  if (from == USER)
-    return &of_user;
-  if (from == PASSWD)
-    return &of_passwd;
+struct opt_field* get_of(enum input from) {
+  if (from == SESSION) return &of_session;
+  if (from == USER) return &of_user;
+  if (from == PASSWD) return &of_passwd;
   return NULL;
 }
 
@@ -210,7 +205,7 @@ void ffield_cursor_focus() {
   } else if (focused_input == PASSWD)
     line += 9;
 
-  struct opt_field *ofield = get_of(focused_input);
+  struct opt_field* ofield = get_of(focused_input);
   row += ofield->current_opt == 0 ? ofield_max_displ_pos(ofield) : 0;
 
   printf("\x1b[%d;%dH", line, row);
@@ -263,8 +258,10 @@ void print_field(enum input focused_input) {
   ffield_cursor_focus();
 }
 
-void print_ffield() { print_field(focused_input); }
-void print_ofield(struct opt_field *ofield) {
+void print_ffield() {
+  print_field(focused_input);
+}
+void print_ofield(struct opt_field* ofield) {
   enum input input;
   if (ofield == &of_session)
     input = SESSION;
@@ -290,9 +287,8 @@ void ffield_move(bool direction) {
 
 // tf I'm doing
 void ffield_change_opt(bool direction) {
-  struct opt_field *ffield = get_of(focused_input);
-  if (focused_input == PASSWD)
-    ffield = &of_session;
+  struct opt_field* ffield = get_of(focused_input);
+  if (focused_input == PASSWD) ffield = &of_session;
   if (!ofield_opt_seek(ffield, direction ? 1 : -1)) {
     if (focused_input == PASSWD || focused_input == SESSION)
       ofield_opt_seek(&of_user, direction ? 1 : -1);
@@ -301,7 +297,7 @@ void ffield_change_opt(bool direction) {
   }
 }
 void ffield_change_pos(bool direction) {
-  struct opt_field *ffield = get_of(focused_input);
+  struct opt_field* ffield = get_of(focused_input);
   if (!ofield_seek(ffield, direction ? 1 : -1))
     if (!ofield_opt_seek(&of_session, direction ? 1 : -1))
       ofield_opt_seek(&of_user, direction ? 1 : -1);
@@ -309,9 +305,9 @@ void ffield_change_pos(bool direction) {
   ffield_cursor_focus();
 }
 
-void ffield_type(char *text) {
-  struct opt_field *field = get_of(focused_input);
-  char *start = "";
+void ffield_type(char* text) {
+  struct opt_field* field = get_of(focused_input);
+  char* start = "";
   if (focused_input == USER && of_user.current_opt != 0)
     start = get_current_user().username;
   if (focused_input == SESSION && of_session.current_opt != 0 &&
@@ -323,13 +319,13 @@ void ffield_type(char *text) {
 }
 
 static char* unknown_str = "unknown";
-int load(struct Vector *users, struct Vector *sessions) {
+int load(struct Vector* users, struct Vector* sessions) {
   /// SETUP
   gusers = users;
   gsessions = sessions;
 
   // hostnames larger won't render properly
-  char *hostname = malloc(16);
+  char* hostname = malloc(16);
   if (gethostname(hostname, 16) != 0) {
     free(hostname);
     hostname = unknown_str;
@@ -351,10 +347,10 @@ int load(struct Vector *users, struct Vector *sessions) {
   printf("\x1b[%d;%dH\x1b[%sm%s\x1b[%sm", boxstart.y + 2,
          boxstart.x + 12 - (uint)strlen(hostname), theme.colors.e_hostname,
          hostname, theme.colors.fg);
-  if(hostname != unknown_str) free(hostname);
+  if (hostname != unknown_str) free(hostname);
 
   // put date
-  char *fmtd_time = fmt_time();
+  char* fmtd_time = fmt_time();
   printf("\x1b[%d;%dH\x1b[%sm%s\x1b[%sm", boxstart.y + 2,
          boxstart.x + boxw - 3 - (uint)strlen(fmtd_time), theme.colors.e_date,
          fmtd_time, theme.colors.fg);
@@ -407,12 +403,11 @@ int load(struct Vector *users, struct Vector *sessions) {
         ffield_type(seq);
     }
 
-    if (esc != 0)
-      esc--;
+    if (esc != 0) esc--;
   }
 }
 
-static char *line_cleaner = NULL;
+static char* line_cleaner = NULL;
 static void clean_line(struct uint_point origin, uint line) {
   if (line_cleaner == NULL) {
     line_cleaner = malloc((boxw - 2) * sizeof(char) + 1);
@@ -424,10 +419,11 @@ static void clean_line(struct uint_point origin, uint line) {
 }
 
 // TODO: session_len > 32
-static void print_session(struct uint_point origin, struct session session,
+static void print_session(struct uint_point origin,
+                          struct session session,
                           bool multiple) {
   clean_line(origin, 5);
-  const char *session_type;
+  const char* session_type;
   if (session.type == XORG) {
     session_type = strings.s_xorg;
   } else if (session.type == WAYLAND) {
@@ -439,7 +435,7 @@ static void print_session(struct uint_point origin, struct session session,
          (ulong)(origin.x + 11 - strlen(session_type)), theme.colors.e_header,
          session_type, theme.colors.fg);
 
-  char *session_color;
+  char* session_color;
   if (session.type == XORG) {
     session_color = theme.colors.s_xorg;
   } else if (session.type == WAYLAND) {
@@ -458,14 +454,15 @@ static void print_session(struct uint_point origin, struct session session,
 }
 
 // TODO: user_len > 32
-static void print_user(struct uint_point origin, struct user user,
+static void print_user(struct uint_point origin,
+                       struct user user,
                        bool multiple) {
   clean_line(origin, 7);
   printf("\r\x1b[%luC\x1b[%sm%s\x1b[%sm",
          (ulong)(origin.x + 11 - strlen(strings.e_user)), theme.colors.e_header,
          strings.e_user, theme.colors.fg);
 
-  char *user_color = theme.colors.e_user;
+  char* user_color = theme.colors.e_user;
 
   if (multiple) {
     printf("\r\x1b[%dC< \x1b[%sm%s\x1b[%sm >", origin.x + 14, user_color,
@@ -484,7 +481,7 @@ static void print_passwd(struct uint_point origin, uint length, bool err) {
          (ulong)(origin.x + 11 - strlen(strings.e_passwd)),
          theme.colors.e_header, strings.e_passwd, theme.colors.fg);
 
-  char *pass_color;
+  char* pass_color;
   if (err)
     pass_color = theme.colors.e_badpasswd;
   else
@@ -502,13 +499,13 @@ static void print_passwd(struct uint_point origin, uint length, bool err) {
   printf("\x1b[%sm", theme.colors.fg);
 }
 
-static void print_empty_row(uint w, uint n, char *edge1, char *edge2) {
+static void print_empty_row(uint w, uint n, char* edge1, char* edge2) {
   for (size_t i = 0; i < n; i++) {
     printf("%s\x1b[%dC%s\x1b[%dD\x1b[1B", edge1, w, edge2, w + 2);
   }
 }
 
-static void print_row(uint w, uint n, char *edge1, char *edge2, char *filler) {
+static void print_row(uint w, uint n, char* edge1, char* edge2, char* filler) {
   for (size_t i = 0; i < n; i++) {
     printf("%s", edge1);
     for (size_t i = 0; i < w; i++) {
@@ -539,22 +536,23 @@ static void print_footer() {
 
   uint row = window.ws_row - 1;
   uint col = window.ws_col - 2 - bsize;
-  printf("\x1b[%3$d;%4$dH%8$s \x1b[%1$sm%5$s\x1b[%2$sm  %9$s "
-         "\x1b[%1$sm%6$s\x1b[%2$sm  %10$s \x1b[%1$sm%7$s\x1b[%2$sm",
-         theme.colors.e_key, theme.colors.fg, row, col,
-         key_names[functions.poweroff], key_names[functions.reboot],
-         key_names[functions.refresh], strings.f_poweroff, strings.f_reboot,
-         strings.f_refresh);
+  printf(
+      "\x1b[%3$d;%4$dH%8$s \x1b[%1$sm%5$s\x1b[%2$sm  %9$s "
+      "\x1b[%1$sm%6$s\x1b[%2$sm  %10$s \x1b[%1$sm%7$s\x1b[%2$sm",
+      theme.colors.e_key, theme.colors.fg, row, col,
+      key_names[functions.poweroff], key_names[functions.reboot],
+      key_names[functions.refresh], strings.f_poweroff, strings.f_reboot,
+      strings.f_refresh);
   fflush(stdout);
 }
 
-void print_err(const char *msg) {
+void print_err(const char* msg) {
   struct uint_point origin = box_start();
   fprintf(stderr, "\x1b[%d;%dH%s(%d): %s", origin.y - 1, origin.x, msg, errno,
           strerror(errno));
 }
 
-void print_errno(const char *descr) {
+void print_errno(const char* descr) {
   struct uint_point origin = box_start();
   if (descr == NULL)
     fprintf(stderr, "\x1b[%d;%dH\x1b[%smunknown error(%d): %s", origin.y - 1,
diff --git a/src/users.c b/src/users.c
index 7cc3a7c..fcb9903 100644
--- a/src/users.c
+++ b/src/users.c
@@ -8,7 +8,7 @@
 #include "users.h"
 #include "util.h"
 
-static struct user __new_user(struct passwd *p) {
+static struct user __new_user(struct passwd* p) {
   struct user __user;
   strcln(&__user.shell, p->pw_shell);
   strcln(&__user.username, p->pw_name);
@@ -25,12 +25,11 @@ struct Vector get_human_users() {
   struct Vector users = vec_new();
   vec_reserve(&users, 4);
 
-  struct passwd *pwd;
+  struct passwd* pwd;
   while ((pwd = getpwent()) != NULL) {
-    if (!(pwd->pw_dir && strncmp(pwd->pw_dir, "/home/", 6) == 0))
-      continue;
+    if (!(pwd->pw_dir && strncmp(pwd->pw_dir, "/home/", 6) == 0)) continue;
 
-    struct user *user_i = malloc(sizeof(struct user));
+    struct user* user_i = malloc(sizeof(struct user));
     *user_i = __new_user(pwd);
     vec_push(&users, user_i);
   }
diff --git a/src/util.c b/src/util.c
index d5138c7..d23c741 100644
--- a/src/util.c
+++ b/src/util.c
@@ -11,22 +11,21 @@
 
 static int selret_magic();
 
-void strcln(char **dest, const char *source) {
+void strcln(char** dest, const char* source) {
   *dest = malloc(strlen(source) + sizeof(char));
   strcpy(*dest, source);
 }
 
-enum keys find_keyname(char *name) {
+enum keys find_keyname(char* name) {
   for (size_t i = 0; i < sizeof(key_mappings) / sizeof(key_mappings[0]); i++) {
-    if (strcmp(key_names[i], name) == 0)
-      return (enum keys)i;
+    if (strcmp(key_names[i], name) == 0) return (enum keys)i;
   }
 
   perror("key not found");
   exit(1);
 }
 
-enum keys find_ansi(char *seq) {
+enum keys find_ansi(char* seq) {
   for (size_t i = 0; i < sizeof(key_mappings) / sizeof(key_mappings[0]); i++) {
     struct key_mapping mapping = key_mappings[i];
     for (size_t j = 0; mapping.sequences[j] != NULL; j++) {
@@ -39,7 +38,7 @@ enum keys find_ansi(char *seq) {
 }
 
 // https://stackoverflow.com/a/48040042
-void read_press(u_char *length, char *out) {
+void read_press(u_char* length, char* out) {
   *length = 0;
 
   while (true) {
@@ -75,11 +74,10 @@ struct Vector vec_new() {
   return vec;
 }
 
-int vec_resize(struct Vector *vec, size_t size) {
-  void **new_location = realloc(vec->pages, size * sizeof(void*));
+int vec_resize(struct Vector* vec, size_t size) {
+  void** new_location = realloc(vec->pages, size * sizeof(void*));
   if (new_location != NULL) {
-    if (vec->length > size)
-      vec->length = size;
+    if (vec->length > size) vec->length = size;
     vec->capacity = size;
     vec->pages = new_location;
   } else {
@@ -88,15 +86,16 @@ int vec_resize(struct Vector *vec, size_t size) {
   return 0;
 }
 
-int vec_reserve(struct Vector *vec, size_t size) {
+int vec_reserve(struct Vector* vec, size_t size) {
   uint32_t new_capacity = vec->capacity;
   while (vec->length + size > new_capacity) {
-    new_capacity = new_capacity + (new_capacity >> 1) + 1; // cap * 1.5 + 1; 0 1 2 4 7 11...
+    new_capacity = new_capacity + (new_capacity >> 1) +
+                   1; // cap * 1.5 + 1; 0 1 2 4 7 11...
   }
   return vec_resize(vec, new_capacity);
 }
 
-int vec_reserve_exact(struct Vector *vec, size_t size) {
+int vec_reserve_exact(struct Vector* vec, size_t size) {
   uint32_t needed_capacity = vec->length + size;
   if (vec->capacity < needed_capacity) {
     return vec_resize(vec, needed_capacity);
@@ -105,42 +104,40 @@ int vec_reserve_exact(struct Vector *vec, size_t size) {
   }
 }
 
-int vec_push(struct Vector *vec, void *item) {
+int vec_push(struct Vector* vec, void* item) {
   int res_ret = vec_reserve(vec, 1);
-  if(res_ret != 0) return res_ret;
+  if (res_ret != 0) return res_ret;
 
   vec->pages[vec->length++] = item;
   return 0;
 }
 
-void vec_free(struct Vector *vec) {
+void vec_free(struct Vector* vec) {
   while (vec->length > 0)
     free(vec->pages[--vec->length]);
 
   vec_clear(vec);
 }
 
-void vec_clear(struct Vector *vec) {
+void vec_clear(struct Vector* vec) {
   free(vec->pages);
   vec_reset(vec);
 }
 
-void vec_reset(struct Vector *vec) {
+void vec_reset(struct Vector* vec) {
   vec->length = 0;
   vec->capacity = 0;
   vec->pages = NULL;
 }
 
-void *vec_pop(struct Vector *vec) {
-  if (vec->length == 0)
-    return NULL;
+void* vec_pop(struct Vector* vec) {
+  if (vec->length == 0) return NULL;
 
   return vec->pages[--vec->length];
 }
 
-void *vec_get(struct Vector *vec, size_t index) {
-  if (index >= vec->length)
-    return NULL;
+void* vec_get(struct Vector* vec, size_t index) {
+  if (index >= vec->length) return NULL;
 
   return vec->pages[index];
 }