diff --git a/src/model/obj.c b/src/model/obj.c
index da2c492..861e4ee 100644
--- a/src/model/obj.c
+++ b/src/model/obj.c
@@ -5,8 +5,7 @@
 #include "vec.h"
 #include <stdio.h>
 
-Model load_obj_file(Arena *arena, const char *filename, const char *diffuse,
-                    const char *tangent) {
+Model load_obj_file(Arena *arena, const char *filename, const char *diffuse, const char *tangent) {
   if (!arena) {
     return INVALID_MODEL;
   }
@@ -22,8 +21,7 @@ Model load_obj_file(Arena *arena, const char *filename, const char *diffuse,
       .texture_coordinates = list_create(V2f, arena),
       .triangles           = list_create(Triangle, arena),
   };
-  if (!(model.vertices) || !(model.normals) || !(model.texture_coordinates) ||
-      !(model.triangles)) {
+  if (!(model.vertices) || !(model.normals) || !(model.texture_coordinates) || !(model.triangles)) {
     return INVALID_MODEL;
   }
 
diff --git a/src/model/obj.h b/src/model/obj.h
index 2505ddb..cb4eb03 100644
--- a/src/model/obj.h
+++ b/src/model/obj.h
@@ -50,15 +50,14 @@ struct point_light {
 
 typedef struct model Model;
 struct model {
-  LIST_TYPE(V3f) * vertices;
-  LIST_TYPE(V3f) * normals;
-  LIST_TYPE(V2f) * texture_coordinates;
-  LIST_TYPE(Triangle) * triangles;
-  Image *texture;
-  Image *normal;
+  LIST_TYPE(V3f)      *vertices;
+  LIST_TYPE(V3f)      *normals;
+  LIST_TYPE(V2f)      *texture_coordinates;
+  LIST_TYPE(Triangle) *triangles;
+  Image               *texture;
+  Image               *normal;
 };
 
-Model load_obj_file(Arena *arena, const char *filename, const char *diffuse,
-                    const char *tangent);
+Model load_obj_file(Arena *arena, const char *filename, const char *diffuse, const char *tangent);
 
 #endif // OBJ_H
diff --git a/src/model/render.c b/src/model/render.c
index dfb9eff..1325e73 100644
--- a/src/model/render.c
+++ b/src/model/render.c
@@ -16,16 +16,13 @@ struct triangle_bbox {
   u64 y1;
 };
 
-internal void render_triangle(const Triangle *triangle, const Model *model,
-                              ShaderID shader, Render *render,
-                              RenderType render_type, Colour colour);
-internal void fill_triangle(Render *render, ShaderID shader,
-                            VertexData vertices[TRIANGLE_VERTICES],
-                            Colour colour, const Model *model, RenderType type);
-internal TriangleBBox get_triangle_bbox(const Image *img,
-                                        V2f vertices[TRIANGLE_VERTICES]);
-internal V3f get_barycentric_coords(V2f a, V2f b, V2f c, V2f p);
-internal V2f get_viewport_vertex(const V3f *vertex, const Image *img);
+internal void         render_triangle(const Triangle *triangle, const Model *model, ShaderID shader,
+                                      Render *render, RenderType render_type, Colour colour);
+internal void         fill_triangle(Render *render, ShaderID shader, VertexData vertices[TRIANGLE_VERTICES],
+                                    Colour colour, const Model *model, RenderType type);
+internal TriangleBBox get_triangle_bbox(const Image *img, V2f vertices[TRIANGLE_VERTICES]);
+internal V3f          get_barycentric_coords(V2f a, V2f b, V2f c, V2f p);
+internal V2f          get_viewport_vertex(const V3f *vertex, const Image *img);
 
 bool init_render(Arena *arena, Render *render, u64 width, u64 height) {
   render->img = (Image){.width = width, .height = height};
@@ -53,9 +50,8 @@ void render_model(const Model *model, Render *render, ShaderID shader,
   }
 }
 
-internal void render_triangle(const Triangle *triangle, const Model *model,
-                              ShaderID shader, Render *render,
-                              RenderType render_type, Colour colour) {
+internal void render_triangle(const Triangle *triangle, const Model *model, ShaderID shader,
+															Render *render, RenderType render_type, Colour colour) {
   Image *img = &(render->img);
   VertexData vertices[TRIANGLE_VERTICES];
   for (u64 i = 0; i < TRIANGLE_VERTICES; ++i) {
@@ -80,11 +76,9 @@ internal void render_triangle(const Triangle *triangle, const Model *model,
   }
 }
 
-internal void fill_triangle(Render *render, ShaderID shader,
-                            VertexData vertices[TRIANGLE_VERTICES],
-                            Colour colour, const Model *model,
-                            RenderType type) {
-  Image *img = &(render->img);
+internal void fill_triangle(Render *render, ShaderID shader, VertexData vertices[TRIANGLE_VERTICES],
+                            Colour colour, const Model *model, RenderType type) {
+  Image *img   = &(render->img);
   Depth *depth = &(render->depth);
 
   V2f vp_verts[TRIANGLE_VERTICES] = {0};
@@ -94,10 +88,10 @@ internal void fill_triangle(Render *render, ShaderID shader,
 
   TriangleBBox bbox = get_triangle_bbox(img, vp_verts);
 
-  V2f point;
-  V3f coords;
-  f32 z;
-  f32 zbuf;
+  V2f            point;
+  V3f            coords;
+  f32            z;
+  f32            zbuf;
   FragmentResult result;
 
   f32 intensity = 1.0f;
@@ -110,10 +104,10 @@ internal void fill_triangle(Render *render, ShaderID shader,
         continue;
       }
 
-      z     = 0.0f;
+      z    = 0.0f;
       z    += vertices[0].position.z * coords.x +
-           vertices[1].position.z * coords.y +
-           vertices[2].position.z * coords.z;
+              vertices[1].position.z * coords.y +
+              vertices[2].position.z * coords.z;
       zbuf = get_pixel(f32, &(render->depth), x, y);
 
       if (z <= zbuf) {
@@ -131,8 +125,7 @@ internal void fill_triangle(Render *render, ShaderID shader,
   }
 }
 
-internal TriangleBBox get_triangle_bbox(const Image *img,
-                                        V2f vertices[TRIANGLE_VERTICES]) {
+internal TriangleBBox get_triangle_bbox(const Image *img, V2f vertices[TRIANGLE_VERTICES]) {
   f32 x0 = min(vertices[0].x, min(vertices[1].x, vertices[2].x));
   f32 x1 = max(vertices[0].x, max(vertices[1].x, vertices[2].x));
   f32 y0 = min(vertices[0].y, min(vertices[1].y, vertices[2].y));
diff --git a/src/shader/depth_shader.c b/src/shader/depth_shader.c
index c2a8b48..9534151 100644
--- a/src/shader/depth_shader.c
+++ b/src/shader/depth_shader.c
@@ -4,8 +4,7 @@
 #include "shader.h"
 #include "utils.h"
 
-VertexData depth_shader_vertex(void *shader, const VertexData *vert, u8 index,
-                               const Model *model) {
+VertexData depth_shader_vertex(void *shader, const VertexData *vert, u8 index, const Model *model) {
   DepthShader *shdr = (DepthShader *)shader;
 
   V4f vh = V3_to_V4(vert->position);
@@ -16,8 +15,8 @@ VertexData depth_shader_vertex(void *shader, const VertexData *vert, u8 index,
   return shdr->vertices[index];
 }
 
-FragmentResult depth_shader_fragment(void *shader, const V3f *barycentric,
-                                     const Colour *colour, const Model *model) {
+FragmentResult depth_shader_fragment(void *shader, const V3f *barycentric, const Colour *colour,
+                                     const Model *model) {
   DepthShader *shdr = (DepthShader *)shader;
 
   // clang-format off
diff --git a/src/shader/depth_shader.h b/src/shader/depth_shader.h
index 5edbd25..208b970 100644
--- a/src/shader/depth_shader.h
+++ b/src/shader/depth_shader.h
@@ -10,9 +10,8 @@ struct depth_shader {
 #include "shader_base.inc"
 };
 
-VertexData depth_shader_vertex(void *shader, const VertexData *vert, u8 index,
-                               const Model *model);
-FragmentResult depth_shader_fragment(void *shader, const V3f *barycentric,
-                                     const Colour *colour, const Model *model);
+VertexData     depth_shader_vertex(void *shader, const VertexData *vert, u8 index, const Model *model);
+FragmentResult depth_shader_fragment(void *shader, const V3f *barycentric, const Colour *colour,
+                                     const Model *model);
 
 #endif // !DEPTH_SHADER_H
diff --git a/src/shader/main_shader.c b/src/shader/main_shader.c
index da95de8..30ad597 100644
--- a/src/shader/main_shader.c
+++ b/src/shader/main_shader.c
@@ -4,8 +4,7 @@
 #include "utils.h"
 #include "vec.h"
 
-VertexData general_shader_vertex(void *shader, const VertexData *vert, u8 index,
-                                 const Model *model) {
+VertexData general_shader_vertex(void *shader, const VertexData *vert, u8 index, const Model *model) {
   Shader *shdr = (Shader *)shader;
 
   V4f vh = V3_to_V4(vert->position);
@@ -24,8 +23,7 @@ VertexData general_shader_vertex(void *shader, const VertexData *vert, u8 index,
   return shdr->vertices[index];
 }
 
-FragmentResult diffuse_shader_fragment(void *shader, const V3f *barycentric,
-                                       const Colour *colour,
+FragmentResult diffuse_shader_fragment(void *shader, const V3f *barycentric, const Colour *colour,
                                        const Model *model) {
   Shader *shdr = (Shader *)shader;
 
@@ -104,8 +102,7 @@ FragmentResult diffuse_shader_fragment(void *shader, const V3f *barycentric,
   return (FragmentResult){.colour = output};
 }
 
-FragmentResult albedo_shader_fragment(void *shader, const V3f *barycentric,
-                                      const Colour *colour,
+FragmentResult albedo_shader_fragment(void *shader, const V3f *barycentric, const Colour *colour,
                                       const Model *model) {
   Shader *shdr = (Shader *)shader;
 
diff --git a/src/shader/main_shader.h b/src/shader/main_shader.h
index 5f5fdfe..3a37563 100644
--- a/src/shader/main_shader.h
+++ b/src/shader/main_shader.h
@@ -9,11 +9,9 @@ struct shader {
 #include "shader_base.inc"
 };
 
-VertexData general_shader_vertex(void *shader, const VertexData *vert, u8 index,
-                                 const Model *model);
-FragmentResult diffuse_shader_fragment(void *shader, const V3f *barycentric,
-                                       const Colour *colour,
+VertexData     general_shader_vertex(void *shader, const VertexData *vert, u8 index, const Model *model);
+FragmentResult diffuse_shader_fragment(void *shader, const V3f *barycentric, const Colour *colour,
                                        const Model *model);
-FragmentResult albedo_shader_fragment(void *shader, const V3f *barycentric,
-                                      const Colour *colour, const Model *model);
+FragmentResult albedo_shader_fragment(void *shader, const V3f *barycentric, const Colour *colour,
+                                      const Model *model);
 #endif // !MAIN_SHADER_H
diff --git a/src/shader/shader.h b/src/shader/shader.h
index 5aa6c6a..381e5aa 100644
--- a/src/shader/shader.h
+++ b/src/shader/shader.h
@@ -21,7 +21,7 @@ struct vertex_data {
 typedef struct fragment_result FragmentResult;
 struct fragment_result {
   Colour colour;
-  bool discard;
+  bool   discard;
 };
 
 #define INVALID_SHADER           ((ShaderID){0})
diff --git a/src/shader/shaders.c b/src/shader/shaders.c
index 71dcce2..f2d13f7 100644
--- a/src/shader/shaders.c
+++ b/src/shader/shaders.c
@@ -12,8 +12,8 @@ ShaderID orthographic_diffuse = {0};
 ShaderID orthographic_albedo  = {0};
 ShaderID depth                = {0};
 
-internal Shader perspective       = {0};
-internal Shader orthographic      = {0};
+internal Shader      perspective  = {0};
+internal Shader      orthographic = {0};
 internal DepthShader depth_shader = {0};
 
 internal V3f g_ambient_light = {0.1f, 0.1f, 0.1f};
diff --git a/src/str/str.c b/src/str/str.c
index 590229b..89106e0 100644
--- a/src/str/str.c
+++ b/src/str/str.c
@@ -6,9 +6,6 @@
 
 #define CAPACITY_SCALAR 4
 
-internal Arena *get_temp_arena(void);
-internal void destroy_temp_arena(Arena *arena);
-
 Str8 str8(Arena *arena, char *str) {
   if (!str) {
     return (Str8){0};
diff --git a/src/str/str.h b/src/str/str.h
index b957689..3377537 100644
--- a/src/str/str.h
+++ b/src/str/str.h
@@ -12,15 +12,15 @@ enum {
 typedef struct str8 Str8;
 struct str8 {
   char *str;
-  u64 length;
-  u64 capacity;
+  u64  length;
+  u64  capacity;
 };
 
 #define str8_lit(STR) (str8(NULL, STR))
 
 Str8 str8(Arena *arena, char *str);
 Str8 str8_copy(Arena *arena, const Str8 *str);
-i32 str8_concat(Arena *arena, Str8 *dst, char *src);
+i32  str8_concat(Arena *arena, Str8 *dst, char *src);
 Str8 str8_substr(Arena *arena, const Str8 *str, u64 start, u64 count);
 
 #endif // !STR_H