diff --git a/include/libtrx/bson.h b/include/libtrx/bson.h
index ea9a07a..25dfd37 100644
--- a/include/libtrx/bson.h
+++ b/include/libtrx/bson.h
@@ -2,28 +2,28 @@
 
 #include "json.h"
 
-enum bson_parse_error_e {
-    bson_parse_error_none = 0,
-    bson_parse_error_invalid_value,
-    bson_parse_error_premature_end_of_buffer,
-    bson_parse_error_unexpected_trailing_bytes,
-    bson_parse_error_unknown,
-};
+typedef enum {
+    BSON_PARSE_ERROR_NONE = 0,
+    BSON_PARSE_ERROR_INVALID_VALUE,
+    BSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER,
+    BSON_PARSE_ERROR_UNEXPECTED_TRAILING_BYTES,
+    BSON_PARSE_ERROR_UNKNOWN,
+} BSON_PARSE_ERROR;
 
-struct bson_parse_result_s {
-    enum bson_parse_error_e error;
+typedef struct {
+    BSON_PARSE_ERROR error;
     size_t error_offset;
-};
+} BSON_PARSE_RESULT;
 
 // Parse a BSON file, returning a pointer to the root of the JSON structure.
 // Returns NULL if an error occurred (malformed BSON input, or malloc failed).
-struct json_value_s *bson_parse(const char *src, size_t src_size);
+JSON_VALUE *BSON_Parse(const char *src, size_t src_size);
 
-struct json_value_s *bson_parse_ex(
-    const char *src, size_t src_size, struct bson_parse_result_s *result);
+JSON_VALUE *BSON_ParseEx(
+    const char *src, size_t src_size, BSON_PARSE_RESULT *result);
 
-const char *bson_get_error_description(enum bson_parse_error_e error);
+const char *BSON_GetErrorDescription(BSON_PARSE_ERROR error);
 
 /* Write out a BSON binary string. Return 0 if an error occurred (malformed
  * JSON input, or malloc failed). The out_size parameter is optional. */
-void *bson_write(const struct json_value_s *value, size_t *out_size);
+void *BSON_Write(const JSON_VALUE *value, size_t *out_size);
diff --git a/include/libtrx/config/config_file.h b/include/libtrx/config/config_file.h
index 019b7b2..7760b28 100644
--- a/include/libtrx/config/config_file.h
+++ b/include/libtrx/config/config_file.h
@@ -7,19 +7,17 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-bool ConfigFile_Read(
-    const char *path, void (*load)(struct json_object_s *root_obj));
-bool ConfigFile_Write(
-    const char *path, void (*dump)(struct json_object_s *root_obj));
+bool ConfigFile_Read(const char *path, void (*load)(JSON_OBJECT *root_obj));
+bool ConfigFile_Write(const char *path, void (*dump)(JSON_OBJECT *root_obj));
 
 void ConfigFile_LoadOptions(
-    struct json_object_s *root_obj, const CONFIG_OPTION *options);
+    JSON_OBJECT *root_obj, const CONFIG_OPTION *options);
 void ConfigFile_DumpOptions(
-    struct json_object_s *root_obj, const CONFIG_OPTION *options);
+    JSON_OBJECT *root_obj, const CONFIG_OPTION *options);
 
 int ConfigFile_ReadEnum(
-    struct json_object_s *obj, const char *name, int default_value,
+    JSON_OBJECT *obj, const char *name, int default_value,
     const ENUM_STRING_MAP *enum_map);
 void ConfigFile_WriteEnum(
-    struct json_object_s *obj, const char *name, int value,
+    JSON_OBJECT *obj, const char *name, int value,
     const ENUM_STRING_MAP *enum_map);
diff --git a/include/libtrx/config/config_option.h b/include/libtrx/config/config_option.h
index d3d6734..12d3c46 100644
--- a/include/libtrx/config/config_option.h
+++ b/include/libtrx/config/config_option.h
@@ -1,6 +1,6 @@
 #pragma once
 
-typedef enum CONFIG_OPTION_TYPE {
+typedef enum {
     COT_BOOL = 0,
     COT_INT32 = 1,
     COT_FLOAT = 2,
diff --git a/include/libtrx/game/console/common.h b/include/libtrx/game/console/common.h
index d5e781d..80312bf 100644
--- a/include/libtrx/game/console/common.h
+++ b/include/libtrx/game/console/common.h
@@ -11,7 +11,7 @@ typedef enum {
     CR_BAD_INVOCATION,
 } COMMAND_RESULT;
 
-typedef struct {
+typedef struct __PACKING {
     const struct __PACKING CONSOLE_COMMAND *cmd;
     const char *prefix;
     const char *args;
diff --git a/include/libtrx/game/creature.h b/include/libtrx/game/creature.h
index 35cd34a..e21afe1 100644
--- a/include/libtrx/game/creature.h
+++ b/include/libtrx/game/creature.h
@@ -23,8 +23,8 @@ typedef struct __PACKING {
     LOT_INFO lot;
     XYZ_32 target;
 #if TR_VERSION == 2
-    ITEM_INFO *enemy;
+    ITEM *enemy;
 #endif
-} CREATURE_INFO;
+} CREATURE;
 
-bool Creature_IsEnemy(const ITEM_INFO *item);
+bool Creature_IsEnemy(const ITEM *item);
diff --git a/include/libtrx/game/effects/types.h b/include/libtrx/game/effects/types.h
index f5b2c37..4130fd0 100644
--- a/include/libtrx/game/effects/types.h
+++ b/include/libtrx/game/effects/types.h
@@ -32,4 +32,4 @@ typedef struct __PACKING {
         } result, prev;
     } interp;
 #endif
-} FX_INFO;
+} FX;
diff --git a/include/libtrx/game/items/common.h b/include/libtrx/game/items/common.h
index 16a7aa1..407fc69 100644
--- a/include/libtrx/game/items/common.h
+++ b/include/libtrx/game/items/common.h
@@ -4,7 +4,7 @@
 
 #include <stdbool.h>
 
-ITEM_INFO *Item_Get(int16_t num);
+ITEM *Item_Get(int16_t num);
 int32_t Item_GetTotalCount(void);
-int32_t Item_GetDistance(const ITEM_INFO *item, const XYZ_32 *target);
-void Item_TakeDamage(ITEM_INFO *item, int16_t damage, bool hit_status);
+int32_t Item_GetDistance(const ITEM *item, const XYZ_32 *target);
+void Item_TakeDamage(ITEM *item, int16_t damage, bool hit_status);
diff --git a/include/libtrx/game/items/types.h b/include/libtrx/game/items/types.h
index 807eaec..0aba367 100644
--- a/include/libtrx/game/items/types.h
+++ b/include/libtrx/game/items/types.h
@@ -47,8 +47,8 @@ typedef struct __PACKING {
     void *priv;
     CARRIED_ITEM *carried_item;
 #elif TR_VERSION == 2
-    int16_t shade1;
-    int16_t shade2;
+    int16_t shade_1;
+    int16_t shade_2;
     int16_t carried_item;
     void *data;
 #endif
@@ -78,4 +78,4 @@ typedef struct __PACKING {
         } result, prev;
     } interp;
 #endif
-} ITEM_INFO;
+} ITEM;
diff --git a/include/libtrx/game/lara/common.h b/include/libtrx/game/lara/common.h
index 4029aa4..606628f 100644
--- a/include/libtrx/game/lara/common.h
+++ b/include/libtrx/game/lara/common.h
@@ -4,4 +4,4 @@
 #include "types.h"
 
 LARA_INFO *Lara_GetLaraInfo(void);
-ITEM_INFO *Lara_GetItem(void);
+ITEM *Lara_GetItem(void);
diff --git a/include/libtrx/game/lara/enum.h b/include/libtrx/game/lara/enum.h
index 5d8c11e..b619dd0 100644
--- a/include/libtrx/game/lara/enum.h
+++ b/include/libtrx/game/lara/enum.h
@@ -25,7 +25,7 @@ typedef enum {
 } LARA_GUN_STATE;
 // clang-format on
 
-typedef enum LARA_MESH {
+typedef enum {
     LM_HIPS = 0,
     LM_THIGH_L = 1,
     LM_CALF_L = 2,
diff --git a/include/libtrx/game/lara/enum_tr1.h b/include/libtrx/game/lara/enum_tr1.h
index c6b85eb..b24f1b4 100644
--- a/include/libtrx/game/lara/enum_tr1.h
+++ b/include/libtrx/game/lara/enum_tr1.h
@@ -1,7 +1,7 @@
 #pragma once
 
 // clang-format off
-typedef enum LARA_SHOTGUN_ANIMATION_FRAME {
+typedef enum {
     LF_SG_AIM_START           = 0,
     LF_SG_AIM_BEND            = 1,
     LF_SG_AIM_END             = 12,
@@ -24,7 +24,7 @@ typedef enum LARA_SHOTGUN_ANIMATION_FRAME {
 // clang-format on
 
 // clang-format off
-typedef enum LARA_GUN_ANIMATION_FRAME {
+typedef enum {
     LF_G_AIM_START    = 0,
     LF_G_AIM_BEND     = 1,
     LF_G_AIM_EXTEND   = 3,
@@ -40,7 +40,7 @@ typedef enum LARA_GUN_ANIMATION_FRAME {
 // clang-format on
 
 // clang-format off
-typedef enum LARA_ANIMATION {
+typedef enum {
     LA_RUN                  = 0,
     LA_WALK_FORWARD         = 1,
     LA_RUN_START            = 6,
@@ -93,7 +93,7 @@ typedef enum LARA_ANIMATION {
 } LARA_ANIMATION;
 
 // clang-format off
-typedef enum LARA_STATE {
+typedef enum {
     LS_WALK         = 0,
     LS_RUN          = 1,
     LS_STOP         = 2,
@@ -157,7 +157,7 @@ typedef enum LARA_STATE {
 // clang-format on
 
 // clang-format off
-typedef enum LARA_GUN_TYPE {
+typedef enum {
     LGT_UNKNOWN = -1, // for legacy saves
     LGT_UNARMED = 0,
     LGT_PISTOLS = 1,
diff --git a/include/libtrx/game/lara/types.h b/include/libtrx/game/lara/types.h
index db885a6..b458eac 100644
--- a/include/libtrx/game/lara/types.h
+++ b/include/libtrx/game/lara/types.h
@@ -36,7 +36,7 @@ typedef struct __PACKING {
     LARA_GUN_TYPE holsters_gun_type;
     LARA_GUN_TYPE back_gun_type;
     int16_t calc_fall_speed;
-    int16_t water_status;
+    LARA_WATER_STATE water_status;
     int16_t pose_count;
     int16_t hit_frame;
     int16_t hit_direction;
@@ -45,10 +45,10 @@ typedef struct __PACKING {
     int16_t death_timer;
     int16_t current_active;
     int16_t spaz_effect_count;
-    FX_INFO *spaz_effect;
+    FX *spaz_effect;
     int32_t mesh_effects;
     int16_t *mesh_ptrs[LM_NUMBER_OF];
-    ITEM_INFO *target;
+    ITEM *target;
     int16_t target_angles[2];
     int16_t turn_rate;
     int16_t move_angle;
@@ -125,10 +125,10 @@ typedef struct __PACKING {
     // clang-format on
     int32_t water_surface_dist;
     XYZ_32 last_pos;
-    FX_INFO *spaz_effect;
+    FX *spaz_effect;
     uint32_t mesh_effects;
     int16_t *mesh_ptrs[15];
-    ITEM_INFO *target;
+    ITEM *target;
     int16_t target_angles[2];
     int16_t turn_rate;
     int16_t move_angle;
@@ -147,7 +147,7 @@ typedef struct __PACKING {
     AMMO_INFO harpoon_ammo;
     AMMO_INFO grenade_ammo;
     AMMO_INFO m16_ammo;
-    CREATURE_INFO *creature;
+    CREATURE *creature;
 } LARA_INFO;
 
 #endif
diff --git a/include/libtrx/game/objects/common.h b/include/libtrx/game/objects/common.h
index 5ac6920..d072b52 100644
--- a/include/libtrx/game/objects/common.h
+++ b/include/libtrx/game/objects/common.h
@@ -7,7 +7,7 @@
 #include "ids.h"
 #include "types.h"
 
-OBJECT_INFO *Object_GetObject(GAME_OBJECT_ID object_id);
+OBJECT *Object_GetObject(GAME_OBJECT_ID object_id);
 
 bool Object_IsObjectType(
     GAME_OBJECT_ID object_id, const GAME_OBJECT_ID *test_arr);
diff --git a/include/libtrx/game/objects/types.h b/include/libtrx/game/objects/types.h
index 0e15187..d55c56c 100644
--- a/include/libtrx/game/objects/types.h
+++ b/include/libtrx/game/objects/types.h
@@ -20,11 +20,11 @@ typedef struct __PACKING {
     void (*initialise)(int16_t item_num);
     void (*control)(int16_t item_num);
     int16_t (*floor_height_func)(
-        const ITEM_INFO *item, int32_t x, int32_t y, int32_t z, int16_t height);
+        const ITEM *item, int32_t x, int32_t y, int32_t z, int16_t height);
     int16_t (*ceiling_height_func)(
-        const ITEM_INFO *item, int32_t x, int32_t y, int32_t z, int16_t height);
-    void (*draw_routine)(ITEM_INFO *item);
-    void (*collision)(int16_t item_num, ITEM_INFO *lara_item, COLL_INFO *coll);
+        const ITEM *item, int32_t x, int32_t y, int32_t z, int16_t height);
+    void (*draw_routine)(ITEM *item);
+    void (*collision)(int16_t item_num, ITEM *lara_item, COLL_INFO *coll);
     const OBJECT_BOUNDS *(*bounds)(void);
     int16_t anim_idx;
     int16_t hit_points;
@@ -38,7 +38,7 @@ typedef struct __PACKING {
     uint16_t save_hitpoints : 1;
     uint16_t save_flags : 1;
     uint16_t save_anim : 1;
-} OBJECT_INFO;
+} OBJECT;
 
 #elif TR_VERSION == 2
 typedef struct __PACKING {
@@ -50,13 +50,11 @@ typedef struct __PACKING {
     void (*initialise)(int16_t item_num);
     void (*control)(int16_t item_num);
     void (*floor)(
-        const ITEM_INFO *item, int32_t x, int32_t y, int32_t z,
-        int32_t *height);
+        const ITEM *item, int32_t x, int32_t y, int32_t z, int32_t *height);
     void (*ceiling)(
-        const ITEM_INFO *item, int32_t x, int32_t y, int32_t z,
-        int32_t *height);
-    void (*draw_routine)(const ITEM_INFO *item);
-    void (*collision)(int16_t item_num, ITEM_INFO *lara_item, COLL_INFO *coll);
+        const ITEM *item, int32_t x, int32_t y, int32_t z, int32_t *height);
+    void (*draw_routine)(const ITEM *item);
+    void (*collision)(int16_t item_num, ITEM *lara_item, COLL_INFO *coll);
 
     int16_t anim_idx;
     int16_t hit_points;
@@ -80,5 +78,5 @@ typedef struct __PACKING {
         };
         // clang-format on
     };
-} OBJECT_INFO;
+} OBJECT;
 #endif
diff --git a/include/libtrx/game/rooms/common.h b/include/libtrx/game/rooms/common.h
index a38a9c4..eb0ac48 100644
--- a/include/libtrx/game/rooms/common.h
+++ b/include/libtrx/game/rooms/common.h
@@ -3,4 +3,4 @@
 #include "types.h"
 
 extern int32_t Room_GetTotalCount(void);
-ROOM_INFO *Room_Get(int32_t room_num);
+ROOM *Room_Get(int32_t room_num);
diff --git a/include/libtrx/game/rooms/types.h b/include/libtrx/game/rooms/types.h
index 004986a..cd89ba0 100644
--- a/include/libtrx/game/rooms/types.h
+++ b/include/libtrx/game/rooms/types.h
@@ -6,19 +6,19 @@
 #include <stdbool.h>
 
 #if TR_VERSION == 1
-typedef struct {
+typedef struct __PACKING {
     TRIGGER_OBJECT type;
     void *parameter;
 } TRIGGER_CMD;
 
-typedef struct {
+typedef struct __PACKING {
     int16_t camera_num;
     uint8_t timer;
     uint8_t glide;
     bool one_shot;
 } TRIGGER_CAMERA_DATA;
 
-typedef struct {
+typedef struct __PACKING {
     TRIGGER_TYPE type;
     int8_t timer;
     int16_t mask;
@@ -27,87 +27,35 @@ typedef struct {
     int32_t command_count;
     TRIGGER_CMD *commands;
 } TRIGGER;
+#endif
 
 typedef struct __PACKING {
     int16_t room_num;
     XYZ_16 normal;
     XYZ_16 vertex[4];
-} DOOR_INFO;
-
-#elif TR_VERSION == 2
-typedef struct __PACKING {
-    int16_t room;
-    int16_t x;
-    int16_t y;
-    int16_t z;
-    XYZ_16 vertex[4];
-} DOOR_INFO;
-#endif
+} PORTAL;
 
 typedef struct __PACKING {
     uint16_t count;
-    DOOR_INFO door[];
-} DOOR_INFOS;
+    PORTAL portal[];
+} PORTALS;
 
 #if TR_VERSION == 1
 typedef struct __PACKING {
-    uint16_t index;
+    uint16_t idx;
     int16_t box;
     bool is_death_sector;
     TRIGGER *trigger;
-    struct {
+    struct __PACKING {
         uint8_t pit;
         uint8_t sky;
         int16_t wall;
     } portal_room;
-    struct {
+    struct __PACKING {
         int16_t height;
         int16_t tilt;
     } floor, ceiling;
-} SECTOR_INFO;
-
-typedef struct LIGHT_INFO {
-    XYZ_32 pos;
-    int16_t intensity;
-    int32_t falloff;
-} LIGHT_INFO;
-
-typedef struct MESH_INFO {
-    XYZ_32 pos;
-    struct {
-        int16_t y;
-    } rot;
-    uint16_t shade;
-    uint16_t static_num;
-} MESH_INFO;
-
-typedef struct __PACKING {
-    int16_t *data;
-    DOOR_INFOS *doors;
-    SECTOR_INFO *sectors;
-    LIGHT_INFO *light;
-    MESH_INFO *mesh;
-    int32_t x;
-    int32_t y;
-    int32_t z;
-    int32_t min_floor;
-    int32_t max_ceiling;
-    int16_t z_size;
-    int16_t x_size;
-    int16_t ambient;
-    int16_t num_lights;
-    int16_t num_meshes;
-    int16_t left;
-    int16_t right;
-    int16_t top;
-    int16_t bottom;
-    int16_t bound_active;
-    int16_t item_num;
-    int16_t fx_num;
-    int16_t flipped_room;
-    uint16_t flags;
-} ROOM_INFO;
-
+} SECTOR;
 #elif TR_VERSION == 2
 typedef struct __PACKING {
     uint16_t idx;
@@ -116,42 +64,56 @@ typedef struct __PACKING {
     int8_t floor;
     uint8_t sky_room;
     int8_t ceiling;
-} SECTOR_INFO;
+} SECTOR;
+#endif
 
 typedef struct __PACKING {
-    int32_t x;
-    int32_t y;
-    int32_t z;
-    int16_t intensity1;
-    int16_t intensity2;
-    int32_t falloff1;
-    int32_t falloff2;
-} LIGHT_INFO;
+    XYZ_32 pos;
+#if TR_VERSION == 1
+    int16_t intensity;
+    int32_t falloff;
+#elif TR_VERSION == 2
+    int16_t intensity_1;
+    int16_t intensity_2;
+    int32_t falloff_1;
+    int32_t falloff_2;
+#endif
+} LIGHT;
 
 typedef struct __PACKING {
-    int32_t x;
-    int32_t y;
-    int32_t z;
-    int16_t y_rot;
-    int16_t shade1;
-    int16_t shade2;
+    XYZ_32 pos;
+    struct __PACKING {
+        int16_t y;
+    } rot;
+#if TR_VERSION == 1
+    uint16_t shade;
+#elif TR_VERSION == 2
+    int16_t shade_1;
+    int16_t shade_2;
+#endif
     int16_t static_num;
-} MESH_INFO;
+} MESH;
 
 typedef struct __PACKING {
     int16_t *data;
-    DOOR_INFOS *doors;
-    SECTOR_INFO *sector;
-    LIGHT_INFO *light;
-    MESH_INFO *mesh;
+    PORTALS *portals;
+    SECTOR *sectors;
+    LIGHT *lights;
+    MESH *meshes;
     XYZ_32 pos;
     int32_t min_floor;
     int32_t max_ceiling;
-    int16_t z_size;
-    int16_t x_size;
-    int16_t ambient1;
-    int16_t ambient2;
+    struct __PACKING {
+        int16_t z;
+        int16_t x;
+    } size;
+#if TR_VERSION == 1
+    int16_t ambient;
+#else
+    int16_t ambient_1;
+    int16_t ambient_2;
     int16_t light_mode;
+#endif
     int16_t num_lights;
     int16_t num_meshes;
     int16_t bound_left;
@@ -159,13 +121,14 @@ typedef struct __PACKING {
     int16_t bound_top;
     int16_t bound_bottom;
     uint16_t bound_active;
+#if TR_VERSION == 2
     int16_t test_left;
     int16_t test_right;
     int16_t test_top;
     int16_t test_bottom;
+#endif
     int16_t item_num;
     int16_t fx_num;
     int16_t flipped_room;
     uint16_t flags;
-} ROOM_INFO;
-#endif
+} ROOM;
diff --git a/include/libtrx/game/sound/common.h b/include/libtrx/game/sound/common.h
index e71afd4..4057cdf 100644
--- a/include/libtrx/game/sound/common.h
+++ b/include/libtrx/game/sound/common.h
@@ -4,7 +4,7 @@
 #include "ids.h"
 
 // clang-format off
-typedef enum SOUND_PLAY_MODE {
+typedef enum {
     SPM_NORMAL     = 0,
     SPM_UNDERWATER = 1,
     SPM_ALWAYS     = 2,
diff --git a/include/libtrx/game/sound/ids.h b/include/libtrx/game/sound/ids.h
index 81e69eb..9a433ce 100644
--- a/include/libtrx/game/sound/ids.h
+++ b/include/libtrx/game/sound/ids.h
@@ -2,7 +2,7 @@
 
 #if TR_VERSION == 1
 // clang-format off
-typedef enum SOUND_EFFECT_ID {
+typedef enum {
     SFX_INVALID               = -1,
     SFX_LARA_FEET             = 0,
     SFX_LARA_CLIMB2           = 1,
diff --git a/include/libtrx/gfx/2d/2d_renderer.h b/include/libtrx/gfx/2d/2d_renderer.h
index a1e2b89..661a407 100644
--- a/include/libtrx/gfx/2d/2d_renderer.h
+++ b/include/libtrx/gfx/2d/2d_renderer.h
@@ -10,19 +10,19 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-typedef struct GFX_2D_Renderer {
+typedef struct {
     uint32_t width;
     uint32_t height;
-    GFX_GL_VertexArray surface_format;
-    GFX_GL_Buffer surface_buffer;
-    GFX_GL_Texture surface_texture;
-    GFX_GL_Sampler sampler;
-    GFX_GL_Program program;
-} GFX_2D_Renderer;
+    GFX_GL_VERTEX_ARRAY surface_format;
+    GFX_GL_BUFFER surface_buffer;
+    GFX_GL_TEXTURE surface_texture;
+    GFX_GL_SAMPLER sampler;
+    GFX_GL_PROGRAM program;
+} GFX_2D_RENDERER;
 
-void GFX_2D_Renderer_Init(GFX_2D_Renderer *renderer);
-void GFX_2D_Renderer_Close(GFX_2D_Renderer *renderer);
+void GFX_2D_Renderer_Init(GFX_2D_RENDERER *renderer);
+void GFX_2D_Renderer_Close(GFX_2D_RENDERER *renderer);
 
 void GFX_2D_Renderer_Upload(
-    GFX_2D_Renderer *renderer, GFX_2D_SurfaceDesc *desc, const uint8_t *data);
-void GFX_2D_Renderer_Render(GFX_2D_Renderer *renderer);
+    GFX_2D_RENDERER *renderer, GFX_2D_SURFACE_DESC *desc, const uint8_t *data);
+void GFX_2D_Renderer_Render(GFX_2D_RENDERER *renderer);
diff --git a/include/libtrx/gfx/2d/2d_surface.h b/include/libtrx/gfx/2d/2d_surface.h
index f5242a6..3bafda8 100644
--- a/include/libtrx/gfx/2d/2d_surface.h
+++ b/include/libtrx/gfx/2d/2d_surface.h
@@ -14,24 +14,25 @@ typedef struct {
     int32_t bit_count;
     GLenum tex_format;
     GLenum tex_type;
-} GFX_2D_SurfaceDesc;
+} GFX_2D_SURFACE_DESC;
 
-typedef struct GFX_2D_Surface {
+typedef struct {
     uint8_t *buffer;
-    GFX_2D_SurfaceDesc desc;
+    GFX_2D_SURFACE_DESC desc;
     bool is_locked;
     bool is_dirty;
-} GFX_2D_Surface;
+} GFX_2D_SURFACE;
 
-GFX_2D_Surface *GFX_2D_Surface_Create(const GFX_2D_SurfaceDesc *desc);
-GFX_2D_Surface *GFX_2D_Surface_CreateFromImage(const IMAGE *image);
-void GFX_2D_Surface_Free(GFX_2D_Surface *surface);
+GFX_2D_SURFACE *GFX_2D_Surface_Create(const GFX_2D_SURFACE_DESC *desc);
+GFX_2D_SURFACE *GFX_2D_Surface_CreateFromImage(const IMAGE *image);
+void GFX_2D_Surface_Free(GFX_2D_SURFACE *surface);
 
 void GFX_2D_Surface_Init(
-    GFX_2D_Surface *surface, const GFX_2D_SurfaceDesc *desc);
-void GFX_2D_Surface_Close(GFX_2D_Surface *surface);
+    GFX_2D_SURFACE *surface, const GFX_2D_SURFACE_DESC *desc);
+void GFX_2D_Surface_Close(GFX_2D_SURFACE *surface);
 
-bool GFX_2D_Surface_Clear(GFX_2D_Surface *surface);
+bool GFX_2D_Surface_Clear(GFX_2D_SURFACE *surface);
 
-bool GFX_2D_Surface_Lock(GFX_2D_Surface *surface, GFX_2D_SurfaceDesc *out_desc);
-bool GFX_2D_Surface_Unlock(GFX_2D_Surface *surface);
+bool GFX_2D_Surface_Lock(
+    GFX_2D_SURFACE *surface, GFX_2D_SURFACE_DESC *out_desc);
+bool GFX_2D_Surface_Unlock(GFX_2D_SURFACE *surface);
diff --git a/include/libtrx/gfx/3d/3d_renderer.h b/include/libtrx/gfx/3d/3d_renderer.h
index 1058c12..63e82b1 100644
--- a/include/libtrx/gfx/3d/3d_renderer.h
+++ b/include/libtrx/gfx/3d/3d_renderer.h
@@ -16,20 +16,20 @@
 #include <stdint.h>
 
 typedef enum {
-    GFX_BlendMode_Off,
-    GFX_BlendMode_Normal,
-    GFX_BlendMode_Multiply,
-} GFX_BlendMode;
+    GFX_BLEND_MODE_OFF,
+    GFX_BLEND_MODE_NORMAL,
+    GFX_BLEND_MODE_MULTIPLY,
+} GFX_BLEND_MODE;
 
-typedef struct GFX_3D_Renderer {
+typedef struct {
     const GFX_CONFIG *config;
 
-    GFX_GL_Program program;
-    GFX_GL_Sampler sampler;
-    GFX_3D_VertexStream vertex_stream;
+    GFX_GL_PROGRAM program;
+    GFX_GL_SAMPLER sampler;
+    GFX_3D_VERTEX_STREAM vertex_stream;
 
-    GFX_GL_Texture *textures[GFX_MAX_TEXTURES];
-    GFX_GL_Texture *env_map_texture;
+    GFX_GL_TEXTURE *textures[GFX_MAX_TEXTURES];
+    GFX_GL_TEXTURE *env_map_texture;
     int selected_texture_num;
 
     // shader variable locations
@@ -37,42 +37,42 @@ typedef struct GFX_3D_Renderer {
     GLint loc_mat_model_view;
     GLint loc_texturing_enabled;
     GLint loc_smoothing_enabled;
-} GFX_3D_Renderer;
+} GFX_3D_RENDERER;
 
-void GFX_3D_Renderer_Init(GFX_3D_Renderer *renderer, const GFX_CONFIG *config);
-void GFX_3D_Renderer_Close(GFX_3D_Renderer *renderer);
+void GFX_3D_Renderer_Init(GFX_3D_RENDERER *renderer, const GFX_CONFIG *config);
+void GFX_3D_Renderer_Close(GFX_3D_RENDERER *renderer);
 
-void GFX_3D_Renderer_RenderBegin(GFX_3D_Renderer *renderer);
-void GFX_3D_Renderer_RenderEnd(GFX_3D_Renderer *renderer);
-void GFX_3D_Renderer_ClearDepth(GFX_3D_Renderer *renderer);
+void GFX_3D_Renderer_RenderBegin(GFX_3D_RENDERER *renderer);
+void GFX_3D_Renderer_RenderEnd(GFX_3D_RENDERER *renderer);
+void GFX_3D_Renderer_ClearDepth(GFX_3D_RENDERER *renderer);
 
 int GFX_3D_Renderer_RegisterTexturePage(
-    GFX_3D_Renderer *renderer, const void *data, int width, int height);
+    GFX_3D_RENDERER *renderer, const void *data, int width, int height);
 bool GFX_3D_Renderer_UnregisterTexturePage(
-    GFX_3D_Renderer *renderer, int texture_num);
+    GFX_3D_RENDERER *renderer, int texture_num);
 
-int GFX_3D_Renderer_RegisterEnvironmentMap(GFX_3D_Renderer *renderer);
+int GFX_3D_Renderer_RegisterEnvironmentMap(GFX_3D_RENDERER *renderer);
 bool GFX_3D_Renderer_UnregisterEnvironmentMap(
-    GFX_3D_Renderer *renderer, int texture_num);
-void GFX_3D_Renderer_FillEnvironmentMap(GFX_3D_Renderer *renderer);
+    GFX_3D_RENDERER *renderer, int texture_num);
+void GFX_3D_Renderer_FillEnvironmentMap(GFX_3D_RENDERER *renderer);
 
-void GFX_3D_Renderer_SelectTexture(GFX_3D_Renderer *renderer, int texture_num);
-void GFX_3D_Renderer_RestoreTexture(GFX_3D_Renderer *renderer);
+void GFX_3D_Renderer_SelectTexture(GFX_3D_RENDERER *renderer, int texture_num);
+void GFX_3D_Renderer_RestoreTexture(GFX_3D_RENDERER *renderer);
 
 void GFX_3D_Renderer_RenderPrimStrip(
-    GFX_3D_Renderer *renderer, GFX_3D_Vertex *vertices, int count);
+    GFX_3D_RENDERER *renderer, GFX_3D_VERTEX *vertices, int count);
 void GFX_3D_Renderer_RenderPrimFan(
-    GFX_3D_Renderer *renderer, GFX_3D_Vertex *vertices, int count);
+    GFX_3D_RENDERER *renderer, GFX_3D_VERTEX *vertices, int count);
 void GFX_3D_Renderer_RenderPrimList(
-    GFX_3D_Renderer *renderer, GFX_3D_Vertex *vertices, int count);
+    GFX_3D_RENDERER *renderer, GFX_3D_VERTEX *vertices, int count);
 
 void GFX_3D_Renderer_SetPrimType(
-    GFX_3D_Renderer *renderer, GFX_3D_PrimType value);
+    GFX_3D_RENDERER *renderer, GFX_3D_PRIM_TYPE value);
 void GFX_3D_Renderer_SetTextureFilter(
-    GFX_3D_Renderer *renderer, GFX_TEXTURE_FILTER filter);
+    GFX_3D_RENDERER *renderer, GFX_TEXTURE_FILTER filter);
 void GFX_3D_Renderer_SetDepthTestEnabled(
-    GFX_3D_Renderer *renderer, bool is_enabled);
+    GFX_3D_RENDERER *renderer, bool is_enabled);
 void GFX_3D_Renderer_SetBlendingMode(
-    GFX_3D_Renderer *renderer, GFX_BlendMode blend_mode);
+    GFX_3D_RENDERER *renderer, GFX_BLEND_MODE blend_mode);
 void GFX_3D_Renderer_SetTexturingEnabled(
-    GFX_3D_Renderer *renderer, bool is_enabled);
+    GFX_3D_RENDERER *renderer, bool is_enabled);
diff --git a/include/libtrx/gfx/3d/vertex_stream.h b/include/libtrx/gfx/3d/vertex_stream.h
index d876f51..f278c0f 100644
--- a/include/libtrx/gfx/3d/vertex_stream.h
+++ b/include/libtrx/gfx/3d/vertex_stream.h
@@ -9,39 +9,39 @@
 typedef enum {
     GFX_3D_PRIM_LINE = 0,
     GFX_3D_PRIM_TRI = 1,
-} GFX_3D_PrimType;
+} GFX_3D_PRIM_TYPE;
 
 typedef struct {
     float x, y, z;
     float s, t, w;
     float r, g, b, a;
-} GFX_3D_Vertex;
+} GFX_3D_VERTEX;
 
-typedef struct GFX_3D_VertexStream {
-    GFX_3D_PrimType prim_type;
+typedef struct {
+    GFX_3D_PRIM_TYPE prim_type;
     size_t buffer_size;
-    GFX_GL_Buffer buffer;
-    GFX_GL_VertexArray vtc_format;
+    GFX_GL_BUFFER buffer;
+    GFX_GL_VERTEX_ARRAY vtc_format;
     struct {
-        GFX_3D_Vertex *data;
+        GFX_3D_VERTEX *data;
         size_t count;
         size_t capacity;
     } pending_vertices;
-} GFX_3D_VertexStream;
+} GFX_3D_VERTEX_STREAM;
 
-void GFX_3D_VertexStream_Init(GFX_3D_VertexStream *vertex_stream);
-void GFX_3D_VertexStream_Close(GFX_3D_VertexStream *vertex_stream);
+void GFX_3D_VertexStream_Init(GFX_3D_VERTEX_STREAM *vertex_stream);
+void GFX_3D_VertexStream_Close(GFX_3D_VERTEX_STREAM *vertex_stream);
 
-void GFX_3D_VertexStream_Bind(GFX_3D_VertexStream *vertex_stream);
+void GFX_3D_VertexStream_Bind(GFX_3D_VERTEX_STREAM *vertex_stream);
 
 void GFX_3D_VertexStream_SetPrimType(
-    GFX_3D_VertexStream *vertex_stream, GFX_3D_PrimType prim_type);
+    GFX_3D_VERTEX_STREAM *vertex_stream, GFX_3D_PRIM_TYPE prim_type);
 
 bool GFX_3D_VertexStream_PushPrimStrip(
-    GFX_3D_VertexStream *vertex_stream, GFX_3D_Vertex *vertices, int count);
+    GFX_3D_VERTEX_STREAM *vertex_stream, GFX_3D_VERTEX *vertices, int count);
 bool GFX_3D_VertexStream_PushPrimFan(
-    GFX_3D_VertexStream *vertex_stream, GFX_3D_Vertex *vertices, int count);
+    GFX_3D_VERTEX_STREAM *vertex_stream, GFX_3D_VERTEX *vertices, int count);
 bool GFX_3D_VertexStream_PushPrimList(
-    GFX_3D_VertexStream *vertex_stream, GFX_3D_Vertex *vertices, int count);
+    GFX_3D_VERTEX_STREAM *vertex_stream, GFX_3D_VERTEX *vertices, int count);
 
-void GFX_3D_VertexStream_RenderPending(GFX_3D_VertexStream *vertex_stream);
+void GFX_3D_VertexStream_RenderPending(GFX_3D_VERTEX_STREAM *vertex_stream);
diff --git a/include/libtrx/gfx/common.h b/include/libtrx/gfx/common.h
index 1aaad6c..b2d5d31 100644
--- a/include/libtrx/gfx/common.h
+++ b/include/libtrx/gfx/common.h
@@ -1,6 +1,6 @@
 #pragma once
 
-typedef enum GFX_TEXTURE_FILTER {
+typedef enum {
     GFX_TF_FIRST = 0,
     GFX_TF_NN = GFX_TF_FIRST,
     GFX_TF_BILINEAR,
@@ -8,12 +8,12 @@ typedef enum GFX_TEXTURE_FILTER {
     GFX_TF_NUMBER_OF,
 } GFX_TEXTURE_FILTER;
 
-typedef enum GFX_RENDER_MODE {
+typedef enum {
     GFX_RM_LEGACY,
     GFX_RM_FRAMEBUFFER,
 } GFX_RENDER_MODE;
 
-typedef enum GFX_GL_BACKEND {
+typedef enum {
     GFX_GL_21,
     GFX_GL_33C,
 } GFX_GL_BACKEND;
diff --git a/include/libtrx/gfx/context.h b/include/libtrx/gfx/context.h
index b695c8c..b821425 100644
--- a/include/libtrx/gfx/context.h
+++ b/include/libtrx/gfx/context.h
@@ -8,8 +8,6 @@
 #include <stdbool.h>
 #include <stdint.h>
 
-typedef struct GFX_CONTEXT GFX_CONTEXT;
-
 void GFX_Context_Attach(void *window_handle);
 void GFX_Context_Detach(void);
 
@@ -38,5 +36,5 @@ void GFX_Context_ScheduleScreenshot(const char *path);
 const char *GFX_Context_GetScheduledScreenshotPath(void);
 void GFX_Context_ClearScheduledScreenshotPath(void);
 
-GFX_2D_Renderer *GFX_Context_GetRenderer2D(void);
-GFX_3D_Renderer *GFX_Context_GetRenderer3D(void);
+GFX_2D_RENDERER *GFX_Context_GetRenderer2D(void);
+GFX_3D_RENDERER *GFX_Context_GetRenderer3D(void);
diff --git a/include/libtrx/gfx/gl/buffer.h b/include/libtrx/gfx/gl/buffer.h
index addf282..99f8f68 100644
--- a/include/libtrx/gfx/gl/buffer.h
+++ b/include/libtrx/gfx/gl/buffer.h
@@ -2,19 +2,19 @@
 
 #include "gl_core_3_3.h"
 
-typedef struct GFX_GL_Buffer {
+typedef struct {
     GLuint id;
     GLenum target;
-} GFX_GL_Buffer;
+} GFX_GL_BUFFER;
 
-void GFX_GL_Buffer_Init(GFX_GL_Buffer *buf, GLenum target);
-void GFX_GL_Buffer_Close(GFX_GL_Buffer *buf);
+void GFX_GL_Buffer_Init(GFX_GL_BUFFER *buf, GLenum target);
+void GFX_GL_Buffer_Close(GFX_GL_BUFFER *buf);
 
-void GFX_GL_Buffer_Bind(GFX_GL_Buffer *buf);
+void GFX_GL_Buffer_Bind(GFX_GL_BUFFER *buf);
 void GFX_GL_Buffer_Data(
-    GFX_GL_Buffer *buf, GLsizei size, const void *data, GLenum usage);
+    GFX_GL_BUFFER *buf, GLsizei size, const void *data, GLenum usage);
 void GFX_GL_Buffer_SubData(
-    GFX_GL_Buffer *buf, GLsizei offset, GLsizei size, const void *data);
-void *GFX_GL_Buffer_Map(GFX_GL_Buffer *buf, GLenum access);
-void GFX_GL_Buffer_Unmap(GFX_GL_Buffer *buf);
-GLint GFX_GL_Buffer_Parameter(GFX_GL_Buffer *buf, GLenum pname);
+    GFX_GL_BUFFER *buf, GLsizei offset, GLsizei size, const void *data);
+void *GFX_GL_Buffer_Map(GFX_GL_BUFFER *buf, GLenum access);
+void GFX_GL_Buffer_Unmap(GFX_GL_BUFFER *buf);
+GLint GFX_GL_Buffer_Parameter(GFX_GL_BUFFER *buf, GLenum pname);
diff --git a/include/libtrx/gfx/gl/program.h b/include/libtrx/gfx/gl/program.h
index f77440f..427a8bb 100644
--- a/include/libtrx/gfx/gl/program.h
+++ b/include/libtrx/gfx/gl/program.h
@@ -5,28 +5,28 @@
 
 #include <stdbool.h>
 
-typedef struct GFX_GL_Program {
+typedef struct {
     GLuint id;
-} GFX_GL_Program;
+} GFX_GL_PROGRAM;
 
-bool GFX_GL_Program_Init(GFX_GL_Program *program);
-void GFX_GL_Program_Close(GFX_GL_Program *program);
+bool GFX_GL_Program_Init(GFX_GL_PROGRAM *program);
+void GFX_GL_Program_Close(GFX_GL_PROGRAM *program);
 
-void GFX_GL_Program_Bind(GFX_GL_Program *program);
+void GFX_GL_Program_Bind(GFX_GL_PROGRAM *program);
 char *GFX_GL_Program_PreprocessShader(
     const char *content, GLenum type, GFX_GL_BACKEND backend);
 void GFX_GL_Program_AttachShader(
-    GFX_GL_Program *program, GLenum type, const char *path);
-void GFX_GL_Program_Link(GFX_GL_Program *program);
-void GFX_GL_Program_FragmentData(GFX_GL_Program *program, const char *name);
-GLint GFX_GL_Program_UniformLocation(GFX_GL_Program *program, const char *name);
+    GFX_GL_PROGRAM *program, GLenum type, const char *path);
+void GFX_GL_Program_Link(GFX_GL_PROGRAM *program);
+void GFX_GL_Program_FragmentData(GFX_GL_PROGRAM *program, const char *name);
+GLint GFX_GL_Program_UniformLocation(GFX_GL_PROGRAM *program, const char *name);
 
 void GFX_GL_Program_Uniform3f(
-    GFX_GL_Program *program, GLint loc, GLfloat v0, GLfloat v1, GLfloat v2);
+    GFX_GL_PROGRAM *program, GLint loc, GLfloat v0, GLfloat v1, GLfloat v2);
 void GFX_GL_Program_Uniform4f(
-    GFX_GL_Program *program, GLint loc, GLfloat v0, GLfloat v1, GLfloat v2,
+    GFX_GL_PROGRAM *program, GLint loc, GLfloat v0, GLfloat v1, GLfloat v2,
     GLfloat v3);
-void GFX_GL_Program_Uniform1i(GFX_GL_Program *program, GLint loc, GLint v0);
+void GFX_GL_Program_Uniform1i(GFX_GL_PROGRAM *program, GLint loc, GLint v0);
 void GFX_GL_Program_UniformMatrix4fv(
-    GFX_GL_Program *program, GLint loc, GLsizei count, GLboolean transpose,
+    GFX_GL_PROGRAM *program, GLint loc, GLsizei count, GLboolean transpose,
     const GLfloat *value);
diff --git a/include/libtrx/gfx/gl/sampler.h b/include/libtrx/gfx/gl/sampler.h
index 87cae87..b1bae2a 100644
--- a/include/libtrx/gfx/gl/sampler.h
+++ b/include/libtrx/gfx/gl/sampler.h
@@ -2,15 +2,15 @@
 
 #include "../gl/gl_core_3_3.h"
 
-typedef struct GFX_GL_Sampler {
+typedef struct {
     GLuint id;
-} GFX_GL_Sampler;
+} GFX_GL_SAMPLER;
 
-void GFX_GL_Sampler_Init(GFX_GL_Sampler *sampler);
-void GFX_GL_Sampler_Close(GFX_GL_Sampler *sampler);
+void GFX_GL_Sampler_Init(GFX_GL_SAMPLER *sampler);
+void GFX_GL_Sampler_Close(GFX_GL_SAMPLER *sampler);
 
-void GFX_GL_Sampler_Bind(GFX_GL_Sampler *sampler, GLuint unit);
+void GFX_GL_Sampler_Bind(GFX_GL_SAMPLER *sampler, GLuint unit);
 void GFX_GL_Sampler_Parameteri(
-    GFX_GL_Sampler *sampler, GLenum pname, GLint param);
+    GFX_GL_SAMPLER *sampler, GLenum pname, GLint param);
 void GFX_GL_Sampler_Parameterf(
-    GFX_GL_Sampler *sampler, GLenum pname, GLfloat param);
+    GFX_GL_SAMPLER *sampler, GLenum pname, GLfloat param);
diff --git a/include/libtrx/gfx/gl/texture.h b/include/libtrx/gfx/gl/texture.h
index 33b384f..96b7bc3 100644
--- a/include/libtrx/gfx/gl/texture.h
+++ b/include/libtrx/gfx/gl/texture.h
@@ -2,18 +2,18 @@
 
 #include "../gl/gl_core_3_3.h"
 
-typedef struct GFX_GL_Texture {
+typedef struct {
     GLuint id;
     GLenum target;
-} GFX_GL_Texture;
+} GFX_GL_TEXTURE;
 
-GFX_GL_Texture *GFX_GL_Texture_Create(GLenum target);
-void GFX_GL_Texture_Free(GFX_GL_Texture *texture);
+GFX_GL_TEXTURE *GFX_GL_Texture_Create(GLenum target);
+void GFX_GL_Texture_Free(GFX_GL_TEXTURE *texture);
 
-void GFX_GL_Texture_Init(GFX_GL_Texture *texture, GLenum target);
-void GFX_GL_Texture_Close(GFX_GL_Texture *texture);
-void GFX_GL_Texture_Bind(GFX_GL_Texture *texture);
+void GFX_GL_Texture_Init(GFX_GL_TEXTURE *texture, GLenum target);
+void GFX_GL_Texture_Close(GFX_GL_TEXTURE *texture);
+void GFX_GL_Texture_Bind(GFX_GL_TEXTURE *texture);
 void GFX_GL_Texture_Load(
-    GFX_GL_Texture *texture, const void *data, int width, int height,
+    GFX_GL_TEXTURE *texture, const void *data, int width, int height,
     GLint internal_format, GLint format);
-void GFX_GL_Texture_LoadFromBackBuffer(GFX_GL_Texture *texture);
+void GFX_GL_Texture_LoadFromBackBuffer(GFX_GL_TEXTURE *texture);
diff --git a/include/libtrx/gfx/gl/vertex_array.h b/include/libtrx/gfx/gl/vertex_array.h
index 2525376..01615f1 100644
--- a/include/libtrx/gfx/gl/vertex_array.h
+++ b/include/libtrx/gfx/gl/vertex_array.h
@@ -2,13 +2,13 @@
 
 #include "../gl/gl_core_3_3.h"
 
-typedef struct GFX_GL_VertexArray {
+typedef struct {
     GLuint id;
-} GFX_GL_VertexArray;
+} GFX_GL_VERTEX_ARRAY;
 
-void GFX_GL_VertexArray_Init(GFX_GL_VertexArray *array);
-void GFX_GL_VertexArray_Close(GFX_GL_VertexArray *array);
-void GFX_GL_VertexArray_Bind(GFX_GL_VertexArray *array);
+void GFX_GL_VertexArray_Init(GFX_GL_VERTEX_ARRAY *array);
+void GFX_GL_VertexArray_Close(GFX_GL_VERTEX_ARRAY *array);
+void GFX_GL_VertexArray_Bind(GFX_GL_VERTEX_ARRAY *array);
 void GFX_GL_VertexArray_Attribute(
-    GFX_GL_VertexArray *array, GLuint index, GLint size, GLenum type,
+    GFX_GL_VERTEX_ARRAY *array, GLuint index, GLint size, GLenum type,
     GLboolean normalized, GLsizei stride, GLsizei offset);
diff --git a/include/libtrx/gfx/renderer.h b/include/libtrx/gfx/renderer.h
index e617af6..7fde3e6 100644
--- a/include/libtrx/gfx/renderer.h
+++ b/include/libtrx/gfx/renderer.h
@@ -8,4 +8,4 @@ typedef struct GFX_Renderer {
     void (*reset)(struct GFX_Renderer *renderer);
     void (*swap_buffers)(struct GFX_Renderer *renderer);
     void *priv;
-} GFX_Renderer;
+} GFX_RENDERER;
diff --git a/include/libtrx/gfx/renderers/fbo_renderer.h b/include/libtrx/gfx/renderers/fbo_renderer.h
index 634e8e8..b576956 100644
--- a/include/libtrx/gfx/renderers/fbo_renderer.h
+++ b/include/libtrx/gfx/renderers/fbo_renderer.h
@@ -2,4 +2,4 @@
 
 #include "../renderer.h"
 
-extern GFX_Renderer g_GFX_Renderer_FBO;
+extern GFX_RENDERER g_GFX_Renderer_FBO;
diff --git a/include/libtrx/gfx/renderers/legacy_renderer.h b/include/libtrx/gfx/renderers/legacy_renderer.h
index 6f95f4b..6c99222 100644
--- a/include/libtrx/gfx/renderers/legacy_renderer.h
+++ b/include/libtrx/gfx/renderers/legacy_renderer.h
@@ -1,3 +1,3 @@
 #include "../renderer.h"
 
-extern GFX_Renderer g_GFX_Renderer_Legacy;
+extern GFX_RENDERER g_GFX_Renderer_Legacy;
diff --git a/include/libtrx/json.h b/include/libtrx/json.h
index 22aa8ff..008b823 100644
--- a/include/libtrx/json.h
+++ b/include/libtrx/json.h
@@ -8,291 +8,274 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#define json_null NULL
 #define json_uintmax_t uintmax_t
 #define json_strtoumax strtoumax
 
-enum json_type_e {
-    json_type_string,
-    json_type_number,
-    json_type_object,
-    json_type_array,
-    json_type_true,
-    json_type_false,
-    json_type_null
-};
-
-struct json_string_s {
+typedef enum {
+    JSON_TYPE_STRING,
+    JSON_TYPE_NUMBER,
+    JSON_TYPE_OBJECT,
+    JSON_TYPE_ARRAY,
+    JSON_TYPE_TRUE,
+    JSON_TYPE_FALSE,
+    JSON_TYPE_NULL
+} JSON_TYPE;
+
+typedef struct {
+    void *payload;
+    size_t type;
+    size_t ref_count;
+} JSON_VALUE;
+
+typedef struct {
     char *string;
     size_t string_size;
     size_t ref_count;
-};
+} JSON_STRING;
 
-struct json_string_ex_s {
-    struct json_string_s string;
+typedef struct {
+    JSON_STRING string;
     size_t offset;
     size_t line_no;
     size_t row_no;
-};
+} JSON_STRING_EX;
 
-struct json_number_s {
+typedef struct {
     char *number;
     size_t number_size;
     size_t ref_count;
-};
+} JSON_NUMBER;
 
-struct json_object_element_s {
-    struct json_string_s *name;
-    struct json_value_s *value;
-    struct json_object_element_s *next;
+typedef struct JSON_OBJECT_ELEMENT {
+    JSON_STRING *name;
+    JSON_VALUE *value;
+    struct JSON_OBJECT_ELEMENT *next;
     size_t ref_count;
-};
+} JSON_OBJECT_ELEMENT;
 
-struct json_object_s {
-    struct json_object_element_s *start;
+typedef struct {
+    JSON_OBJECT_ELEMENT *start;
     size_t length;
     size_t ref_count;
-};
+} JSON_OBJECT;
 
-struct json_array_element_s {
-    struct json_value_s *value;
-    struct json_array_element_s *next;
+typedef struct JSON_ARRAY_ELEMENT {
+    JSON_VALUE *value;
+    struct JSON_ARRAY_ELEMENT *next;
     size_t ref_count;
-};
+} JSON_ARRAY_ELEMENT;
 
-struct json_array_s {
-    struct json_array_element_s *start;
+typedef struct {
+    JSON_ARRAY_ELEMENT *start;
     size_t length;
     size_t ref_count;
-};
-
-struct json_value_s {
-    void *payload;
-    size_t type;
-    size_t ref_count;
-};
+} JSON_ARRAY;
 
-struct json_value_ex_s {
-    struct json_value_s value;
+typedef struct {
+    JSON_VALUE value;
     size_t offset;
     size_t line_no;
     size_t row_no;
-};
+} JSON_VALUE_EX;
 
 // numbers
-struct json_number_s *json_number_new_int(int number);
-struct json_number_s *json_number_new_int64(int64_t number);
-struct json_number_s *json_number_new_double(double number);
-void json_number_free(struct json_number_s *num);
+JSON_NUMBER *JSON_NumberNewInt(int number);
+JSON_NUMBER *JSON_NumberNewInt64(int64_t number);
+JSON_NUMBER *JSON_NumberNewDouble(double number);
+void JSON_NumberFree(JSON_NUMBER *num);
 
 // strings
-struct json_string_s *json_string_new(const char *string);
-void json_string_free(struct json_string_s *str);
+JSON_STRING *JSON_StringNew(const char *string);
+void JSON_StringFree(JSON_STRING *str);
 
 // arrays
-struct json_array_s *json_array_new(void);
-void json_array_free(struct json_array_s *arr);
-void json_array_element_free(struct json_array_element_s *element);
-
-void json_array_append(struct json_array_s *arr, struct json_value_s *value);
-void json_array_append_bool(struct json_array_s *arr, int b);
-void json_array_append_int(struct json_array_s *arr, int number);
-void json_array_append_double(struct json_array_s *arr, double number);
-void json_array_append_string(struct json_array_s *arr, const char *string);
-void json_array_append_array(
-    struct json_array_s *arr, struct json_array_s *arr2);
-void json_array_append_object(
-    struct json_array_s *arr, struct json_object_s *obj);
-
-struct json_value_s *json_array_get_value(
-    struct json_array_s *arr, const size_t idx);
-int json_array_get_bool(struct json_array_s *arr, const size_t idx, int d);
-int json_array_get_int(struct json_array_s *arr, const size_t idx, int d);
-double json_array_get_double(
-    struct json_array_s *arr, const size_t idx, double d);
-const char *json_array_get_string(
-    struct json_array_s *arr, const size_t idx, const char *d);
-struct json_array_s *json_array_get_array(
-    struct json_array_s *arr, const size_t idx);
-struct json_object_s *json_array_get_object(
-    struct json_array_s *arr, const size_t idx);
+JSON_ARRAY *JSON_ArrayNew(void);
+void JSON_ArrayFree(JSON_ARRAY *arr);
+void JSON_ArrayElementFree(JSON_ARRAY_ELEMENT *element);
+
+void JSON_ArrayAppend(JSON_ARRAY *arr, JSON_VALUE *value);
+void JSON_ArrayApendBool(JSON_ARRAY *arr, int b);
+void JSON_ArrayAppendInt(JSON_ARRAY *arr, int number);
+void JSON_ArrayAppendDouble(JSON_ARRAY *arr, double number);
+void JSON_ArrayAppendString(JSON_ARRAY *arr, const char *string);
+void JSON_ArrayAppendArray(JSON_ARRAY *arr, JSON_ARRAY *arr2);
+void JSON_ArrayAppendObject(JSON_ARRAY *arr, JSON_OBJECT *obj);
+
+JSON_VALUE *JSON_ArrayGetValue(JSON_ARRAY *arr, const size_t idx);
+int JSON_ArrayGetBool(JSON_ARRAY *arr, const size_t idx, int d);
+int JSON_ArrayGetInt(JSON_ARRAY *arr, const size_t idx, int d);
+double JSON_ArrayGetDouble(JSON_ARRAY *arr, const size_t idx, double d);
+const char *JSON_ArrayGetString(
+    JSON_ARRAY *arr, const size_t idx, const char *d);
+JSON_ARRAY *JSON_ArrayGetArray(JSON_ARRAY *arr, const size_t idx);
+JSON_OBJECT *JSON_ArrayGetObject(JSON_ARRAY *arr, const size_t idx);
 
 // objects
-struct json_object_s *json_object_new(void);
-void json_object_free(struct json_object_s *obj);
-void json_object_element_free(struct json_object_element_s *element);
-
-void json_object_append(
-    struct json_object_s *obj, const char *key, struct json_value_s *value);
-void json_object_append_bool(struct json_object_s *obj, const char *key, int b);
-void json_object_append_int(
-    struct json_object_s *obj, const char *key, int number);
-void json_object_append_int64(
-    struct json_object_s *obj, const char *key, int64_t number);
-void json_object_append_double(
-    struct json_object_s *obj, const char *key, double number);
-void json_object_append_string(
-    struct json_object_s *obj, const char *key, const char *string);
-void json_object_append_array(
-    struct json_object_s *obj, const char *key, struct json_array_s *arr);
-void json_object_append_object(
-    struct json_object_s *obj, const char *key, struct json_object_s *obj2);
-
-void json_object_evict_key(struct json_object_s *obj, const char *key);
-
-struct json_value_s *json_object_get_value(
-    struct json_object_s *obj, const char *key);
-int json_object_get_bool(struct json_object_s *obj, const char *key, int d);
-int json_object_get_int(struct json_object_s *obj, const char *key, int d);
-int64_t json_object_get_int64(
-    struct json_object_s *obj, const char *key, int64_t d);
-double json_object_get_double(
-    struct json_object_s *obj, const char *key, double d);
-const char *json_object_get_string(
-    struct json_object_s *obj, const char *key, const char *d);
-struct json_array_s *json_object_get_array(
-    struct json_object_s *obj, const char *key);
-struct json_object_s *json_object_get_object(
-    struct json_object_s *obj, const char *key);
+JSON_OBJECT *JSON_ObjectNew(void);
+void JSON_ObjectFree(JSON_OBJECT *obj);
+void JSON_ObjectElementFree(JSON_OBJECT_ELEMENT *element);
+
+void JSON_ObjectAppend(JSON_OBJECT *obj, const char *key, JSON_VALUE *value);
+void JSON_ObjectAppendBool(JSON_OBJECT *obj, const char *key, int b);
+void JSON_ObjectAppendInt(JSON_OBJECT *obj, const char *key, int number);
+void JSON_ObjectAppendInt64(JSON_OBJECT *obj, const char *key, int64_t number);
+void JSON_ObjectAppendDouble(JSON_OBJECT *obj, const char *key, double number);
+void JSON_ObjectAppendString(
+    JSON_OBJECT *obj, const char *key, const char *string);
+void JSON_ObjectAppendArray(JSON_OBJECT *obj, const char *key, JSON_ARRAY *arr);
+void JSON_ObjectAppendObject(
+    JSON_OBJECT *obj, const char *key, JSON_OBJECT *obj2);
+
+void JSON_ObjectEvictKey(JSON_OBJECT *obj, const char *key);
+
+JSON_VALUE *JSON_ObjectGetValue(JSON_OBJECT *obj, const char *key);
+int JSON_ObjectGetBool(JSON_OBJECT *obj, const char *key, int d);
+int JSON_ObjectGetInt(JSON_OBJECT *obj, const char *key, int d);
+int64_t JSON_ObjectGetInt64(JSON_OBJECT *obj, const char *key, int64_t d);
+double JSON_ObjectGetDouble(JSON_OBJECT *obj, const char *key, double d);
+const char *JSON_ObjectGetString(
+    JSON_OBJECT *obj, const char *key, const char *d);
+JSON_ARRAY *JSON_ObjectGetArray(JSON_OBJECT *obj, const char *key);
+JSON_OBJECT *JSON_ObjectGetObject(JSON_OBJECT *obj, const char *key);
 
 // values
-struct json_string_s *json_value_as_string(struct json_value_s *value);
-struct json_number_s *json_value_as_number(struct json_value_s *value);
-struct json_object_s *json_value_as_object(struct json_value_s *value);
-struct json_array_s *json_value_as_array(struct json_value_s *value);
-int json_value_is_true(const struct json_value_s *value);
-int json_value_is_false(const struct json_value_s *value);
-int json_value_is_null(const struct json_value_s *value);
-
-struct json_value_s *json_value_from_bool(int b);
-struct json_value_s *json_value_from_number(struct json_number_s *num);
-struct json_value_s *json_value_from_string(struct json_string_s *str);
-struct json_value_s *json_value_from_array(struct json_array_s *arr);
-struct json_value_s *json_value_from_object(struct json_object_s *obj);
-
-void json_value_free(struct json_value_s *value);
-
-enum json_parse_error_e {
-    json_parse_error_none = 0,
-    json_parse_error_expected_comma_or_closing_bracket,
-    json_parse_error_expected_colon,
-    json_parse_error_expected_opening_quote,
-    json_parse_error_invalid_string_escape_sequence,
-    json_parse_error_invalid_number_format,
-    json_parse_error_invalid_value,
-    json_parse_error_premature_end_of_buffer,
-    json_parse_error_invalid_string,
-    json_parse_error_allocator_failed,
-    json_parse_error_unexpected_trailing_characters,
-    json_parse_error_unknown
-};
-
-struct json_parse_result_s {
+JSON_STRING *JSON_ValueAsString(JSON_VALUE *value);
+JSON_NUMBER *JSON_ValueAsNumber(JSON_VALUE *value);
+JSON_OBJECT *JSON_ValueAsObject(JSON_VALUE *value);
+JSON_ARRAY *JSON_ValueAsArray(JSON_VALUE *value);
+int JSON_ValueIsTrue(const JSON_VALUE *value);
+int JSON_ValueIsFalse(const JSON_VALUE *value);
+int JSON_ValueIsNull(const JSON_VALUE *value);
+
+JSON_VALUE *JSON_ValueFromBool(int b);
+JSON_VALUE *JSON_ValueFromNumber(JSON_NUMBER *num);
+JSON_VALUE *JSON_ValueFromString(JSON_STRING *str);
+JSON_VALUE *JSON_ValueFromArray(JSON_ARRAY *arr);
+JSON_VALUE *JSON_ValueFromObject(JSON_OBJECT *obj);
+
+void JSON_ValueFree(JSON_VALUE *value);
+
+typedef enum {
+    JSON_PARSE_ERROR_NONE = 0,
+    JSON_PARSE_ERROR_EXPECTED_COMMA_OR_CLOSING_BRACKET,
+    JSON_PARSE_ERROR_EXPECTED_COLON,
+    JSON_PARSE_ERROR_EXPECTED_OPENING_QUOTE,
+    JSON_PARSE_ERROR_INVALID_STRING_ESCAPE_SEQUENCE,
+    JSON_PARSE_ERROR_INVALID_NUMBER_FORMAT,
+    JSON_PARSE_ERROR_INVALID_VALUE,
+    JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER,
+    JSON_PARSE_ERROR_INVALID_STRING,
+    JSON_PARSE_ERROR_ALLOCATOR_FAILED,
+    JSON_PARSE_ERROR_UNEXPECTED_TRAILING_CHARACTERS,
+    JSON_PARSE_ERROR_UNKNOWN
+} JSON_PARSE_ERROR;
+
+typedef struct {
     size_t error;
     size_t error_offset;
     size_t error_line_no;
     size_t error_row_no;
-};
+} JSON_PARSE_RESULT;
 
-enum json_parse_flags_e {
-    json_parse_flags_default = 0,
+typedef enum {
+    JSON_PARSE_FLAGS_DEFAULT = 0,
 
     /* allow trailing commas in objects and arrays. For example, both [true,]
        and
        {"a" : null,} would be allowed with this option on. */
-    json_parse_flags_allow_trailing_comma = 0x1,
+    JSON_PARSE_FLAGS_ALLOW_TRAILING_COMMA = 0x1,
 
     /* allow unquoted keys for objects. For example, {a : null} would be allowed
        with this option on. */
-    json_parse_flags_allow_unquoted_keys = 0x2,
+    JSON_PARSE_FLAGS_ALLOW_UNQUOTED_KEYS = 0x2,
 
     /* allow a global unbracketed object. For example, a : null, b : true, c :
        {} would be allowed with this option on. */
-    json_parse_flags_allow_global_object = 0x4,
+    JSON_PARSE_FLAGS_ALLOW_GLOBAL_OBJECT = 0x4,
 
     /* allow objects to use '=' instead of ':' between key/value pairs. For
        example, a = null, b : true would be allowed with this option on. */
-    json_parse_flags_allow_equals_in_object = 0x8,
+    JSON_PARSE_FLAGS_ALLOW_EQUALS_IN_OBJECT = 0x8,
 
     /* allow that objects don't have to have comma separators between key/value
        pairs. */
-    json_parse_flags_allow_no_commas = 0x10,
+    JSON_PARSE_FLAGS_ALLOW_NO_COMMAS = 0x10,
 
     /* allow c-style comments (either variants) to be ignored in the input JSON
        file. */
-    json_parse_flags_allow_c_style_comments = 0x20,
+    JSON_PARSE_FLAGS_ALLOW_C_STYLE_COMMENTS = 0x20,
 
     /* deprecated flag, unused. */
-    json_parse_flags_deprecated = 0x40,
+    JSON_PARSE_FLAGS_DEPRECATED = 0x40,
 
     /* record location information for each value. */
-    json_parse_flags_allow_location_information = 0x80,
+    JSON_PARSE_FLAGS_ALLOW_LOCATION_INFORMATION = 0x80,
 
     /* allow strings to be 'single quoted'. */
-    json_parse_flags_allow_single_quoted_strings = 0x100,
+    JSON_PARSE_FLAGS_ALLOW_SINGLE_QUOTED_STRINGS = 0x100,
 
     /* allow numbers to be hexadecimal. */
-    json_parse_flags_allow_hexadecimal_numbers = 0x200,
+    JSON_PARSE_FLAGS_ALLOW_HEXADECIMAL_NUMBERS = 0x200,
 
     /* allow numbers like +123 to be parsed. */
-    json_parse_flags_allow_leading_plus_sign = 0x400,
+    JSON_PARSE_FLAGS_ALLOW_LEADING_PLUS_SIGN = 0x400,
 
     /* allow numbers like .0123 or 123. to be parsed. */
-    json_parse_flags_allow_leading_or_trailing_decimal_point = 0x800,
+    JSON_PARSE_FLAGS_ALLOW_LEADING_OR_TRAILING_DECIMAL_POINT = 0x800,
 
     /* allow Infinity, -Infinity, NaN, -NaN. */
-    json_parse_flags_allow_inf_and_nan = 0x1000,
+    JSON_PARSE_FLAGS_ALLOW_INF_AND_NAN = 0x1000,
 
     /* allow multi line string values. */
-    json_parse_flags_allow_multi_line_strings = 0x2000,
+    JSON_PARSE_FLAGS_ALLOW_MULTI_LINE_STRINGS = 0x2000,
 
     /* allow simplified JSON to be parsed. Simplified JSON is an enabling of a
        set of other parsing options. */
-    json_parse_flags_allow_simplified_json =
-        (json_parse_flags_allow_trailing_comma
-         | json_parse_flags_allow_unquoted_keys
-         | json_parse_flags_allow_global_object
-         | json_parse_flags_allow_equals_in_object
-         | json_parse_flags_allow_no_commas),
+    JSON_PARSE_FLAGS_ALLOW_SIMPLIFIED_JSON =
+        (JSON_PARSE_FLAGS_ALLOW_TRAILING_COMMA
+         | JSON_PARSE_FLAGS_ALLOW_UNQUOTED_KEYS
+         | JSON_PARSE_FLAGS_ALLOW_GLOBAL_OBJECT
+         | JSON_PARSE_FLAGS_ALLOW_EQUALS_IN_OBJECT
+         | JSON_PARSE_FLAGS_ALLOW_NO_COMMAS),
 
     /* allow JSON5 to be parsed. JSON5 is an enabling of a set of other parsing
        options. */
-    json_parse_flags_allow_json5 =
-        (json_parse_flags_allow_trailing_comma
-         | json_parse_flags_allow_unquoted_keys
-         | json_parse_flags_allow_c_style_comments
-         | json_parse_flags_allow_single_quoted_strings
-         | json_parse_flags_allow_hexadecimal_numbers
-         | json_parse_flags_allow_leading_plus_sign
-         | json_parse_flags_allow_leading_or_trailing_decimal_point
-         | json_parse_flags_allow_inf_and_nan
-         | json_parse_flags_allow_multi_line_strings)
-};
+    JSON_PARSE_FLAGS_ALLOW_JSON5 =
+        (JSON_PARSE_FLAGS_ALLOW_TRAILING_COMMA
+         | JSON_PARSE_FLAGS_ALLOW_UNQUOTED_KEYS
+         | JSON_PARSE_FLAGS_ALLOW_C_STYLE_COMMENTS
+         | JSON_PARSE_FLAGS_ALLOW_SINGLE_QUOTED_STRINGS
+         | JSON_PARSE_FLAGS_ALLOW_HEXADECIMAL_NUMBERS
+         | JSON_PARSE_FLAGS_ALLOW_LEADING_PLUS_SIGN
+         | JSON_PARSE_FLAGS_ALLOW_LEADING_OR_TRAILING_DECIMAL_POINT
+         | JSON_PARSE_FLAGS_ALLOW_INF_AND_NAN
+         | JSON_PARSE_FLAGS_ALLOW_MULTI_LINE_STRINGS)
+} JSON_PARSE_FLAGS;
 
 /* Parse a JSON text file, returning a pointer to the root of the JSON
- * structure. json_parse performs 1 call to malloc for the entire encoding.
+ * structure. JSON_Parse performs 1 call to malloc for the entire encoding.
  * Returns 0 if an error occurred (malformed JSON input, or malloc failed). */
-struct json_value_s *json_parse(const void *src, size_t src_size);
+JSON_VALUE *JSON_Parse(const void *src, size_t src_size);
 
 /* Parse a JSON text file, returning a pointer to the root of the JSON
- * structure. json_parse performs 1 call to alloc_func_ptr for the entire
+ * structure. JSON_Parse performs 1 call to alloc_func_ptr for the entire
  * encoding. Returns 0 if an error occurred (malformed JSON input, or malloc
  * failed). If an error occurred, the result struct (if not NULL) will explain
  * the type of error, and the location in the input it occurred. If
  * alloc_func_ptr is null then malloc is used. */
-struct json_value_s *json_parse_ex(
+JSON_VALUE *JSON_ParseEx(
     const void *src, size_t src_size, size_t flags_bitset,
     void *(*alloc_func_ptr)(void *, size_t), void *user_data,
-    struct json_parse_result_s *result);
+    JSON_PARSE_RESULT *result);
 
-const char *json_get_error_description(enum json_parse_error_e error);
+const char *JSON_GetErrorDescription(JSON_PARSE_ERROR error);
 
 /* Write out a minified JSON utf-8 string. This string is an encoding of the
  * minimal string characters required to still encode the same data.
  * json_write_minified performs 1 call to malloc for the entire encoding. Return
  * 0 if an error occurred (malformed JSON input, or malloc failed). The out_size
  * parameter is optional as the utf-8 string is null terminated. */
-void *json_write_minified(const struct json_value_s *value, size_t *out_size);
+void *JSON_WriteMinified(const JSON_VALUE *value, size_t *out_size);
 
 /* Write out a pretty JSON utf-8 string. This string is encoded such that the
  * resultant JSON is pretty in that it is easily human readable. The indent and
@@ -303,6 +286,6 @@ void *json_write_minified(const struct json_value_s *value, size_t *out_size);
  * json_write_pretty performs 1 call to malloc for the entire encoding. Return 0
  * if an error occurred (malformed JSON input, or malloc failed). The out_size
  * parameter is optional as the utf-8 string is null terminated. */
-void *json_write_pretty(
-    const struct json_value_s *value, const char *indent, const char *newline,
+void *JSON_WritePretty(
+    const JSON_VALUE *value, const char *indent, const char *newline,
     size_t *out_size);
diff --git a/src/config/config_file.c b/src/config/config_file.c
index 0405c21..187d3b5 100644
--- a/src/config/config_file.c
+++ b/src/config/config_file.c
@@ -7,50 +7,49 @@
 #include <string.h>
 
 static bool M_ReadFromJSON(
-    const char *json, void (*load)(struct json_object_s *root_obj));
-static char *M_WriteToJSON(void (*dump)(struct json_object_s *root_obj));
+    const char *json, void (*load)(JSON_OBJECT *root_obj));
+static char *M_WriteToJSON(void (*dump)(JSON_OBJECT *root_obj));
 static const char *M_ResolveOptionName(const char *option_name);
 
 static bool M_ReadFromJSON(
-    const char *cfg_data, void (*load)(struct json_object_s *root_obj))
+    const char *cfg_data, void (*load)(JSON_OBJECT *root_obj))
 {
     bool result = false;
-    struct json_value_s *root;
-    struct json_parse_result_s parse_result;
 
-    root = json_parse_ex(
-        cfg_data, strlen(cfg_data), json_parse_flags_allow_json5, NULL, NULL,
+    JSON_PARSE_RESULT parse_result;
+    JSON_VALUE *root = JSON_ParseEx(
+        cfg_data, strlen(cfg_data), JSON_PARSE_FLAGS_ALLOW_JSON5, NULL, NULL,
         &parse_result);
-    if (root) {
+    if (root != NULL) {
         result = true;
     } else {
         LOG_ERROR(
             "failed to parse config file: %s in line %d, char %d",
-            json_get_error_description(parse_result.error),
+            JSON_GetErrorDescription(parse_result.error),
             parse_result.error_line_no, parse_result.error_row_no);
         // continue to supply the default values
     }
 
-    struct json_object_s *root_obj = json_value_as_object(root);
+    JSON_OBJECT *root_obj = JSON_ValueAsObject(root);
     load(root_obj);
 
     if (root) {
-        json_value_free(root);
+        JSON_ValueFree(root);
     }
 
     return result;
 }
 
-static char *M_WriteToJSON(void (*dump)(struct json_object_s *root_obj))
+static char *M_WriteToJSON(void (*dump)(JSON_OBJECT *root_obj))
 {
-    struct json_object_s *root_obj = json_object_new();
+    JSON_OBJECT *root_obj = JSON_ObjectNew();
 
     dump(root_obj);
 
-    struct json_value_s *root = json_value_from_object(root_obj);
+    JSON_VALUE *root = JSON_ValueFromObject(root_obj);
     size_t size;
-    char *data = json_write_pretty(root, "  ", "\n", &size);
-    json_value_free(root);
+    char *data = JSON_WritePretty(root, "  ", "\n", &size);
+    JSON_ValueFree(root);
 
     return data;
 }
@@ -64,8 +63,7 @@ static const char *M_ResolveOptionName(const char *option_name)
     return option_name;
 }
 
-bool ConfigFile_Read(
-    const char *path, void (*load)(struct json_object_s *root_obj))
+bool ConfigFile_Read(const char *path, void (*load)(JSON_OBJECT *root_obj))
 {
     bool result = false;
     char *cfg_data = NULL;
@@ -81,8 +79,7 @@ bool ConfigFile_Read(
     return result;
 }
 
-bool ConfigFile_Write(
-    const char *path, void (*dump)(struct json_object_s *root_obj))
+bool ConfigFile_Write(const char *path, void (*dump)(JSON_OBJECT *root_obj))
 {
     LOG_INFO("Saving user settings");
 
@@ -99,32 +96,31 @@ bool ConfigFile_Write(
     return true;
 }
 
-void ConfigFile_LoadOptions(
-    struct json_object_s *root_obj, const CONFIG_OPTION *options)
+void ConfigFile_LoadOptions(JSON_OBJECT *root_obj, const CONFIG_OPTION *options)
 {
     const CONFIG_OPTION *opt = options;
     while (opt->target) {
         switch (opt->type) {
         case COT_BOOL:
-            *(bool *)opt->target = json_object_get_bool(
+            *(bool *)opt->target = JSON_ObjectGetBool(
                 root_obj, M_ResolveOptionName(opt->name),
                 *(bool *)opt->default_value);
             break;
 
         case COT_INT32:
-            *(int32_t *)opt->target = json_object_get_int(
+            *(int32_t *)opt->target = JSON_ObjectGetInt(
                 root_obj, M_ResolveOptionName(opt->name),
                 *(int32_t *)opt->default_value);
             break;
 
         case COT_FLOAT:
-            *(float *)opt->target = json_object_get_double(
+            *(float *)opt->target = JSON_ObjectGetDouble(
                 root_obj, M_ResolveOptionName(opt->name),
                 *(float *)opt->default_value);
             break;
 
         case COT_DOUBLE:
-            *(double *)opt->target = json_object_get_double(
+            *(double *)opt->target = JSON_ObjectGetDouble(
                 root_obj, M_ResolveOptionName(opt->name),
                 *(double *)opt->default_value);
             break;
@@ -139,31 +135,30 @@ void ConfigFile_LoadOptions(
     }
 }
 
-void ConfigFile_DumpOptions(
-    struct json_object_s *root_obj, const CONFIG_OPTION *options)
+void ConfigFile_DumpOptions(JSON_OBJECT *root_obj, const CONFIG_OPTION *options)
 {
     const CONFIG_OPTION *opt = options;
     while (opt->target) {
         switch (opt->type) {
         case COT_BOOL:
-            json_object_append_bool(
+            JSON_ObjectAppendBool(
                 root_obj, M_ResolveOptionName(opt->name), *(bool *)opt->target);
             break;
 
         case COT_INT32:
-            json_object_append_int(
+            JSON_ObjectAppendInt(
                 root_obj, M_ResolveOptionName(opt->name),
                 *(int32_t *)opt->target);
             break;
 
         case COT_FLOAT:
-            json_object_append_double(
+            JSON_ObjectAppendDouble(
                 root_obj, M_ResolveOptionName(opt->name),
                 *(float *)opt->target);
             break;
 
         case COT_DOUBLE:
-            json_object_append_double(
+            JSON_ObjectAppendDouble(
                 root_obj, M_ResolveOptionName(opt->name),
                 *(double *)opt->target);
             break;
@@ -179,10 +174,10 @@ void ConfigFile_DumpOptions(
 }
 
 int ConfigFile_ReadEnum(
-    struct json_object_s *obj, const char *name, int default_value,
+    JSON_OBJECT *obj, const char *name, int default_value,
     const ENUM_STRING_MAP *enum_map)
 {
-    const char *value_str = json_object_get_string(obj, name, NULL);
+    const char *value_str = JSON_ObjectGetString(obj, name, NULL);
     if (value_str) {
         while (enum_map->text) {
             if (!strcmp(value_str, enum_map->text)) {
@@ -195,12 +190,12 @@ int ConfigFile_ReadEnum(
 }
 
 void ConfigFile_WriteEnum(
-    struct json_object_s *obj, const char *name, int value,
+    JSON_OBJECT *obj, const char *name, int value,
     const ENUM_STRING_MAP *enum_map)
 {
     while (enum_map->text) {
         if (enum_map->value == value) {
-            json_object_append_string(obj, name, enum_map->text);
+            JSON_ObjectAppendString(obj, name, enum_map->text);
             break;
         }
         enum_map++;
diff --git a/src/engine/audio_sample.c b/src/engine/audio_sample.c
index cc7648a..52dfffe 100644
--- a/src/engine/audio_sample.c
+++ b/src/engine/audio_sample.c
@@ -24,7 +24,7 @@
 #include <string.h>
 #include <time.h>
 
-typedef struct AUDIO_SAMPLE {
+typedef struct {
     char *original_data;
     size_t original_size;
 
@@ -33,7 +33,7 @@ typedef struct AUDIO_SAMPLE {
     int32_t num_samples;
 } AUDIO_SAMPLE;
 
-typedef struct AUDIO_SAMPLE_SOUND {
+typedef struct {
     bool is_used;
     bool is_looped;
     bool is_playing;
@@ -50,7 +50,7 @@ typedef struct AUDIO_SAMPLE_SOUND {
     AUDIO_SAMPLE *sample;
 } AUDIO_SAMPLE_SOUND;
 
-typedef struct AUDIO_AV_BUFFER {
+typedef struct {
     const char *data;
     const char *ptr;
     int32_t size;
diff --git a/src/engine/audio_stream.c b/src/engine/audio_stream.c
index 4001298..7400941 100644
--- a/src/engine/audio_stream.c
+++ b/src/engine/audio_stream.c
@@ -28,7 +28,7 @@
 #define READ_BUFFER_SIZE                                                       \
     (AUDIO_SAMPLES * AUDIO_WORKING_CHANNELS * sizeof(AUDIO_WORKING_FORMAT))
 
-typedef struct AUDIO_STREAM_SOUND {
+typedef struct {
     bool is_used;
     bool is_playing;
     bool is_read_done;
diff --git a/src/game/console/cmd/config.c b/src/game/console/cmd/config.c
index f0d2e82..2c11add 100644
--- a/src/game/console/cmd/config.c
+++ b/src/game/console/cmd/config.c
@@ -227,7 +227,10 @@ COMMAND_RESULT Console_Cmd_Config_Helper(
         if (M_GetCurrentValue(option, cur_value, 128)) {
             Console_Log(GS(OSD_CONFIG_OPTION_GET), normalized_name, cur_value);
             result = CR_SUCCESS;
+        } else {
+            result = CR_FAILURE;
         }
+        return result;
     }
 
     if (M_SetCurrentValue(option, new_value)) {
diff --git a/src/game/console/cmd/die.c b/src/game/console/cmd/die.c
index 39b1c9f..c34a053 100644
--- a/src/game/console/cmd/die.c
+++ b/src/game/console/cmd/die.c
@@ -6,17 +6,22 @@
 #include "game/objects/common.h"
 #include "game/objects/ids.h"
 #include "game/sound.h"
+#include "strings.h"
 
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *ctx);
 
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *const ctx)
 {
+    if (!String_IsEmpty(ctx->args)) {
+        return CR_BAD_INVOCATION;
+    }
+
     if (!Object_GetObject(O_LARA)->loaded) {
         return CR_UNAVAILABLE;
     }
 
     LARA_INFO *const lara = Lara_GetLaraInfo();
-    ITEM_INFO *const lara_item = Lara_GetItem();
+    ITEM *const lara_item = Lara_GetItem();
     if (lara_item->hit_points <= 0) {
         return CR_UNAVAILABLE;
     }
diff --git a/src/game/console/cmd/end_level.c b/src/game/console/cmd/end_level.c
index 9cac5ab..06400cb 100644
--- a/src/game/console/cmd/end_level.c
+++ b/src/game/console/cmd/end_level.c
@@ -7,7 +7,7 @@ static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *ctx);
 
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *const ctx)
 {
-    if (!String_Equivalent(ctx->args, "")) {
+    if (!String_IsEmpty(ctx->args)) {
         return CR_BAD_INVOCATION;
     }
 
diff --git a/src/game/console/cmd/exit_game.c b/src/game/console/cmd/exit_game.c
index 37edd28..f4ab38b 100644
--- a/src/game/console/cmd/exit_game.c
+++ b/src/game/console/cmd/exit_game.c
@@ -1,11 +1,16 @@
 #include "game/console/cmd/exit_game.h"
 
 #include "game/gameflow/common.h"
+#include "strings.h"
 
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *ctx);
 
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *const ctx)
 {
+    if (!String_IsEmpty(ctx->args)) {
+        return CR_BAD_INVOCATION;
+    }
+
     Gameflow_OverrideCommand((GAMEFLOW_COMMAND) { .action = GF_EXIT_GAME });
     return CR_SUCCESS;
 }
diff --git a/src/game/console/cmd/exit_to_title.c b/src/game/console/cmd/exit_to_title.c
index 5d89e93..83a4d82 100644
--- a/src/game/console/cmd/exit_to_title.c
+++ b/src/game/console/cmd/exit_to_title.c
@@ -1,11 +1,16 @@
 #include "game/console/cmd/exit_to_title.h"
 
 #include "game/gameflow/common.h"
+#include "strings.h"
 
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *ctx);
 
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *const ctx)
 {
+    if (!String_IsEmpty(ctx->args)) {
+        return CR_BAD_INVOCATION;
+    }
+
     Gameflow_OverrideCommand((GAMEFLOW_COMMAND) { .action = GF_EXIT_TO_TITLE });
     return CR_SUCCESS;
 }
diff --git a/src/game/console/cmd/fly.c b/src/game/console/cmd/fly.c
index 4719328..98fabd6 100644
--- a/src/game/console/cmd/fly.c
+++ b/src/game/console/cmd/fly.c
@@ -3,6 +3,8 @@
 #include "game/game.h"
 #include "game/game_string.h"
 #include "game/lara/cheat.h"
+#include "game/lara/common.h"
+#include "strings.h"
 
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *ctx);
 
@@ -11,7 +13,27 @@ static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *const ctx)
     if (!Game_IsPlayable()) {
         return CR_UNAVAILABLE;
     }
-    Lara_Cheat_EnterFlyMode();
+
+    bool enable;
+    if (String_ParseBool(ctx->args, &enable)) {
+        if (enable) {
+            Lara_Cheat_EnterFlyMode();
+        } else {
+            Lara_Cheat_ExitFlyMode();
+        }
+        return CR_SUCCESS;
+    }
+
+    if (!String_IsEmpty(ctx->args)) {
+        return CR_BAD_INVOCATION;
+    }
+
+    const LARA_INFO *const lara = Lara_GetLaraInfo();
+    if (lara->water_status == LWS_CHEAT) {
+        Lara_Cheat_ExitFlyMode();
+    } else {
+        Lara_Cheat_EnterFlyMode();
+    }
     return CR_SUCCESS;
 }
 
diff --git a/src/game/console/cmd/give_item.c b/src/game/console/cmd/give_item.c
index 69e6462..a0647cb 100644
--- a/src/game/console/cmd/give_item.c
+++ b/src/game/console/cmd/give_item.c
@@ -49,7 +49,7 @@ static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *const ctx)
         args++;
     }
 
-    if (String_Equivalent(args, "")) {
+    if (String_IsEmpty(ctx->args)) {
         return CR_BAD_INVOCATION;
     }
 
diff --git a/src/game/console/cmd/heal.c b/src/game/console/cmd/heal.c
index fd620bd..3624281 100644
--- a/src/game/console/cmd/heal.c
+++ b/src/game/console/cmd/heal.c
@@ -5,16 +5,21 @@
 #include "game/lara/common.h"
 #include "game/lara/const.h"
 #include "game/lara/misc.h"
+#include "strings.h"
 
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *ctx);
 
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *const ctx)
 {
+    if (!String_IsEmpty(ctx->args)) {
+        return CR_BAD_INVOCATION;
+    }
+
     if (!Game_IsPlayable()) {
         return CR_UNAVAILABLE;
     }
 
-    ITEM_INFO *const lara_item = Lara_GetItem();
+    ITEM *const lara_item = Lara_GetItem();
     if (lara_item->hit_points == LARA_MAX_HITPOINTS) {
         Console_Log(GS(OSD_HEAL_ALREADY_FULL_HP));
         return CR_SUCCESS;
diff --git a/src/game/console/cmd/kill.c b/src/game/console/cmd/kill.c
index 5a586d4..2d6ac81 100644
--- a/src/game/console/cmd/kill.c
+++ b/src/game/console/cmd/kill.c
@@ -15,6 +15,9 @@
 #include "strings.h"
 
 static bool M_CanTargetObjectCreature(GAME_OBJECT_ID object_id);
+static COMMAND_RESULT M_KillAllEnemies(void);
+static COMMAND_RESULT M_KillNearestEnemies(void);
+static COMMAND_RESULT M_KillEnemyType(const char *enemy_name);
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *ctx);
 
 static bool M_CanTargetObjectCreature(const GAME_OBJECT_ID object_id)
@@ -23,100 +26,107 @@ static bool M_CanTargetObjectCreature(const GAME_OBJECT_ID object_id)
         || Object_IsObjectType(object_id, g_AllyObjects);
 }
 
-static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *const ctx)
+static COMMAND_RESULT M_KillAllEnemies(void)
 {
-    // kill all the enemies in the level
-    if (String_Equivalent(ctx->args, "all")) {
-        int32_t num_killed = 0;
-        for (int16_t item_num = 0; item_num < Item_GetTotalCount();
-             item_num++) {
-            const ITEM_INFO *const item = Item_Get(item_num);
-            if (!Creature_IsEnemy(item)) {
-                continue;
-            }
-            if (Lara_Cheat_KillEnemy(item_num)) {
-                num_killed++;
-            }
+    int32_t num_killed = 0;
+    for (int16_t item_num = 0; item_num < Item_GetTotalCount(); item_num++) {
+        const ITEM *const item = Item_Get(item_num);
+        if (!Creature_IsEnemy(item)) {
+            continue;
         }
-
-        if (num_killed == 0) {
-            Console_Log(GS(OSD_KILL_ALL_FAIL));
-            return CR_FAILURE;
+        if (Lara_Cheat_KillEnemy(item_num)) {
+            num_killed++;
         }
+    }
 
-        Console_Log(GS(OSD_KILL_ALL), num_killed);
-        return CR_SUCCESS;
+    if (num_killed == 0) {
+        Console_Log(GS(OSD_KILL_ALL_FAIL));
+        return CR_FAILURE;
     }
 
-    // kill all the enemies around Lara within one tile, or a single nearest
-    // enemy
-    if (String_Equivalent(ctx->args, "")) {
-        bool found = false;
-        while (true) {
-            const int16_t best_item_num = Lara_GetNearestEnemy();
-            if (best_item_num == NO_ITEM) {
-                break;
-            }
+    Console_Log(GS(OSD_KILL_ALL), num_killed);
+    return CR_SUCCESS;
+}
 
-            const ITEM_INFO *const lara_item = Lara_GetItem();
-            const ITEM_INFO *const item = Item_Get(best_item_num);
-            const int32_t distance = Item_GetDistance(item, &lara_item->pos);
-            found |= Lara_Cheat_KillEnemy(best_item_num);
-            if (distance >= WALL_L) {
-                break;
-            }
+static COMMAND_RESULT M_KillNearestEnemies(void)
+{
+    bool found = false;
+    while (true) {
+        const int16_t best_item_num = Lara_GetNearestEnemy();
+        if (best_item_num == NO_ITEM) {
+            break;
         }
 
-        if (!found) {
-            Console_Log(GS(OSD_KILL_FAIL));
-            return CR_FAILURE;
+        const ITEM *const lara_item = Lara_GetItem();
+        const ITEM *const item = Item_Get(best_item_num);
+        const int32_t distance = Item_GetDistance(item, &lara_item->pos);
+        found |= Lara_Cheat_KillEnemy(best_item_num);
+        if (distance >= WALL_L) {
+            break;
         }
+    }
 
-        Console_Log(GS(OSD_KILL));
-        return CR_SUCCESS;
+    if (!found) {
+        Console_Log(GS(OSD_KILL_FAIL));
+        return CR_FAILURE;
     }
 
-    // kill a single enemy type
-    {
-        bool matches_found = false;
-        int32_t num_killed = 0;
-        int32_t match_count = 0;
-        GAME_OBJECT_ID *matching_objs = Object_IdsFromName(
-            ctx->args, &match_count, M_CanTargetObjectCreature);
-
-        for (int16_t item_num = 0; item_num < Item_GetTotalCount();
-             item_num++) {
-            const ITEM_INFO *const item = Item_Get(item_num);
-
-            bool is_matched = false;
-            for (int32_t i = 0; i < match_count; i++) {
-                if (matching_objs[i] == item->object_id) {
-                    is_matched = true;
-                    break;
-                }
-            }
-            if (!is_matched) {
-                continue;
-            }
-            matches_found = true;
+    Console_Log(GS(OSD_KILL));
+    return CR_SUCCESS;
+}
 
-            if (Lara_Cheat_KillEnemy(item_num)) {
-                num_killed++;
+static COMMAND_RESULT M_KillEnemyType(const char *const enemy_name)
+{
+    bool matches_found = false;
+    int32_t num_killed = 0;
+    int32_t match_count = 0;
+    GAME_OBJECT_ID *matching_objs =
+        Object_IdsFromName(enemy_name, &match_count, M_CanTargetObjectCreature);
+
+    for (int16_t item_num = 0; item_num < Item_GetTotalCount(); item_num++) {
+        const ITEM *const item = Item_Get(item_num);
+
+        bool is_matched = false;
+        for (int32_t i = 0; i < match_count; i++) {
+            if (matching_objs[i] == item->object_id) {
+                is_matched = true;
+                break;
             }
         }
-        Memory_FreePointer(&matching_objs);
-
-        if (!matches_found) {
-            Console_Log(GS(OSD_INVALID_OBJECT), ctx->args);
-            return CR_FAILURE;
+        if (!is_matched) {
+            continue;
         }
-        if (num_killed == 0) {
-            Console_Log(GS(OSD_OBJECT_NOT_FOUND), ctx->args);
-            return CR_FAILURE;
+        matches_found = true;
+
+        if (Lara_Cheat_KillEnemy(item_num)) {
+            num_killed++;
         }
-        Console_Log(GS(OSD_KILL_ALL), num_killed);
-        return CR_SUCCESS;
     }
+    Memory_FreePointer(&matching_objs);
+
+    if (!matches_found) {
+        Console_Log(GS(OSD_INVALID_OBJECT), enemy_name);
+        return CR_FAILURE;
+    }
+    if (num_killed == 0) {
+        Console_Log(GS(OSD_OBJECT_NOT_FOUND), enemy_name);
+        return CR_FAILURE;
+    }
+    Console_Log(GS(OSD_KILL_ALL), num_killed);
+    return CR_SUCCESS;
+}
+
+static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *const ctx)
+{
+    if (String_Equivalent(ctx->args, "all")) {
+        return M_KillAllEnemies();
+    }
+
+    if (String_IsEmpty(ctx->args)) {
+        return M_KillNearestEnemies();
+    }
+
+    return M_KillEnemyType(ctx->args);
 }
 
 CONSOLE_COMMAND g_Console_Cmd_Kill = {
diff --git a/src/game/console/cmd/play_demo.c b/src/game/console/cmd/play_demo.c
index ef14a4b..e3c5a48 100644
--- a/src/game/console/cmd/play_demo.c
+++ b/src/game/console/cmd/play_demo.c
@@ -1,11 +1,16 @@
 #include "game/console/cmd/play_demo.h"
 
 #include "game/gameflow/common.h"
+#include "strings.h"
 
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *ctx);
 
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *const ctx)
 {
+    if (!String_IsEmpty(ctx->args)) {
+        return CR_BAD_INVOCATION;
+    }
+
     Gameflow_OverrideCommand((GAMEFLOW_COMMAND) { .action = GF_START_DEMO });
     return CR_SUCCESS;
 }
diff --git a/src/game/console/cmd/pos.c b/src/game/console/cmd/pos.c
index cbd76cf..c163eb4 100644
--- a/src/game/console/cmd/pos.c
+++ b/src/game/console/cmd/pos.c
@@ -5,17 +5,22 @@
 #include "game/game_string.h"
 #include "game/lara/common.h"
 #include "game/objects/common.h"
+#include "strings.h"
 
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *ctx);
 
 static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *const ctx)
 {
-    const OBJECT_INFO *const object = Object_GetObject(O_LARA);
+    if (!String_IsEmpty(ctx->args)) {
+        return CR_BAD_INVOCATION;
+    }
+
+    const OBJECT *const object = Object_GetObject(O_LARA);
     if (!object->loaded) {
         return CR_UNAVAILABLE;
     }
 
-    const ITEM_INFO *const lara_item = Lara_GetItem();
+    const ITEM *const lara_item = Lara_GetItem();
 
     // clang-format off
     Console_Log(
diff --git a/src/game/console/cmd/set_health.c b/src/game/console/cmd/set_health.c
index 265b512..6d31d12 100644
--- a/src/game/console/cmd/set_health.c
+++ b/src/game/console/cmd/set_health.c
@@ -17,7 +17,7 @@ static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *const ctx)
         return CR_UNAVAILABLE;
     }
 
-    ITEM_INFO *const lara_item = Lara_GetItem();
+    ITEM *const lara_item = Lara_GetItem();
     if (String_IsEmpty(ctx->args)) {
         Console_Log(GS(OSD_CURRENT_HEALTH_GET), lara_item->hit_points);
         return CR_SUCCESS;
diff --git a/src/game/console/cmd/teleport.c b/src/game/console/cmd/teleport.c
index 3f4183b..22db227 100644
--- a/src/game/console/cmd/teleport.c
+++ b/src/game/console/cmd/teleport.c
@@ -62,21 +62,13 @@ static COMMAND_RESULT M_TeleportToRoom(const int16_t room_num)
         return CR_FAILURE;
     }
 
-    const ROOM_INFO *const room = Room_Get(room_num);
-#if TR_VERSION == 1
-    const int32_t rx = room->x;
-    const int32_t rz = room->z;
-#elif TR_VERSION == 2
-    const int32_t rx = room->pos.x;
-    const int32_t rz = room->pos.z;
-#endif
-
-    const int32_t x1 = rx + WALL_L;
-    const int32_t x2 = rx + (room->x_size << WALL_SHIFT) - WALL_L;
+    const ROOM *const room = Room_Get(room_num);
+    const int32_t x1 = room->pos.x + WALL_L;
+    const int32_t x2 = room->pos.x + (room->size.x << WALL_SHIFT) - WALL_L;
     const int32_t y1 = room->min_floor;
     const int32_t y2 = room->max_ceiling;
-    const int32_t z1 = rz + WALL_L;
-    const int32_t z2 = rz + (room->z_size << WALL_SHIFT) - WALL_L;
+    const int32_t z1 = room->pos.z + WALL_L;
+    const int32_t z2 = room->pos.z + (room->size.z << WALL_SHIFT) - WALL_L;
 
     bool success = false;
     for (int32_t i = 0; i < 100; i++) {
@@ -109,12 +101,12 @@ static COMMAND_RESULT M_TeleportToObject(const char *const user_input)
     GAME_OBJECT_ID *matching_objs =
         Object_IdsFromName(user_input, &match_count, M_CanTargetObject);
 
-    const ITEM_INFO *const lara_item = Lara_GetItem();
-    const ITEM_INFO *best_item = NULL;
+    const ITEM *const lara_item = Lara_GetItem();
+    const ITEM *best_item = NULL;
     int32_t best_distance = INT32_MAX;
 
     for (int16_t item_num = 0; item_num < Item_GetTotalCount(); item_num++) {
-        const ITEM_INFO *const item = Item_Get(item_num);
+        const ITEM *const item = Item_Get(item_num);
         if (Object_IsObjectType(item->object_id, g_PickupObjects)
             && (item->status == IS_INVISIBLE || item->status == IS_DEACTIVATED
                 || item->room_num == NO_ROOM)) {
@@ -168,18 +160,16 @@ static COMMAND_RESULT M_Entrypoint(const COMMAND_CONTEXT *const ctx)
         return CR_UNAVAILABLE;
     }
 
-    const ITEM_INFO *const lara_item = Lara_GetItem();
+    const ITEM *const lara_item = Lara_GetItem();
     if (!lara_item->hit_points) {
         return CR_UNAVAILABLE;
     }
 
-    // X Y Z
     float x, y, z;
     if (sscanf(ctx->args, "%f %f %f", &x, &y, &z) == 3) {
         return M_TeleportToXYZ(x, y, z);
     }
 
-    // Room number
     int16_t room_num = -1;
     if (sscanf(ctx->args, "%hd", &room_num) == 1) {
         return M_TeleportToRoom(room_num);
diff --git a/src/game/items.c b/src/game/items.c
index a4bd3ee..f92993b 100644
--- a/src/game/items.c
+++ b/src/game/items.c
@@ -4,7 +4,7 @@
 #include "utils.h"
 
 void Item_TakeDamage(
-    ITEM_INFO *const item, const int16_t damage, const bool hit_status)
+    ITEM *const item, const int16_t damage, const bool hit_status)
 {
 #if TR_VERSION == 1
     if (item->hit_points == DONT_TARGET) {
diff --git a/src/gfx/2d/2d_renderer.c b/src/gfx/2d/2d_renderer.c
index d9b06ef..6124e00 100644
--- a/src/gfx/2d/2d_renderer.c
+++ b/src/gfx/2d/2d_renderer.c
@@ -6,7 +6,7 @@
 
 #include <assert.h>
 
-void GFX_2D_Renderer_Init(GFX_2D_Renderer *renderer)
+void GFX_2D_Renderer_Init(GFX_2D_RENDERER *renderer)
 {
     LOG_INFO("");
     assert(renderer);
@@ -47,7 +47,7 @@ void GFX_2D_Renderer_Init(GFX_2D_Renderer *renderer)
     GFX_GL_CheckError();
 }
 
-void GFX_2D_Renderer_Close(GFX_2D_Renderer *renderer)
+void GFX_2D_Renderer_Close(GFX_2D_RENDERER *renderer)
 {
     LOG_INFO("");
     assert(renderer);
@@ -60,7 +60,7 @@ void GFX_2D_Renderer_Close(GFX_2D_Renderer *renderer)
 }
 
 void GFX_2D_Renderer_Upload(
-    GFX_2D_Renderer *renderer, GFX_2D_SurfaceDesc *desc, const uint8_t *data)
+    GFX_2D_RENDERER *renderer, GFX_2D_SURFACE_DESC *desc, const uint8_t *data)
 {
     const uint32_t width = desc->width;
     const uint32_t height = desc->height;
@@ -85,7 +85,7 @@ void GFX_2D_Renderer_Upload(
     }
 }
 
-void GFX_2D_Renderer_Render(GFX_2D_Renderer *renderer)
+void GFX_2D_Renderer_Render(GFX_2D_RENDERER *renderer)
 {
     GFX_GL_Program_Bind(&renderer->program);
     GFX_GL_Buffer_Bind(&renderer->surface_buffer);
diff --git a/src/gfx/2d/2d_surface.c b/src/gfx/2d/2d_surface.c
index dadad61..033bc1b 100644
--- a/src/gfx/2d/2d_surface.c
+++ b/src/gfx/2d/2d_surface.c
@@ -7,16 +7,16 @@
 #include <assert.h>
 #include <string.h>
 
-GFX_2D_Surface *GFX_2D_Surface_Create(const GFX_2D_SurfaceDesc *desc)
+GFX_2D_SURFACE *GFX_2D_Surface_Create(const GFX_2D_SURFACE_DESC *desc)
 {
-    GFX_2D_Surface *surface = Memory_Alloc(sizeof(GFX_2D_Surface));
+    GFX_2D_SURFACE *surface = Memory_Alloc(sizeof(GFX_2D_SURFACE));
     GFX_2D_Surface_Init(surface, desc);
     return surface;
 }
 
-GFX_2D_Surface *GFX_2D_Surface_CreateFromImage(const IMAGE *image)
+GFX_2D_SURFACE *GFX_2D_Surface_CreateFromImage(const IMAGE *image)
 {
-    GFX_2D_Surface *surface = Memory_Alloc(sizeof(GFX_2D_Surface));
+    GFX_2D_SURFACE *surface = Memory_Alloc(sizeof(GFX_2D_SURFACE));
     surface->is_locked = false;
     surface->is_dirty = true;
     surface->desc.width = image->width;
@@ -33,7 +33,7 @@ GFX_2D_Surface *GFX_2D_Surface_CreateFromImage(const IMAGE *image)
     return surface;
 }
 
-void GFX_2D_Surface_Free(GFX_2D_Surface *surface)
+void GFX_2D_Surface_Free(GFX_2D_SURFACE *surface)
 {
     if (surface) {
         GFX_2D_Surface_Close(surface);
@@ -42,13 +42,13 @@ void GFX_2D_Surface_Free(GFX_2D_Surface *surface)
 }
 
 void GFX_2D_Surface_Init(
-    GFX_2D_Surface *surface, const GFX_2D_SurfaceDesc *desc)
+    GFX_2D_SURFACE *surface, const GFX_2D_SURFACE_DESC *desc)
 {
     surface->is_locked = false;
     surface->is_dirty = false;
     surface->desc = *desc;
 
-    GFX_2D_SurfaceDesc display_desc = {
+    GFX_2D_SURFACE_DESC display_desc = {
         .bit_count = 32,
         .width = GFX_Context_GetDisplayWidth(),
         .height = GFX_Context_GetDisplayHeight(),
@@ -76,12 +76,12 @@ void GFX_2D_Surface_Init(
     surface->desc.pixels = NULL;
 }
 
-void GFX_2D_Surface_Close(GFX_2D_Surface *surface)
+void GFX_2D_Surface_Close(GFX_2D_SURFACE *surface)
 {
     Memory_FreePointer(&surface->buffer);
 }
 
-bool GFX_2D_Surface_Clear(GFX_2D_Surface *surface)
+bool GFX_2D_Surface_Clear(GFX_2D_SURFACE *surface)
 {
     if (surface->is_locked) {
         LOG_ERROR("Surface is locked");
@@ -93,7 +93,7 @@ bool GFX_2D_Surface_Clear(GFX_2D_Surface *surface)
     return true;
 }
 
-bool GFX_2D_Surface_Lock(GFX_2D_Surface *surface, GFX_2D_SurfaceDesc *out_desc)
+bool GFX_2D_Surface_Lock(GFX_2D_SURFACE *surface, GFX_2D_SURFACE_DESC *out_desc)
 {
     assert(surface != NULL);
     if (surface->is_locked) {
@@ -112,7 +112,7 @@ bool GFX_2D_Surface_Lock(GFX_2D_Surface *surface, GFX_2D_SurfaceDesc *out_desc)
     return true;
 }
 
-bool GFX_2D_Surface_Unlock(GFX_2D_Surface *surface)
+bool GFX_2D_Surface_Unlock(GFX_2D_SURFACE *surface)
 {
     // ensure that the surface is actually locked
     if (!surface->is_locked) {
diff --git a/src/gfx/3d/3d_renderer.c b/src/gfx/3d/3d_renderer.c
index 64904b5..901ddbb 100644
--- a/src/gfx/3d/3d_renderer.c
+++ b/src/gfx/3d/3d_renderer.c
@@ -7,13 +7,13 @@
 #include <assert.h>
 #include <stddef.h>
 
-static void M_SelectTextureImpl(GFX_3D_Renderer *renderer, int texture_num);
+static void M_SelectTextureImpl(GFX_3D_RENDERER *renderer, int texture_num);
 
-static void M_SelectTextureImpl(GFX_3D_Renderer *renderer, int texture_num)
+static void M_SelectTextureImpl(GFX_3D_RENDERER *renderer, int texture_num)
 {
     assert(renderer);
 
-    GFX_GL_Texture *texture = NULL;
+    GFX_GL_TEXTURE *texture = NULL;
     if (texture_num == GFX_ENV_MAP_TEXTURE) {
         texture = renderer->env_map_texture;
     } else if (texture_num != GFX_NO_TEXTURE) {
@@ -32,7 +32,7 @@ static void M_SelectTextureImpl(GFX_3D_Renderer *renderer, int texture_num)
 }
 
 void GFX_3D_Renderer_Init(
-    GFX_3D_Renderer *renderer, const GFX_CONFIG *const config)
+    GFX_3D_RENDERER *renderer, const GFX_CONFIG *const config)
 {
     LOG_INFO("");
     assert(renderer);
@@ -90,7 +90,7 @@ void GFX_3D_Renderer_Init(
     GFX_GL_CheckError();
 }
 
-void GFX_3D_Renderer_Close(GFX_3D_Renderer *renderer)
+void GFX_3D_Renderer_Close(GFX_3D_RENDERER *renderer)
 {
     LOG_INFO("");
     assert(renderer);
@@ -100,7 +100,7 @@ void GFX_3D_Renderer_Close(GFX_3D_Renderer *renderer)
     GFX_GL_Sampler_Close(&renderer->sampler);
 }
 
-void GFX_3D_Renderer_RenderBegin(GFX_3D_Renderer *renderer)
+void GFX_3D_Renderer_RenderBegin(GFX_3D_RENDERER *renderer)
 {
     assert(renderer);
     glEnable(GL_BLEND);
@@ -141,7 +141,7 @@ void GFX_3D_Renderer_RenderBegin(GFX_3D_Renderer *renderer)
     GFX_GL_CheckError();
 }
 
-void GFX_3D_Renderer_RenderEnd(GFX_3D_Renderer *renderer)
+void GFX_3D_Renderer_RenderEnd(GFX_3D_RENDERER *renderer)
 {
     assert(renderer);
     GFX_3D_VertexStream_RenderPending(&renderer->vertex_stream);
@@ -149,19 +149,19 @@ void GFX_3D_Renderer_RenderEnd(GFX_3D_Renderer *renderer)
     GFX_GL_CheckError();
 }
 
-void GFX_3D_Renderer_ClearDepth(GFX_3D_Renderer *renderer)
+void GFX_3D_Renderer_ClearDepth(GFX_3D_RENDERER *renderer)
 {
     GFX_3D_VertexStream_RenderPending(&renderer->vertex_stream);
     glClear(GL_DEPTH_BUFFER_BIT);
     GFX_GL_CheckError();
 }
 
-int GFX_3D_Renderer_RegisterEnvironmentMap(GFX_3D_Renderer *const renderer)
+int GFX_3D_Renderer_RegisterEnvironmentMap(GFX_3D_RENDERER *const renderer)
 {
     assert(renderer != NULL);
     assert(renderer->env_map_texture == NULL);
 
-    GFX_GL_Texture *texture = GFX_GL_Texture_Create(GL_TEXTURE_2D);
+    GFX_GL_TEXTURE *texture = GFX_GL_Texture_Create(GL_TEXTURE_2D);
     renderer->env_map_texture = texture;
 
     GFX_3D_Renderer_RestoreTexture(renderer);
@@ -170,11 +170,11 @@ int GFX_3D_Renderer_RegisterEnvironmentMap(GFX_3D_Renderer *const renderer)
 }
 
 bool GFX_3D_Renderer_UnregisterEnvironmentMap(
-    GFX_3D_Renderer *const renderer, const int texture_num)
+    GFX_3D_RENDERER *const renderer, const int texture_num)
 {
     assert(renderer != NULL);
 
-    GFX_GL_Texture *const texture = renderer->env_map_texture;
+    GFX_GL_TEXTURE *const texture = renderer->env_map_texture;
     if (texture == NULL) {
         LOG_ERROR("No environment map registered");
         return false;
@@ -196,11 +196,11 @@ bool GFX_3D_Renderer_UnregisterEnvironmentMap(
     return true;
 }
 
-void GFX_3D_Renderer_FillEnvironmentMap(GFX_3D_Renderer *const renderer)
+void GFX_3D_Renderer_FillEnvironmentMap(GFX_3D_RENDERER *const renderer)
 {
     assert(renderer != NULL);
 
-    GFX_GL_Texture *const env_map = renderer->env_map_texture;
+    GFX_GL_TEXTURE *const env_map = renderer->env_map_texture;
     if (env_map != NULL) {
         GFX_3D_VertexStream_RenderPending(&renderer->vertex_stream);
         GFX_GL_Texture_LoadFromBackBuffer(env_map);
@@ -209,11 +209,11 @@ void GFX_3D_Renderer_FillEnvironmentMap(GFX_3D_Renderer *const renderer)
 }
 
 int GFX_3D_Renderer_RegisterTexturePage(
-    GFX_3D_Renderer *renderer, const void *data, int width, int height)
+    GFX_3D_RENDERER *renderer, const void *data, int width, int height)
 {
     assert(renderer);
     assert(data);
-    GFX_GL_Texture *texture = GFX_GL_Texture_Create(GL_TEXTURE_2D);
+    GFX_GL_TEXTURE *texture = GFX_GL_Texture_Create(GL_TEXTURE_2D);
     GFX_GL_Texture_Load(texture, data, width, height, GL_RGBA, GL_RGBA);
 
     int texture_num = GFX_NO_TEXTURE;
@@ -232,13 +232,13 @@ int GFX_3D_Renderer_RegisterTexturePage(
 }
 
 bool GFX_3D_Renderer_UnregisterTexturePage(
-    GFX_3D_Renderer *renderer, int texture_num)
+    GFX_3D_RENDERER *renderer, int texture_num)
 {
     assert(renderer);
     assert(texture_num >= 0);
     assert(texture_num < GFX_MAX_TEXTURES);
 
-    GFX_GL_Texture *texture = renderer->textures[texture_num];
+    GFX_GL_TEXTURE *texture = renderer->textures[texture_num];
     if (!texture) {
         LOG_ERROR("Invalid texture handle");
         return false;
@@ -256,7 +256,7 @@ bool GFX_3D_Renderer_UnregisterTexturePage(
 }
 
 void GFX_3D_Renderer_RenderPrimStrip(
-    GFX_3D_Renderer *renderer, GFX_3D_Vertex *vertices, int count)
+    GFX_3D_RENDERER *renderer, GFX_3D_VERTEX *vertices, int count)
 {
     assert(renderer);
     assert(vertices);
@@ -265,7 +265,7 @@ void GFX_3D_Renderer_RenderPrimStrip(
 }
 
 void GFX_3D_Renderer_RenderPrimFan(
-    GFX_3D_Renderer *renderer, GFX_3D_Vertex *vertices, int count)
+    GFX_3D_RENDERER *renderer, GFX_3D_VERTEX *vertices, int count)
 {
     assert(renderer);
     assert(vertices);
@@ -273,14 +273,14 @@ void GFX_3D_Renderer_RenderPrimFan(
 }
 
 void GFX_3D_Renderer_RenderPrimList(
-    GFX_3D_Renderer *renderer, GFX_3D_Vertex *vertices, int count)
+    GFX_3D_RENDERER *renderer, GFX_3D_VERTEX *vertices, int count)
 {
     assert(renderer);
     assert(vertices);
     GFX_3D_VertexStream_PushPrimList(&renderer->vertex_stream, vertices, count);
 }
 
-void GFX_3D_Renderer_SelectTexture(GFX_3D_Renderer *renderer, int texture_num)
+void GFX_3D_Renderer_SelectTexture(GFX_3D_RENDERER *renderer, int texture_num)
 {
     assert(renderer);
     GFX_3D_VertexStream_RenderPending(&renderer->vertex_stream);
@@ -288,14 +288,14 @@ void GFX_3D_Renderer_SelectTexture(GFX_3D_Renderer *renderer, int texture_num)
     M_SelectTextureImpl(renderer, texture_num);
 }
 
-void GFX_3D_Renderer_RestoreTexture(GFX_3D_Renderer *renderer)
+void GFX_3D_Renderer_RestoreTexture(GFX_3D_RENDERER *renderer)
 {
     assert(renderer);
     M_SelectTextureImpl(renderer, renderer->selected_texture_num);
 }
 
 void GFX_3D_Renderer_SetPrimType(
-    GFX_3D_Renderer *renderer, GFX_3D_PrimType value)
+    GFX_3D_RENDERER *renderer, GFX_3D_PRIM_TYPE value)
 {
     assert(renderer);
     GFX_3D_VertexStream_RenderPending(&renderer->vertex_stream);
@@ -303,7 +303,7 @@ void GFX_3D_Renderer_SetPrimType(
 }
 
 void GFX_3D_Renderer_SetTextureFilter(
-    GFX_3D_Renderer *renderer, GFX_TEXTURE_FILTER filter)
+    GFX_3D_RENDERER *renderer, GFX_TEXTURE_FILTER filter)
 {
     assert(renderer);
     GFX_3D_VertexStream_RenderPending(&renderer->vertex_stream);
@@ -319,7 +319,7 @@ void GFX_3D_Renderer_SetTextureFilter(
 }
 
 void GFX_3D_Renderer_SetDepthTestEnabled(
-    GFX_3D_Renderer *renderer, bool is_enabled)
+    GFX_3D_RENDERER *renderer, bool is_enabled)
 {
     assert(renderer);
     GFX_3D_VertexStream_RenderPending(&renderer->vertex_stream);
@@ -331,26 +331,26 @@ void GFX_3D_Renderer_SetDepthTestEnabled(
 }
 
 void GFX_3D_Renderer_SetBlendingMode(
-    GFX_3D_Renderer *const renderer, const GFX_BlendMode blend_mode)
+    GFX_3D_RENDERER *const renderer, const GFX_BLEND_MODE blend_mode)
 {
     assert(renderer != NULL);
     GFX_3D_VertexStream_RenderPending(&renderer->vertex_stream);
 
     switch (blend_mode) {
-    case GFX_BlendMode_Off:
+    case GFX_BLEND_MODE_OFF:
         glBlendFunc(GL_ONE, GL_ZERO);
         break;
-    case GFX_BlendMode_Normal:
+    case GFX_BLEND_MODE_NORMAL:
         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         break;
-    case GFX_BlendMode_Multiply:
+    case GFX_BLEND_MODE_MULTIPLY:
         glBlendFunc(GL_DST_COLOR, GL_SRC_COLOR);
         break;
     }
 }
 
 void GFX_3D_Renderer_SetTexturingEnabled(
-    GFX_3D_Renderer *renderer, bool is_enabled)
+    GFX_3D_RENDERER *renderer, bool is_enabled)
 {
     assert(renderer);
     GFX_3D_VertexStream_RenderPending(&renderer->vertex_stream);
diff --git a/src/gfx/3d/vertex_stream.c b/src/gfx/3d/vertex_stream.c
index 1fbef64..91edbe5 100644
--- a/src/gfx/3d/vertex_stream.c
+++ b/src/gfx/3d/vertex_stream.c
@@ -11,24 +11,24 @@ static const GLenum GL_PRIM_MODES[] = {
 };
 
 static void M_PushVertex(
-    GFX_3D_VertexStream *vertex_stream, GFX_3D_Vertex *vertex);
+    GFX_3D_VERTEX_STREAM *vertex_stream, GFX_3D_VERTEX *vertex);
 
 static void M_PushVertex(
-    GFX_3D_VertexStream *vertex_stream, GFX_3D_Vertex *vertex)
+    GFX_3D_VERTEX_STREAM *vertex_stream, GFX_3D_VERTEX *vertex)
 {
     if (vertex_stream->pending_vertices.count + 1
         >= vertex_stream->pending_vertices.capacity) {
         vertex_stream->pending_vertices.capacity += 1000;
         vertex_stream->pending_vertices.data = Memory_Realloc(
             vertex_stream->pending_vertices.data,
-            vertex_stream->pending_vertices.capacity * sizeof(GFX_3D_Vertex));
+            vertex_stream->pending_vertices.capacity * sizeof(GFX_3D_VERTEX));
     }
 
     vertex_stream->pending_vertices
         .data[vertex_stream->pending_vertices.count++] = *vertex;
 }
 
-void GFX_3D_VertexStream_Init(GFX_3D_VertexStream *vertex_stream)
+void GFX_3D_VertexStream_Init(GFX_3D_VERTEX_STREAM *vertex_stream)
 {
     vertex_stream->prim_type = GFX_3D_PRIM_TRI;
     vertex_stream->buffer_size = 0;
@@ -51,7 +51,7 @@ void GFX_3D_VertexStream_Init(GFX_3D_VertexStream *vertex_stream)
     GFX_GL_CheckError();
 }
 
-void GFX_3D_VertexStream_Close(GFX_3D_VertexStream *vertex_stream)
+void GFX_3D_VertexStream_Close(GFX_3D_VERTEX_STREAM *vertex_stream)
 {
     GFX_GL_VertexArray_Close(&vertex_stream->vtc_format);
     GFX_GL_Buffer_Close(&vertex_stream->buffer);
@@ -59,19 +59,19 @@ void GFX_3D_VertexStream_Close(GFX_3D_VertexStream *vertex_stream)
     Memory_FreePointer(&vertex_stream->pending_vertices.data);
 }
 
-void GFX_3D_VertexStream_Bind(GFX_3D_VertexStream *vertex_stream)
+void GFX_3D_VertexStream_Bind(GFX_3D_VERTEX_STREAM *vertex_stream)
 {
     GFX_GL_Buffer_Bind(&vertex_stream->buffer);
 }
 
 void GFX_3D_VertexStream_SetPrimType(
-    GFX_3D_VertexStream *vertex_stream, GFX_3D_PrimType prim_type)
+    GFX_3D_VERTEX_STREAM *vertex_stream, GFX_3D_PRIM_TYPE prim_type)
 {
     vertex_stream->prim_type = prim_type;
 }
 
 bool GFX_3D_VertexStream_PushPrimStrip(
-    GFX_3D_VertexStream *vertex_stream, GFX_3D_Vertex *vertices, int count)
+    GFX_3D_VERTEX_STREAM *vertex_stream, GFX_3D_VERTEX *vertices, int count)
 {
     if (vertex_stream->prim_type != GFX_3D_PRIM_TRI) {
         LOG_ERROR("Unsupported prim type: %d", vertex_stream->prim_type);
@@ -95,7 +95,7 @@ bool GFX_3D_VertexStream_PushPrimStrip(
 }
 
 bool GFX_3D_VertexStream_PushPrimFan(
-    GFX_3D_VertexStream *vertex_stream, GFX_3D_Vertex *vertices, int count)
+    GFX_3D_VERTEX_STREAM *vertex_stream, GFX_3D_VERTEX *vertices, int count)
 {
     if (vertex_stream->prim_type != GFX_3D_PRIM_TRI) {
         LOG_ERROR("Unsupported prim type: %d", vertex_stream->prim_type);
@@ -119,7 +119,7 @@ bool GFX_3D_VertexStream_PushPrimFan(
 }
 
 bool GFX_3D_VertexStream_PushPrimList(
-    GFX_3D_VertexStream *vertex_stream, GFX_3D_Vertex *vertices, int count)
+    GFX_3D_VERTEX_STREAM *vertex_stream, GFX_3D_VERTEX *vertices, int count)
 {
     for (int i = 0; i < count; i++) {
         M_PushVertex(vertex_stream, &vertices[i]);
@@ -127,7 +127,7 @@ bool GFX_3D_VertexStream_PushPrimList(
     return true;
 }
 
-void GFX_3D_VertexStream_RenderPending(GFX_3D_VertexStream *vertex_stream)
+void GFX_3D_VertexStream_RenderPending(GFX_3D_VERTEX_STREAM *vertex_stream)
 {
     if (!vertex_stream->pending_vertices.count) {
         return;
@@ -137,7 +137,7 @@ void GFX_3D_VertexStream_RenderPending(GFX_3D_VertexStream *vertex_stream)
 
     // resize GPU buffer if required
     size_t buffer_size =
-        sizeof(GFX_3D_Vertex) * vertex_stream->pending_vertices.count;
+        sizeof(GFX_3D_VERTEX) * vertex_stream->pending_vertices.count;
     if (buffer_size > vertex_stream->buffer_size) {
         LOG_INFO(
             "Vertex buffer resize: %d -> %d", vertex_stream->buffer_size,
diff --git a/src/gfx/context.c b/src/gfx/context.c
index 8a005ed..1176ac1 100644
--- a/src/gfx/context.c
+++ b/src/gfx/context.c
@@ -12,7 +12,7 @@
 #include <SDL2/SDL_video.h>
 #include <string.h>
 
-typedef struct GFX_CONTEXT {
+typedef struct {
     SDL_GLContext context;
     SDL_Window *window_handle;
 
@@ -24,9 +24,9 @@ typedef struct GFX_CONTEXT {
     int32_t window_height;
 
     char *scheduled_screenshot_path;
-    GFX_Renderer *renderer;
-    GFX_2D_Renderer renderer_2d;
-    GFX_3D_Renderer renderer_3d;
+    GFX_RENDERER *renderer;
+    GFX_2D_RENDERER renderer_2d;
+    GFX_3D_RENDERER renderer_3d;
 } GFX_CONTEXT;
 
 static GFX_CONTEXT m_Context = { 0 };
@@ -318,12 +318,12 @@ void GFX_Context_ClearScheduledScreenshotPath(void)
     Memory_FreePointer(&m_Context.scheduled_screenshot_path);
 }
 
-GFX_2D_Renderer *GFX_Context_GetRenderer2D(void)
+GFX_2D_RENDERER *GFX_Context_GetRenderer2D(void)
 {
     return &m_Context.renderer_2d;
 }
 
-GFX_3D_Renderer *GFX_Context_GetRenderer3D(void)
+GFX_3D_RENDERER *GFX_Context_GetRenderer3D(void)
 {
     return &m_Context.renderer_3d;
 }
diff --git a/src/gfx/gl/buffer.c b/src/gfx/gl/buffer.c
index c1a1fb8..aed161a 100644
--- a/src/gfx/gl/buffer.c
+++ b/src/gfx/gl/buffer.c
@@ -4,7 +4,7 @@
 
 #include <assert.h>
 
-void GFX_GL_Buffer_Init(GFX_GL_Buffer *buf, GLenum target)
+void GFX_GL_Buffer_Init(GFX_GL_BUFFER *buf, GLenum target)
 {
     assert(buf);
     buf->target = target;
@@ -12,14 +12,14 @@ void GFX_GL_Buffer_Init(GFX_GL_Buffer *buf, GLenum target)
     GFX_GL_CheckError();
 }
 
-void GFX_GL_Buffer_Close(GFX_GL_Buffer *buf)
+void GFX_GL_Buffer_Close(GFX_GL_BUFFER *buf)
 {
     assert(buf);
     glDeleteBuffers(1, &buf->id);
     GFX_GL_CheckError();
 }
 
-void GFX_GL_Buffer_Bind(GFX_GL_Buffer *buf)
+void GFX_GL_Buffer_Bind(GFX_GL_BUFFER *buf)
 {
     assert(buf);
     glBindBuffer(buf->target, buf->id);
@@ -27,7 +27,7 @@ void GFX_GL_Buffer_Bind(GFX_GL_Buffer *buf)
 }
 
 void GFX_GL_Buffer_Data(
-    GFX_GL_Buffer *buf, GLsizei size, const void *data, GLenum usage)
+    GFX_GL_BUFFER *buf, GLsizei size, const void *data, GLenum usage)
 {
     assert(buf);
     glBufferData(buf->target, size, data, usage);
@@ -35,14 +35,14 @@ void GFX_GL_Buffer_Data(
 }
 
 void GFX_GL_Buffer_SubData(
-    GFX_GL_Buffer *buf, GLsizei offset, GLsizei size, const void *data)
+    GFX_GL_BUFFER *buf, GLsizei offset, GLsizei size, const void *data)
 {
     assert(buf);
     glBufferSubData(buf->target, offset, size, data);
     GFX_GL_CheckError();
 }
 
-void *GFX_GL_Buffer_Map(GFX_GL_Buffer *buf, GLenum access)
+void *GFX_GL_Buffer_Map(GFX_GL_BUFFER *buf, GLenum access)
 {
     assert(buf);
     void *ret = glMapBuffer(buf->target, access);
@@ -50,14 +50,14 @@ void *GFX_GL_Buffer_Map(GFX_GL_Buffer *buf, GLenum access)
     return ret;
 }
 
-void GFX_GL_Buffer_Unmap(GFX_GL_Buffer *buf)
+void GFX_GL_Buffer_Unmap(GFX_GL_BUFFER *buf)
 {
     assert(buf);
     glUnmapBuffer(buf->target);
     GFX_GL_CheckError();
 }
 
-GLint GFX_GL_Buffer_Parameter(GFX_GL_Buffer *buf, GLenum pname)
+GLint GFX_GL_Buffer_Parameter(GFX_GL_BUFFER *buf, GLenum pname)
 {
     assert(buf);
     GLint params = 0;
diff --git a/src/gfx/gl/program.c b/src/gfx/gl/program.c
index bd32623..a3e65ab 100644
--- a/src/gfx/gl/program.c
+++ b/src/gfx/gl/program.c
@@ -10,7 +10,7 @@
 #include <stddef.h>
 #include <string.h>
 
-bool GFX_GL_Program_Init(GFX_GL_Program *program)
+bool GFX_GL_Program_Init(GFX_GL_PROGRAM *program)
 {
     assert(program);
     program->id = glCreateProgram();
@@ -22,7 +22,7 @@ bool GFX_GL_Program_Init(GFX_GL_Program *program)
     return true;
 }
 
-void GFX_GL_Program_Close(GFX_GL_Program *program)
+void GFX_GL_Program_Close(GFX_GL_PROGRAM *program)
 {
     if (program->id) {
         glDeleteProgram(program->id);
@@ -31,7 +31,7 @@ void GFX_GL_Program_Close(GFX_GL_Program *program)
     }
 }
 
-void GFX_GL_Program_Bind(GFX_GL_Program *program)
+void GFX_GL_Program_Bind(GFX_GL_PROGRAM *program)
 {
     glUseProgram(program->id);
     GFX_GL_CheckError();
@@ -83,7 +83,7 @@ char *GFX_GL_Program_PreprocessShader(
 }
 
 void GFX_GL_Program_AttachShader(
-    GFX_GL_Program *program, GLenum type, const char *path)
+    GFX_GL_PROGRAM *program, GLenum type, const char *path)
 {
     GLuint shader_id = glCreateShader(type);
     GFX_GL_CheckError();
@@ -135,7 +135,7 @@ void GFX_GL_Program_AttachShader(
     GFX_GL_CheckError();
 }
 
-void GFX_GL_Program_Link(GFX_GL_Program *program)
+void GFX_GL_Program_Link(GFX_GL_PROGRAM *program)
 {
     glLinkProgram(program->id);
     GFX_GL_CheckError();
@@ -158,13 +158,13 @@ void GFX_GL_Program_Link(GFX_GL_Program *program)
     }
 }
 
-void GFX_GL_Program_FragmentData(GFX_GL_Program *program, const char *name)
+void GFX_GL_Program_FragmentData(GFX_GL_PROGRAM *program, const char *name)
 {
     glBindFragDataLocation(program->id, 0, name);
     GFX_GL_CheckError();
 }
 
-GLint GFX_GL_Program_UniformLocation(GFX_GL_Program *program, const char *name)
+GLint GFX_GL_Program_UniformLocation(GFX_GL_PROGRAM *program, const char *name)
 {
     GLint location = glGetUniformLocation(program->id, name);
     GFX_GL_CheckError();
@@ -175,28 +175,28 @@ GLint GFX_GL_Program_UniformLocation(GFX_GL_Program *program, const char *name)
 }
 
 void GFX_GL_Program_Uniform3f(
-    GFX_GL_Program *program, GLint loc, GLfloat v0, GLfloat v1, GLfloat v2)
+    GFX_GL_PROGRAM *program, GLint loc, GLfloat v0, GLfloat v1, GLfloat v2)
 {
     glUniform3f(loc, v0, v1, v2);
     GFX_GL_CheckError();
 }
 
 void GFX_GL_Program_Uniform4f(
-    GFX_GL_Program *program, GLint loc, GLfloat v0, GLfloat v1, GLfloat v2,
+    GFX_GL_PROGRAM *program, GLint loc, GLfloat v0, GLfloat v1, GLfloat v2,
     GLfloat v3)
 {
     glUniform4f(loc, v0, v1, v2, v3);
     GFX_GL_CheckError();
 }
 
-void GFX_GL_Program_Uniform1i(GFX_GL_Program *program, GLint loc, GLint v0)
+void GFX_GL_Program_Uniform1i(GFX_GL_PROGRAM *program, GLint loc, GLint v0)
 {
     glUniform1i(loc, v0);
     GFX_GL_CheckError();
 }
 
 void GFX_GL_Program_UniformMatrix4fv(
-    GFX_GL_Program *program, GLint loc, GLsizei count, GLboolean transpose,
+    GFX_GL_PROGRAM *program, GLint loc, GLsizei count, GLboolean transpose,
     const GLfloat *value)
 {
     glUniformMatrix4fv(loc, count, transpose, value);
diff --git a/src/gfx/gl/sampler.c b/src/gfx/gl/sampler.c
index fc940e9..cb76df8 100644
--- a/src/gfx/gl/sampler.c
+++ b/src/gfx/gl/sampler.c
@@ -2,33 +2,33 @@
 
 #include "gfx/gl/utils.h"
 
-void GFX_GL_Sampler_Init(GFX_GL_Sampler *sampler)
+void GFX_GL_Sampler_Init(GFX_GL_SAMPLER *sampler)
 {
     glGenSamplers(1, &sampler->id);
     GFX_GL_CheckError();
 }
 
-void GFX_GL_Sampler_Close(GFX_GL_Sampler *sampler)
+void GFX_GL_Sampler_Close(GFX_GL_SAMPLER *sampler)
 {
     glDeleteSamplers(1, &sampler->id);
     GFX_GL_CheckError();
 }
 
-void GFX_GL_Sampler_Bind(GFX_GL_Sampler *sampler, GLuint unit)
+void GFX_GL_Sampler_Bind(GFX_GL_SAMPLER *sampler, GLuint unit)
 {
     glBindSampler(unit, sampler->id);
     GFX_GL_CheckError();
 }
 
 void GFX_GL_Sampler_Parameteri(
-    GFX_GL_Sampler *sampler, GLenum pname, GLint param)
+    GFX_GL_SAMPLER *sampler, GLenum pname, GLint param)
 {
     glSamplerParameteri(sampler->id, pname, param);
     GFX_GL_CheckError();
 }
 
 void GFX_GL_Sampler_Parameterf(
-    GFX_GL_Sampler *sampler, GLenum pname, GLfloat param)
+    GFX_GL_SAMPLER *sampler, GLenum pname, GLfloat param)
 {
     glSamplerParameterf(sampler->id, pname, param);
     GFX_GL_CheckError();
diff --git a/src/gfx/gl/texture.c b/src/gfx/gl/texture.c
index 04427c6..f5f067d 100644
--- a/src/gfx/gl/texture.c
+++ b/src/gfx/gl/texture.c
@@ -6,14 +6,14 @@
 
 #include <assert.h>
 
-GFX_GL_Texture *GFX_GL_Texture_Create(GLenum target)
+GFX_GL_TEXTURE *GFX_GL_Texture_Create(GLenum target)
 {
-    GFX_GL_Texture *texture = Memory_Alloc(sizeof(GFX_GL_Texture));
+    GFX_GL_TEXTURE *texture = Memory_Alloc(sizeof(GFX_GL_TEXTURE));
     GFX_GL_Texture_Init(texture, target);
     return texture;
 }
 
-void GFX_GL_Texture_Free(GFX_GL_Texture *texture)
+void GFX_GL_Texture_Free(GFX_GL_TEXTURE *texture)
 {
     if (texture != NULL) {
         GFX_GL_Texture_Close(texture);
@@ -21,7 +21,7 @@ void GFX_GL_Texture_Free(GFX_GL_Texture *texture)
     }
 }
 
-void GFX_GL_Texture_Init(GFX_GL_Texture *texture, GLenum target)
+void GFX_GL_Texture_Init(GFX_GL_TEXTURE *texture, GLenum target)
 {
     assert(texture != NULL);
     texture->target = target;
@@ -29,14 +29,14 @@ void GFX_GL_Texture_Init(GFX_GL_Texture *texture, GLenum target)
     GFX_GL_CheckError();
 }
 
-void GFX_GL_Texture_Close(GFX_GL_Texture *texture)
+void GFX_GL_Texture_Close(GFX_GL_TEXTURE *texture)
 {
     assert(texture != NULL);
     glDeleteTextures(1, &texture->id);
     GFX_GL_CheckError();
 }
 
-void GFX_GL_Texture_Bind(GFX_GL_Texture *texture)
+void GFX_GL_Texture_Bind(GFX_GL_TEXTURE *texture)
 {
     assert(texture != NULL);
     glBindTexture(texture->target, texture->id);
@@ -44,7 +44,7 @@ void GFX_GL_Texture_Bind(GFX_GL_Texture *texture)
 }
 
 void GFX_GL_Texture_Load(
-    GFX_GL_Texture *texture, const void *data, int width, int height,
+    GFX_GL_TEXTURE *texture, const void *data, int width, int height,
     GLint internal_format, GLint format)
 {
     assert(texture != NULL);
@@ -62,7 +62,7 @@ void GFX_GL_Texture_Load(
     GFX_GL_CheckError();
 }
 
-void GFX_GL_Texture_LoadFromBackBuffer(GFX_GL_Texture *const texture)
+void GFX_GL_Texture_LoadFromBackBuffer(GFX_GL_TEXTURE *const texture)
 {
     assert(texture != NULL);
 
diff --git a/src/gfx/gl/vertex_array.c b/src/gfx/gl/vertex_array.c
index 288fa9f..6f89039 100644
--- a/src/gfx/gl/vertex_array.c
+++ b/src/gfx/gl/vertex_array.c
@@ -5,21 +5,21 @@
 #include <assert.h>
 #include <stdint.h>
 
-void GFX_GL_VertexArray_Init(GFX_GL_VertexArray *array)
+void GFX_GL_VertexArray_Init(GFX_GL_VERTEX_ARRAY *array)
 {
     assert(array);
     glGenVertexArrays(1, &array->id);
     GFX_GL_CheckError();
 }
 
-void GFX_GL_VertexArray_Close(GFX_GL_VertexArray *array)
+void GFX_GL_VertexArray_Close(GFX_GL_VERTEX_ARRAY *array)
 {
     assert(array);
     glDeleteVertexArrays(1, &array->id);
     GFX_GL_CheckError();
 }
 
-void GFX_GL_VertexArray_Bind(GFX_GL_VertexArray *array)
+void GFX_GL_VertexArray_Bind(GFX_GL_VERTEX_ARRAY *array)
 {
     assert(array);
     glBindVertexArray(array->id);
@@ -27,7 +27,7 @@ void GFX_GL_VertexArray_Bind(GFX_GL_VertexArray *array)
 }
 
 void GFX_GL_VertexArray_Attribute(
-    GFX_GL_VertexArray *array, GLuint index, GLint size, GLenum type,
+    GFX_GL_VERTEX_ARRAY *array, GLuint index, GLint size, GLenum type,
     GLboolean normalized, GLsizei stride, GLsizei offset)
 {
     assert(array);
diff --git a/src/gfx/renderers/fbo_renderer.c b/src/gfx/renderers/fbo_renderer.c
index da9460d..b9736df 100644
--- a/src/gfx/renderers/fbo_renderer.c
+++ b/src/gfx/renderers/fbo_renderer.c
@@ -25,23 +25,23 @@ typedef struct {
     GLuint fbo;
     GLuint rbo;
 
-    GFX_GL_VertexArray vertex_array;
-    GFX_GL_Buffer buffer;
-    GFX_GL_Texture texture;
-    GFX_GL_Sampler sampler;
-    GFX_GL_Program program;
-} GFX_Renderer_FBO_Context;
-
-static void M_SwapBuffers(GFX_Renderer *renderer);
-static void M_Init(GFX_Renderer *renderer, const GFX_CONFIG *config);
-static void M_Shutdown(GFX_Renderer *renderer);
-static void M_Reset(GFX_Renderer *renderer);
-
-static void M_Render(GFX_Renderer *renderer);
-static void M_Bind(const GFX_Renderer *renderer);
-static void M_Unbind(const GFX_Renderer *renderer);
-
-static void M_SwapBuffers(GFX_Renderer *renderer)
+    GFX_GL_VERTEX_ARRAY vertex_array;
+    GFX_GL_BUFFER buffer;
+    GFX_GL_TEXTURE texture;
+    GFX_GL_SAMPLER sampler;
+    GFX_GL_PROGRAM program;
+} M_CONTEXT;
+
+static void M_SwapBuffers(GFX_RENDERER *renderer);
+static void M_Init(GFX_RENDERER *renderer, const GFX_CONFIG *config);
+static void M_Shutdown(GFX_RENDERER *renderer);
+static void M_Reset(GFX_RENDERER *renderer);
+
+static void M_Render(GFX_RENDERER *renderer);
+static void M_Bind(const GFX_RENDERER *renderer);
+static void M_Unbind(const GFX_RENDERER *renderer);
+
+static void M_SwapBuffers(GFX_RENDERER *renderer)
 {
     if (GFX_Context_GetScheduledScreenshotPath()) {
         GFX_Screenshot_CaptureToFile(GFX_Context_GetScheduledScreenshotPath());
@@ -62,14 +62,13 @@ static void M_SwapBuffers(GFX_Renderer *renderer)
     GFX_Context_SwitchToDisplayViewport();
 }
 
-static void M_Init(GFX_Renderer *const renderer, const GFX_CONFIG *const config)
+static void M_Init(GFX_RENDERER *const renderer, const GFX_CONFIG *const config)
 {
     LOG_INFO("");
 
     assert(renderer != NULL);
-    renderer->priv = (GFX_Renderer_FBO_Context *)Memory_Alloc(
-        sizeof(GFX_Renderer_FBO_Context));
-    GFX_Renderer_FBO_Context *priv = renderer->priv;
+    renderer->priv = (M_CONTEXT *)Memory_Alloc(sizeof(M_CONTEXT));
+    M_CONTEXT *priv = renderer->priv;
     assert(priv != NULL);
 
     priv->config = config;
@@ -144,12 +143,12 @@ static void M_Init(GFX_Renderer *const renderer, const GFX_CONFIG *const config)
     }
 }
 
-static void M_Shutdown(GFX_Renderer *renderer)
+static void M_Shutdown(GFX_RENDERER *renderer)
 {
     LOG_INFO("");
 
     assert(renderer != NULL);
-    GFX_Renderer_FBO_Context *priv = renderer->priv;
+    M_CONTEXT *priv = renderer->priv;
     assert(priv != NULL);
 
     if (!priv->fbo) {
@@ -167,19 +166,19 @@ static void M_Shutdown(GFX_Renderer *renderer)
     Memory_FreePointer(&renderer->priv);
 }
 
-static void M_Reset(GFX_Renderer *renderer)
+static void M_Reset(GFX_RENDERER *renderer)
 {
-    GFX_Renderer_FBO_Context *const priv = renderer->priv;
+    M_CONTEXT *const priv = renderer->priv;
     const GFX_CONFIG *const config = priv->config;
 
     renderer->shutdown(renderer);
     renderer->init(renderer, config);
 }
 
-static void M_Render(GFX_Renderer *renderer)
+static void M_Render(GFX_RENDERER *renderer)
 {
     assert(renderer != NULL);
-    GFX_Renderer_FBO_Context *priv = renderer->priv;
+    M_CONTEXT *priv = renderer->priv;
     assert(priv != NULL);
 
     const GLuint filter = priv->config->display_filter == GFX_TF_BILINEAR
@@ -225,20 +224,20 @@ static void M_Render(GFX_Renderer *renderer)
     GFX_GL_CheckError();
 }
 
-static void M_Bind(const GFX_Renderer *renderer)
+static void M_Bind(const GFX_RENDERER *renderer)
 {
     assert(renderer != NULL);
-    GFX_Renderer_FBO_Context *priv = renderer->priv;
+    M_CONTEXT *priv = renderer->priv;
     assert(priv != NULL);
     glBindFramebuffer(GL_FRAMEBUFFER, priv->fbo);
 }
 
-static void M_Unbind(const GFX_Renderer *renderer)
+static void M_Unbind(const GFX_RENDERER *renderer)
 {
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
-GFX_Renderer g_GFX_Renderer_FBO = {
+GFX_RENDERER g_GFX_Renderer_FBO = {
     .swap_buffers = &M_SwapBuffers,
     .init = &M_Init,
     .shutdown = &M_Shutdown,
diff --git a/src/gfx/renderers/legacy_renderer.c b/src/gfx/renderers/legacy_renderer.c
index 3df02bd..450d84c 100644
--- a/src/gfx/renderers/legacy_renderer.c
+++ b/src/gfx/renderers/legacy_renderer.c
@@ -7,9 +7,9 @@
 #include <SDL2/SDL_video.h>
 #include <assert.h>
 
-static void M_SwapBuffers(GFX_Renderer *renderer);
+static void M_SwapBuffers(GFX_RENDERER *renderer);
 
-static void M_SwapBuffers(GFX_Renderer *renderer)
+static void M_SwapBuffers(GFX_RENDERER *renderer)
 {
     assert(renderer != NULL);
 
@@ -26,7 +26,7 @@ static void M_SwapBuffers(GFX_Renderer *renderer)
     GFX_GL_CheckError();
 }
 
-GFX_Renderer g_GFX_Renderer_Legacy = {
+GFX_RENDERER g_GFX_Renderer_Legacy = {
     .priv = NULL,
     .swap_buffers = &M_SwapBuffers,
     .init = NULL,
diff --git a/src/json/bson_parse.c b/src/json/bson_parse.c
index 06e515f..66fa749 100644
--- a/src/json/bson_parse.c
+++ b/src/json/bson_parse.c
@@ -9,7 +9,7 @@
 #include <stdio.h>
 #include <string.h>
 
-struct bson_parse_state_s {
+typedef struct {
     const char *src;
     size_t size;
     size_t offset;
@@ -20,52 +20,40 @@ struct bson_parse_state_s {
     size_t data_size;
 
     size_t error;
-};
-
-static bool M_GetObjectKeySize(struct bson_parse_state_s *state);
-static bool M_GetNullValueSize(struct bson_parse_state_s *state);
-static bool M_GetBoolValueSize(struct bson_parse_state_s *state);
-static bool M_GetInt32ValueSize(struct bson_parse_state_s *state);
-static bool M_GetDoubleValueSize(struct bson_parse_state_s *state);
-static bool M_GetStringValueSize(struct bson_parse_state_s *state);
-static bool M_GetArrayElementWrappedSize(struct bson_parse_state_s *state);
-static bool M_GetArraySize(struct bson_parse_state_s *state);
-static bool M_GetArrayValueSize(struct bson_parse_state_s *state);
-static bool M_GetObjectElementWrappedSize(struct bson_parse_state_s *state);
-static bool M_GetObjectSize(struct bson_parse_state_s *state);
-static bool M_GetObjectValueSize(struct bson_parse_state_s *state);
-static bool M_GetValueSize(struct bson_parse_state_s *state, uint8_t marker);
-static bool M_GetRootSize(struct bson_parse_state_s *state);
-
-static void M_HandleObjectKey(
-    struct bson_parse_state_s *state, struct json_string_s *string);
-static void M_HandleNullValue(
-    struct bson_parse_state_s *state, struct json_value_s *value);
-static void M_HandleBoolValue(
-    struct bson_parse_state_s *state, struct json_value_s *value);
-static void M_HandleInt32Value(
-    struct bson_parse_state_s *state, struct json_value_s *value);
-static void M_HandleDoubleValue(
-    struct bson_parse_state_s *state, struct json_value_s *value);
-static void M_HandleStringValue(
-    struct bson_parse_state_s *state, struct json_value_s *value);
+} M_STATE;
+
+static bool M_GetObjectKeySize(M_STATE *state);
+static bool M_GetNullValueSize(M_STATE *state);
+static bool M_GetBoolValueSize(M_STATE *state);
+static bool M_GetInt32ValueSize(M_STATE *state);
+static bool M_GetDoubleValueSize(M_STATE *state);
+static bool M_GetStringValueSize(M_STATE *state);
+static bool M_GetArrayElementWrappedSize(M_STATE *state);
+static bool M_GetArraySize(M_STATE *state);
+static bool M_GetArrayValueSize(M_STATE *state);
+static bool M_GetObjectElementWrappedSize(M_STATE *state);
+static bool M_GetObjectSize(M_STATE *state);
+static bool M_GetObjectValueSize(M_STATE *state);
+static bool M_GetValueSize(M_STATE *state, uint8_t marker);
+static bool M_GetRootSize(M_STATE *state);
+
+static void M_HandleObjectKey(M_STATE *state, JSON_STRING *string);
+static void M_HandleNullValue(M_STATE *state, JSON_VALUE *value);
+static void M_HandleBoolValue(M_STATE *state, JSON_VALUE *value);
+static void M_HandleInt32Value(M_STATE *state, JSON_VALUE *value);
+static void M_HandleDoubleValue(M_STATE *state, JSON_VALUE *value);
+static void M_HandleStringValue(M_STATE *state, JSON_VALUE *value);
 static void M_HandleArrayElementWrapped(
-    struct bson_parse_state_s *state, struct json_array_element_s *element);
-static void M_HandleArray(
-    struct bson_parse_state_s *state, struct json_array_s *array);
-static void M_HandleArrayValue(
-    struct bson_parse_state_s *state, struct json_value_s *value);
+    M_STATE *state, JSON_ARRAY_ELEMENT *element);
+static void M_HandleArray(M_STATE *state, JSON_ARRAY *array);
+static void M_HandleArrayValue(M_STATE *state, JSON_VALUE *value);
 static void M_HandleObjectElementWrapped(
-    struct bson_parse_state_s *state, struct json_object_element_s *element);
-static void M_HandleObject(
-    struct bson_parse_state_s *state, struct json_object_s *object);
-static void M_HandleObjectValue(
-    struct bson_parse_state_s *state, struct json_value_s *value);
-static void M_HandleValue(
-    struct bson_parse_state_s *state, struct json_value_s *value,
-    uint8_t marker);
-
-static bool M_GetObjectKeySize(struct bson_parse_state_s *state)
+    M_STATE *state, JSON_OBJECT_ELEMENT *element);
+static void M_HandleObject(M_STATE *state, JSON_OBJECT *object);
+static void M_HandleObjectValue(M_STATE *state, JSON_VALUE *value);
+static void M_HandleValue(M_STATE *state, JSON_VALUE *value, uint8_t marker);
+
+static bool M_GetObjectKeySize(M_STATE *state)
 {
     assert(state);
     while (state->src[state->offset]) {
@@ -77,17 +65,17 @@ static bool M_GetObjectKeySize(struct bson_parse_state_s *state)
     return true;
 }
 
-static bool M_GetNullValueSize(struct bson_parse_state_s *state)
+static bool M_GetNullValueSize(M_STATE *state)
 {
     assert(state);
     return true;
 }
 
-static bool M_GetBoolValueSize(struct bson_parse_state_s *state)
+static bool M_GetBoolValueSize(M_STATE *state)
 {
     assert(state);
     if (state->offset + sizeof(uint8_t) > state->size) {
-        state->error = bson_parse_error_premature_end_of_buffer;
+        state->error = BSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         return false;
     }
 
@@ -97,7 +85,7 @@ static bool M_GetBoolValueSize(struct bson_parse_state_s *state)
     case 0x01:
         break;
     default:
-        state->error = bson_parse_error_invalid_value;
+        state->error = BSON_PARSE_ERROR_INVALID_VALUE;
         return false;
     }
 
@@ -105,180 +93,180 @@ static bool M_GetBoolValueSize(struct bson_parse_state_s *state)
     return true;
 }
 
-static bool M_GetInt32ValueSize(struct bson_parse_state_s *state)
+static bool M_GetInt32ValueSize(M_STATE *state)
 {
     assert(state);
 
     if (state->offset + sizeof(int32_t) > state->size) {
-        state->error = bson_parse_error_premature_end_of_buffer;
+        state->error = BSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         return false;
     }
     int32_t num = *(int32_t *)&state->src[state->offset];
     state->offset += sizeof(int32_t);
 
-    state->dom_size += sizeof(struct json_number_s);
+    state->dom_size += sizeof(JSON_NUMBER);
     state->data_size += snprintf(NULL, 0, "%d", num) + 1;
     return true;
 }
 
-static bool M_GetDoubleValueSize(struct bson_parse_state_s *state)
+static bool M_GetDoubleValueSize(M_STATE *state)
 {
     assert(state);
 
     if (state->offset + sizeof(double) > state->size) {
-        state->error = bson_parse_error_premature_end_of_buffer;
+        state->error = BSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         return false;
     }
     double num = *(double *)&state->src[state->offset];
     state->offset += sizeof(double);
 
-    state->dom_size += sizeof(struct json_number_s);
+    state->dom_size += sizeof(JSON_NUMBER);
     state->data_size += snprintf(NULL, 0, "%f", num) + 1;
     return true;
 }
 
-static bool M_GetStringValueSize(struct bson_parse_state_s *state)
+static bool M_GetStringValueSize(M_STATE *state)
 {
     assert(state);
 
     if (state->offset + sizeof(int32_t) > state->size) {
-        state->error = bson_parse_error_premature_end_of_buffer;
+        state->error = BSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         return false;
     }
     int32_t size = *(int32_t *)&state->src[state->offset];
     state->offset += sizeof(int32_t);
     if (state->offset + size > state->size) {
-        state->error = bson_parse_error_premature_end_of_buffer;
+        state->error = BSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         return false;
     }
     if (state->src[state->offset + size - 1] != '\0') {
-        state->error = bson_parse_error_invalid_value;
+        state->error = BSON_PARSE_ERROR_INVALID_VALUE;
         return false;
     }
     state->offset += size;
-    state->dom_size += sizeof(struct json_string_s);
+    state->dom_size += sizeof(JSON_STRING);
     state->data_size += size;
     return true;
 }
 
-static bool M_GetArrayElementWrappedSize(struct bson_parse_state_s *state)
+static bool M_GetArrayElementWrappedSize(M_STATE *state)
 {
     assert(state);
 
     if (state->offset + sizeof(uint8_t) > state->size) {
-        state->error = bson_parse_error_premature_end_of_buffer;
+        state->error = BSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         return false;
     }
     uint8_t marker = state->src[state->offset];
     state->offset++;
 
     // BSON arrays always use keys
-    state->dom_size += sizeof(struct json_string_s);
+    state->dom_size += sizeof(JSON_STRING);
     if (!M_GetObjectKeySize(state)) {
         return false;
     }
 
-    state->dom_size += sizeof(struct json_value_s);
+    state->dom_size += sizeof(JSON_VALUE);
     return M_GetValueSize(state, marker);
 }
 
-static bool M_GetArraySize(struct bson_parse_state_s *state)
+static bool M_GetArraySize(M_STATE *state)
 {
     assert(state);
 
     const size_t start_offset = state->offset;
     if (state->offset + sizeof(int32_t) > state->size) {
-        state->error = bson_parse_error_premature_end_of_buffer;
+        state->error = BSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         return false;
     }
     const int size = *(int32_t *)&state->src[state->offset];
     state->offset += sizeof(int32_t);
 
     while (state->offset < start_offset + size - 1) {
-        state->dom_size += sizeof(struct json_array_element_s);
+        state->dom_size += sizeof(JSON_ARRAY_ELEMENT);
         if (!M_GetArrayElementWrappedSize(state)) {
             return false;
         }
     }
 
     if (state->offset + sizeof(char) > state->size) {
-        state->error = bson_parse_error_premature_end_of_buffer;
+        state->error = BSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         return false;
     }
     if (state->src[state->offset] != '\0') {
-        state->error = bson_parse_error_invalid_value;
+        state->error = BSON_PARSE_ERROR_INVALID_VALUE;
         return false;
     }
     state->offset++;
     return true;
 }
 
-static bool M_GetArrayValueSize(struct bson_parse_state_s *state)
+static bool M_GetArrayValueSize(M_STATE *state)
 {
     assert(state);
-    state->dom_size += sizeof(struct json_array_s);
+    state->dom_size += sizeof(JSON_ARRAY);
     return M_GetArraySize(state);
 }
 
-static bool M_GetObjectElementWrappedSize(struct bson_parse_state_s *state)
+static bool M_GetObjectElementWrappedSize(M_STATE *state)
 {
     assert(state);
 
     if (state->offset + sizeof(uint8_t) > state->size) {
-        state->error = bson_parse_error_premature_end_of_buffer;
+        state->error = BSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         return false;
     }
     uint8_t marker = state->src[state->offset];
     state->offset++;
 
-    state->dom_size += sizeof(struct json_string_s);
+    state->dom_size += sizeof(JSON_STRING);
     if (!M_GetObjectKeySize(state)) {
         return false;
     }
 
-    state->dom_size += sizeof(struct json_value_s);
+    state->dom_size += sizeof(JSON_VALUE);
     return M_GetValueSize(state, marker);
 }
 
-static bool M_GetObjectSize(struct bson_parse_state_s *state)
+static bool M_GetObjectSize(M_STATE *state)
 {
     assert(state);
 
     const size_t start_offset = state->offset;
     if (state->offset + sizeof(int32_t) > state->size) {
-        state->error = bson_parse_error_premature_end_of_buffer;
+        state->error = BSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         return false;
     }
     const int size = *(int32_t *)&state->src[state->offset];
     state->offset += sizeof(int32_t);
 
     while (state->offset < start_offset + size - 1) {
-        state->dom_size += sizeof(struct json_object_element_s);
+        state->dom_size += sizeof(JSON_OBJECT_ELEMENT);
         if (!M_GetObjectElementWrappedSize(state)) {
             return false;
         }
     }
 
     if (state->offset + sizeof(char) > state->size) {
-        state->error = bson_parse_error_premature_end_of_buffer;
+        state->error = BSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         return false;
     }
     if (state->src[state->offset] != '\0') {
-        state->error = bson_parse_error_invalid_value;
+        state->error = BSON_PARSE_ERROR_INVALID_VALUE;
         return false;
     }
     state->offset++;
     return true;
 }
 
-static bool M_GetObjectValueSize(struct bson_parse_state_s *state)
+static bool M_GetObjectValueSize(M_STATE *state)
 {
     assert(state);
-    state->dom_size += sizeof(struct json_object_s);
+    state->dom_size += sizeof(JSON_OBJECT);
     return M_GetObjectSize(state);
 }
 
-static bool M_GetValueSize(struct bson_parse_state_s *state, uint8_t marker)
+static bool M_GetValueSize(M_STATE *state, uint8_t marker)
 {
     assert(state);
     switch (marker) {
@@ -297,20 +285,19 @@ static bool M_GetValueSize(struct bson_parse_state_s *state, uint8_t marker)
     case 0x10:
         return M_GetInt32ValueSize(state);
     default:
-        state->error = bson_parse_error_invalid_value;
+        state->error = BSON_PARSE_ERROR_INVALID_VALUE;
         return false;
     }
 }
 
-static bool M_GetRootSize(struct bson_parse_state_s *state)
+static bool M_GetRootSize(M_STATE *state)
 {
     // assume the root element to be an object
-    state->dom_size += sizeof(struct json_value_s);
+    state->dom_size += sizeof(JSON_VALUE);
     return M_GetObjectValueSize(state);
 }
 
-static void M_HandleObjectKey(
-    struct bson_parse_state_s *state, struct json_string_s *string)
+static void M_HandleObjectKey(M_STATE *state, JSON_STRING *string)
 {
     assert(state);
     assert(string);
@@ -325,29 +312,27 @@ static void M_HandleObjectKey(
     state->data += size;
 }
 
-static void M_HandleNullValue(
-    struct bson_parse_state_s *state, struct json_value_s *value)
+static void M_HandleNullValue(M_STATE *state, JSON_VALUE *value)
 {
     assert(state);
     assert(value);
-    value->type = json_type_null;
-    value->payload = json_null;
+    value->type = JSON_TYPE_NULL;
+    value->payload = NULL;
 }
 
-static void M_HandleBoolValue(
-    struct bson_parse_state_s *state, struct json_value_s *value)
+static void M_HandleBoolValue(M_STATE *state, JSON_VALUE *value)
 {
     assert(state);
     assert(value);
     assert(state->offset + sizeof(char) <= state->size);
     switch (state->src[state->offset]) {
     case 0x00:
-        value->type = json_type_false;
-        value->payload = json_null;
+        value->type = JSON_TYPE_FALSE;
+        value->payload = NULL;
         break;
     case 0x01:
-        value->type = json_type_true;
-        value->payload = json_null;
+        value->type = JSON_TYPE_TRUE;
+        value->payload = NULL;
         break;
     default:
         assert(0);
@@ -355,8 +340,7 @@ static void M_HandleBoolValue(
     state->offset++;
 }
 
-static void M_HandleInt32Value(
-    struct bson_parse_state_s *state, struct json_value_s *value)
+static void M_HandleInt32Value(M_STATE *state, JSON_VALUE *value)
 {
     assert(state);
     assert(value);
@@ -365,21 +349,20 @@ static void M_HandleInt32Value(
     int32_t num = *(int32_t *)&state->src[state->offset];
     state->offset += sizeof(int32_t);
 
-    struct json_number_s *number = (struct json_number_s *)state->dom;
+    JSON_NUMBER *number = (JSON_NUMBER *)state->dom;
     number->ref_count = 1;
-    state->dom += sizeof(struct json_number_s);
+    state->dom += sizeof(JSON_NUMBER);
 
     number->number = state->data;
     sprintf(state->data, "%d", num);
     number->number_size = strlen(number->number);
     state->data += number->number_size + 1;
 
-    value->type = json_type_number;
+    value->type = JSON_TYPE_NUMBER;
     value->payload = number;
 }
 
-static void M_HandleDoubleValue(
-    struct bson_parse_state_s *state, struct json_value_s *value)
+static void M_HandleDoubleValue(M_STATE *state, JSON_VALUE *value)
 {
     assert(state);
     assert(value);
@@ -388,9 +371,9 @@ static void M_HandleDoubleValue(
     double num = *(double *)&state->src[state->offset];
     state->offset += sizeof(double);
 
-    struct json_number_s *number = (struct json_number_s *)state->dom;
+    JSON_NUMBER *number = (JSON_NUMBER *)state->dom;
     number->ref_count = 1;
-    state->dom += sizeof(struct json_number_s);
+    state->dom += sizeof(JSON_NUMBER);
 
     number->number = state->data;
     sprintf(state->data, "%f", num);
@@ -406,12 +389,11 @@ static void M_HandleDoubleValue(
         number->number[number->number_size] = '\0';
     }
 
-    value->type = json_type_number;
+    value->type = JSON_TYPE_NUMBER;
     value->payload = number;
 }
 
-static void M_HandleStringValue(
-    struct bson_parse_state_s *state, struct json_value_s *value)
+static void M_HandleStringValue(M_STATE *state, JSON_VALUE *value)
 {
     assert(state);
     assert(value);
@@ -420,9 +402,9 @@ static void M_HandleStringValue(
     int32_t size = *(int32_t *)&state->src[state->offset];
     state->offset += sizeof(int32_t);
 
-    struct json_string_s *string = (struct json_string_s *)state->dom;
+    JSON_STRING *string = (JSON_STRING *)state->dom;
     string->ref_count = 1;
-    state->dom += sizeof(struct json_string_s);
+    state->dom += sizeof(JSON_STRING);
 
     memcpy(state->data, state->src + state->offset, size);
     state->offset += size;
@@ -431,12 +413,12 @@ static void M_HandleStringValue(
     string->string_size = size;
     state->data += size;
 
-    value->type = json_type_string;
+    value->type = JSON_TYPE_STRING;
     value->payload = string;
 }
 
 static void M_HandleArrayElementWrapped(
-    struct bson_parse_state_s *state, struct json_array_element_s *element)
+    M_STATE *state, JSON_ARRAY_ELEMENT *element)
 {
     assert(state);
     assert(element);
@@ -446,22 +428,21 @@ static void M_HandleArrayElementWrapped(
     state->offset++;
 
     // BSON arrays always use keys
-    struct json_string_s *key = (struct json_string_s *)state->dom;
+    JSON_STRING *key = (JSON_STRING *)state->dom;
     key->ref_count = 1;
-    state->dom += sizeof(struct json_string_s);
+    state->dom += sizeof(JSON_STRING);
     M_HandleObjectKey(state, key);
 
-    struct json_value_s *value = (struct json_value_s *)state->dom;
+    JSON_VALUE *value = (JSON_VALUE *)state->dom;
     value->ref_count = 1;
-    state->dom += sizeof(struct json_value_s);
+    state->dom += sizeof(JSON_VALUE);
 
     element->value = value;
 
     M_HandleValue(state, value, marker);
 }
 
-static void M_HandleArray(
-    struct bson_parse_state_s *state, struct json_array_s *array)
+static void M_HandleArray(M_STATE *state, JSON_ARRAY *array)
 {
     assert(state);
     assert(array);
@@ -471,13 +452,12 @@ static void M_HandleArray(
     const int size = *(int32_t *)&state->src[state->offset];
     state->offset += sizeof(int32_t);
 
-    struct json_array_element_s *previous = NULL;
+    JSON_ARRAY_ELEMENT *previous = NULL;
     int count = 0;
     while (state->offset < start_offset + size - 1) {
-        struct json_array_element_s *element =
-            (struct json_array_element_s *)state->dom;
+        JSON_ARRAY_ELEMENT *element = (JSON_ARRAY_ELEMENT *)state->dom;
         element->ref_count = 1;
-        state->dom += sizeof(struct json_array_element_s);
+        state->dom += sizeof(JSON_ARRAY_ELEMENT);
         if (!previous) {
             array->start = element;
         } else {
@@ -500,24 +480,23 @@ static void M_HandleArray(
     state->offset++;
 }
 
-static void M_HandleArrayValue(
-    struct bson_parse_state_s *state, struct json_value_s *value)
+static void M_HandleArrayValue(M_STATE *state, JSON_VALUE *value)
 {
     assert(state);
     assert(value);
 
-    struct json_array_s *array = (struct json_array_s *)state->dom;
+    JSON_ARRAY *array = (JSON_ARRAY *)state->dom;
     array->ref_count = 1;
-    state->dom += sizeof(struct json_array_s);
+    state->dom += sizeof(JSON_ARRAY);
 
     M_HandleArray(state, array);
 
-    value->type = json_type_array;
+    value->type = JSON_TYPE_ARRAY;
     value->payload = array;
 }
 
 static void M_HandleObjectElementWrapped(
-    struct bson_parse_state_s *state, struct json_object_element_s *element)
+    M_STATE *state, JSON_OBJECT_ELEMENT *element)
 {
     assert(state);
     assert(element);
@@ -526,14 +505,14 @@ static void M_HandleObjectElementWrapped(
     uint8_t marker = state->src[state->offset];
     state->offset++;
 
-    struct json_string_s *key = (struct json_string_s *)state->dom;
+    JSON_STRING *key = (JSON_STRING *)state->dom;
     key->ref_count = 1;
-    state->dom += sizeof(struct json_string_s);
+    state->dom += sizeof(JSON_STRING);
     M_HandleObjectKey(state, key);
 
-    struct json_value_s *value = (struct json_value_s *)state->dom;
+    JSON_VALUE *value = (JSON_VALUE *)state->dom;
     value->ref_count = 1;
-    state->dom += sizeof(struct json_value_s);
+    state->dom += sizeof(JSON_VALUE);
 
     element->name = key;
     element->value = value;
@@ -541,8 +520,7 @@ static void M_HandleObjectElementWrapped(
     M_HandleValue(state, value, marker);
 }
 
-static void M_HandleObject(
-    struct bson_parse_state_s *state, struct json_object_s *object)
+static void M_HandleObject(M_STATE *state, JSON_OBJECT *object)
 {
     assert(state);
     assert(object);
@@ -552,13 +530,12 @@ static void M_HandleObject(
     const int size = *(int32_t *)&state->src[state->offset];
     state->offset += sizeof(int32_t);
 
-    struct json_object_element_s *previous = NULL;
+    JSON_OBJECT_ELEMENT *previous = NULL;
     int count = 0;
     while (state->offset < start_offset + size - 1) {
-        struct json_object_element_s *element =
-            (struct json_object_element_s *)state->dom;
+        JSON_OBJECT_ELEMENT *element = (JSON_OBJECT_ELEMENT *)state->dom;
         element->ref_count = 1;
-        state->dom += sizeof(struct json_object_element_s);
+        state->dom += sizeof(JSON_OBJECT_ELEMENT);
         if (!previous) {
             object->start = element;
         } else {
@@ -581,25 +558,22 @@ static void M_HandleObject(
     state->offset++;
 }
 
-static void M_HandleObjectValue(
-    struct bson_parse_state_s *state, struct json_value_s *value)
+static void M_HandleObjectValue(M_STATE *state, JSON_VALUE *value)
 {
     assert(state);
     assert(value);
 
-    struct json_object_s *object = (struct json_object_s *)state->dom;
+    JSON_OBJECT *object = (JSON_OBJECT *)state->dom;
     object->ref_count = 1;
-    state->dom += sizeof(struct json_object_s);
+    state->dom += sizeof(JSON_OBJECT);
 
     M_HandleObject(state, object);
 
-    value->type = json_type_object;
+    value->type = JSON_TYPE_OBJECT;
     value->payload = object;
 }
 
-static void M_HandleValue(
-    struct bson_parse_state_s *state, struct json_value_s *value,
-    uint8_t marker)
+static void M_HandleValue(M_STATE *state, JSON_VALUE *value, uint8_t marker)
 {
     assert(state);
     assert(value);
@@ -630,21 +604,21 @@ static void M_HandleValue(
     }
 }
 
-struct json_value_s *bson_parse(const char *src, size_t src_size)
+JSON_VALUE *BSON_Parse(const char *src, size_t src_size)
 {
-    return bson_parse_ex(src, src_size, NULL);
+    return BSON_ParseEx(src, src_size, NULL);
 }
 
-struct json_value_s *bson_parse_ex(
-    const char *src, size_t src_size, struct bson_parse_result_s *result)
+JSON_VALUE *BSON_ParseEx(
+    const char *src, size_t src_size, BSON_PARSE_RESULT *result)
 {
-    struct bson_parse_state_s state;
+    M_STATE state;
     void *allocation;
-    struct json_value_s *value;
+    JSON_VALUE *value;
     size_t total_size;
 
     if (result) {
-        result->error = bson_parse_error_none;
+        result->error = BSON_PARSE_ERROR_NONE;
         result->error_offset = 0;
     }
 
@@ -655,24 +629,24 @@ struct json_value_s *bson_parse_ex(
     state.src = src;
     state.size = src_size;
     state.offset = 0;
-    state.error = bson_parse_error_none;
+    state.error = BSON_PARSE_ERROR_NONE;
     state.dom_size = 0;
     state.data_size = 0;
 
     if (M_GetRootSize(&state)) {
         if (state.offset != state.size) {
-            state.error = bson_parse_error_unexpected_trailing_bytes;
+            state.error = BSON_PARSE_ERROR_UNEXPECTED_TRAILING_BYTES;
         }
     }
 
-    if (state.error != bson_parse_error_none) {
+    if (state.error != BSON_PARSE_ERROR_NONE) {
         if (result) {
             result->error = state.error;
             result->error_offset = state.offset;
         }
         LOG_ERROR(
             "Error while reading BSON near offset %d: %s", state.offset,
-            bson_get_error_description(state.error));
+            BSON_GetErrorDescription(state.error));
         return NULL;
     }
 
@@ -684,9 +658,9 @@ struct json_value_s *bson_parse_ex(
     state.data = state.dom + state.dom_size;
 
     // assume the root element to be an object
-    value = (struct json_value_s *)state.dom;
+    value = (JSON_VALUE *)state.dom;
     value->ref_count = 0;
-    state.dom += sizeof(struct json_value_s);
+    state.dom += sizeof(JSON_VALUE);
     M_HandleObjectValue(&state, value);
 
     assert(state.dom == allocation + state.dom_size);
@@ -695,22 +669,22 @@ struct json_value_s *bson_parse_ex(
     return value;
 }
 
-const char *bson_get_error_description(enum bson_parse_error_e error)
+const char *BSON_GetErrorDescription(BSON_PARSE_ERROR error)
 {
     switch (error) {
-    case bson_parse_error_none:
+    case BSON_PARSE_ERROR_NONE:
         return "no error";
 
-    case bson_parse_error_invalid_value:
+    case BSON_PARSE_ERROR_INVALID_VALUE:
         return "invalid value";
 
-    case bson_parse_error_premature_end_of_buffer:
+    case BSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER:
         return "premature end of buffer";
 
-    case bson_parse_error_unexpected_trailing_bytes:
+    case BSON_PARSE_ERROR_UNEXPECTED_TRAILING_BYTES:
         return "unexpected trailing bytes";
 
-    case bson_parse_error_unknown:
+    case BSON_PARSE_ERROR_UNKNOWN:
     default:
         return "unknown";
     }
diff --git a/src/json/bson_write.c b/src/json/bson_write.c
index 7cc7a63..834fe8c 100644
--- a/src/json/bson_write.c
+++ b/src/json/bson_write.c
@@ -19,19 +19,19 @@ static bool M_GetInt32WrappedSize(size_t *size, const char *key);
 static bool M_GetDoubleSize(size_t *size);
 static bool M_GetDoubleWrappedSize(size_t *size, const char *key);
 static bool M_GetNumberWrappedSize(
-    size_t *size, const char *key, const struct json_number_s *number);
-static bool M_GetStringSize(size_t *size, const struct json_string_s *string);
+    size_t *size, const char *key, const JSON_NUMBER *number);
+static bool M_GetStringSize(size_t *size, const JSON_STRING *string);
 static bool M_GetStringWrappedSize(
-    size_t *size, const char *key, const struct json_string_s *string);
-static bool M_GetArraySize(size_t *size, const struct json_array_s *array);
+    size_t *size, const char *key, const JSON_STRING *string);
+static bool M_GetArraySize(size_t *size, const JSON_ARRAY *array);
 static bool M_GetArrayWrappedSize(
-    size_t *size, const char *key, const struct json_array_s *array);
-static bool M_GetObjectSize(size_t *size, const struct json_object_s *object);
+    size_t *size, const char *key, const JSON_ARRAY *array);
+static bool M_GetObjectSize(size_t *size, const JSON_OBJECT *object);
 static bool M_GetObjectWrappedSize(
-    size_t *size, const char *key, const struct json_object_s *object);
-static bool M_GetValueSize(size_t *size, const struct json_value_s *value);
+    size_t *size, const char *key, const JSON_OBJECT *object);
+static bool M_GetValueSize(size_t *size, const JSON_VALUE *value);
 static bool M_GetValueWrappedSize(
-    size_t *size, const char *key, const struct json_value_s *value);
+    size_t *size, const char *key, const JSON_VALUE *value);
 
 static char *M_WriteMarker(char *data, const char *key, const uint8_t marker);
 static char *M_WriteNullWrapped(char *data, const char *key);
@@ -43,19 +43,19 @@ static char *M_WriteDouble(char *data, const double value);
 static char *M_WriteDoubleWrapped(
     char *data, const char *key, const double value);
 static char *M_WriteNumberWrapped(
-    char *data, const char *key, const struct json_number_s *number);
-static char *M_WriteString(char *data, const struct json_string_s *string);
+    char *data, const char *key, const JSON_NUMBER *number);
+static char *M_WriteString(char *data, const JSON_STRING *string);
 static char *M_WriteStringWrapped(
-    char *data, const char *key, const struct json_string_s *string);
-static char *M_WriteArray(char *data, const struct json_array_s *array);
+    char *data, const char *key, const JSON_STRING *string);
+static char *M_WriteArray(char *data, const JSON_ARRAY *array);
 static char *M_WriteArrayWrapped(
-    char *data, const char *key, const struct json_array_s *array);
-static char *M_WriteObject(char *data, const struct json_object_s *object);
+    char *data, const char *key, const JSON_ARRAY *array);
+static char *M_WriteObject(char *data, const JSON_OBJECT *object);
 static char *M_WriteObjectWrapped(
-    char *data, const char *key, const struct json_object_s *object);
-static char *M_WriteValue(char *data, const struct json_value_s *value);
+    char *data, const char *key, const JSON_OBJECT *object);
+static char *M_WriteValue(char *data, const JSON_VALUE *value);
 static char *M_WriteValueWrapped(
-    char *data, const char *key, const struct json_value_s *value);
+    char *data, const char *key, const JSON_VALUE *value);
 
 static bool M_GetMarkerSize(size_t *size, const char *key)
 {
@@ -126,7 +126,7 @@ static bool M_GetDoubleWrappedSize(size_t *size, const char *key)
 }
 
 static bool M_GetNumberWrappedSize(
-    size_t *size, const char *key, const struct json_number_s *number)
+    size_t *size, const char *key, const JSON_NUMBER *number)
 {
     assert(size);
     assert(key);
@@ -160,7 +160,7 @@ static bool M_GetNumberWrappedSize(
     return false;
 }
 
-static bool M_GetStringSize(size_t *size, const struct json_string_s *string)
+static bool M_GetStringSize(size_t *size, const JSON_STRING *string)
 {
     assert(size);
     assert(string);
@@ -171,7 +171,7 @@ static bool M_GetStringSize(size_t *size, const struct json_string_s *string)
 }
 
 static bool M_GetStringWrappedSize(
-    size_t *size, const char *key, const struct json_string_s *string)
+    size_t *size, const char *key, const JSON_STRING *string)
 {
     assert(size);
     assert(key);
@@ -185,15 +185,15 @@ static bool M_GetStringWrappedSize(
     return true;
 }
 
-static bool M_GetArraySize(size_t *size, const struct json_array_s *array)
+static bool M_GetArraySize(size_t *size, const JSON_ARRAY *array)
 {
     assert(size);
     assert(array);
     char key[12];
     int idx = 0;
     *size += sizeof(int32_t); // object size
-    for (struct json_array_element_s *element = array->start;
-         element != json_null; element = element->next) {
+    for (JSON_ARRAY_ELEMENT *element = array->start; element != NULL;
+         element = element->next) {
         sprintf(key, "%d", idx);
         idx++;
         if (!M_GetValueWrappedSize(size, key, element->value)) {
@@ -205,7 +205,7 @@ static bool M_GetArraySize(size_t *size, const struct json_array_s *array)
 }
 
 static bool M_GetArrayWrappedSize(
-    size_t *size, const char *key, const struct json_array_s *array)
+    size_t *size, const char *key, const JSON_ARRAY *array)
 {
     assert(size);
     assert(key);
@@ -219,13 +219,13 @@ static bool M_GetArrayWrappedSize(
     return true;
 }
 
-static bool M_GetObjectSize(size_t *size, const struct json_object_s *object)
+static bool M_GetObjectSize(size_t *size, const JSON_OBJECT *object)
 {
     assert(size);
     assert(object);
     *size += sizeof(int32_t); // object size
-    for (struct json_object_element_s *element = object->start;
-         element != json_null; element = element->next) {
+    for (JSON_OBJECT_ELEMENT *element = object->start; element != NULL;
+         element = element->next) {
         if (!M_GetValueWrappedSize(
                 size, element->name->string, element->value)) {
             return false;
@@ -236,7 +236,7 @@ static bool M_GetObjectSize(size_t *size, const struct json_object_s *object)
 }
 
 static bool M_GetObjectWrappedSize(
-    size_t *size, const char *key, const struct json_object_s *object)
+    size_t *size, const char *key, const JSON_OBJECT *object)
 {
     assert(size);
     assert(key);
@@ -250,15 +250,15 @@ static bool M_GetObjectWrappedSize(
     return true;
 }
 
-static bool M_GetValueSize(size_t *size, const struct json_value_s *value)
+static bool M_GetValueSize(size_t *size, const JSON_VALUE *value)
 {
     assert(size);
     assert(value);
     switch (value->type) {
-    case json_type_array:
-        return M_GetArraySize(size, (struct json_array_s *)value->payload);
-    case json_type_object:
-        return M_GetObjectSize(size, (struct json_object_s *)value->payload);
+    case JSON_TYPE_ARRAY:
+        return M_GetArraySize(size, (JSON_ARRAY *)value->payload);
+    case JSON_TYPE_OBJECT:
+        return M_GetObjectSize(size, (JSON_OBJECT *)value->payload);
     default:
         LOG_ERROR("Bad BSON root element: %d", value->type);
     }
@@ -266,30 +266,26 @@ static bool M_GetValueSize(size_t *size, const struct json_value_s *value)
 }
 
 static bool M_GetValueWrappedSize(
-    size_t *size, const char *key, const struct json_value_s *value)
+    size_t *size, const char *key, const JSON_VALUE *value)
 {
     assert(size);
     assert(key);
     assert(value);
     switch (value->type) {
-    case json_type_null:
+    case JSON_TYPE_NULL:
         return M_GetNullWrappedSize(size, key);
-    case json_type_true:
+    case JSON_TYPE_TRUE:
         return M_GetBoolWrappedSize(size, key);
-    case json_type_false:
+    case JSON_TYPE_FALSE:
         return M_GetBoolWrappedSize(size, key);
-    case json_type_number:
-        return M_GetNumberWrappedSize(
-            size, key, (struct json_number_s *)value->payload);
-    case json_type_string:
-        return M_GetStringWrappedSize(
-            size, key, (struct json_string_s *)value->payload);
-    case json_type_array:
-        return M_GetArrayWrappedSize(
-            size, key, (struct json_array_s *)value->payload);
-    case json_type_object:
-        return M_GetObjectWrappedSize(
-            size, key, (struct json_object_s *)value->payload);
+    case JSON_TYPE_NUMBER:
+        return M_GetNumberWrappedSize(size, key, (JSON_NUMBER *)value->payload);
+    case JSON_TYPE_STRING:
+        return M_GetStringWrappedSize(size, key, (JSON_STRING *)value->payload);
+    case JSON_TYPE_ARRAY:
+        return M_GetArrayWrappedSize(size, key, (JSON_ARRAY *)value->payload);
+    case JSON_TYPE_OBJECT:
+        return M_GetObjectWrappedSize(size, key, (JSON_OBJECT *)value->payload);
     default:
         LOG_ERROR("Unknown JSON element: %d", value->type);
         return false;
@@ -358,7 +354,7 @@ static char *M_WriteDoubleWrapped(
 }
 
 static char *M_WriteNumberWrapped(
-    char *data, const char *key, const struct json_number_s *number)
+    char *data, const char *key, const JSON_NUMBER *number)
 {
     assert(data);
     assert(key);
@@ -368,7 +364,7 @@ static char *M_WriteNumberWrapped(
     // hexadecimal numbers
     if (number->number_size >= 2 && (str[1] == 'x' || str[1] == 'X')) {
         return M_WriteInt32Wrapped(
-            data, key, json_strtoumax(number->number, json_null, 0));
+            data, key, json_strtoumax(number->number, NULL, 0));
     }
 
     // skip leading sign
@@ -392,7 +388,7 @@ static char *M_WriteNumberWrapped(
     return data;
 }
 
-static char *M_WriteString(char *data, const struct json_string_s *string)
+static char *M_WriteString(char *data, const JSON_STRING *string)
 {
     assert(data);
     assert(string);
@@ -405,7 +401,7 @@ static char *M_WriteString(char *data, const struct json_string_s *string)
 }
 
 static char *M_WriteStringWrapped(
-    char *data, const char *key, const struct json_string_s *string)
+    char *data, const char *key, const JSON_STRING *string)
 {
     assert(data);
     assert(key);
@@ -415,7 +411,7 @@ static char *M_WriteStringWrapped(
     return data;
 }
 
-static char *M_WriteArray(char *data, const struct json_array_s *array)
+static char *M_WriteArray(char *data, const JSON_ARRAY *array)
 {
     assert(data);
     assert(array);
@@ -423,8 +419,8 @@ static char *M_WriteArray(char *data, const struct json_array_s *array)
     int idx = 0;
     char *old = data;
     data += sizeof(int32_t);
-    for (struct json_array_element_s *element = array->start;
-         element != json_null; element = element->next) {
+    for (JSON_ARRAY_ELEMENT *element = array->start; element != NULL;
+         element = element->next) {
         sprintf(key, "%d", idx);
         idx++;
         data = M_WriteValueWrapped(data, key, element->value);
@@ -435,7 +431,7 @@ static char *M_WriteArray(char *data, const struct json_array_s *array)
 }
 
 static char *M_WriteArrayWrapped(
-    char *data, const char *key, const struct json_array_s *array)
+    char *data, const char *key, const JSON_ARRAY *array)
 {
     assert(data);
     assert(key);
@@ -445,14 +441,14 @@ static char *M_WriteArrayWrapped(
     return data;
 }
 
-static char *M_WriteObject(char *data, const struct json_object_s *object)
+static char *M_WriteObject(char *data, const JSON_OBJECT *object)
 {
     assert(data);
     assert(object);
     char *old = data;
     data += sizeof(int32_t);
-    for (struct json_object_element_s *element = object->start;
-         element != json_null; element = element->next) {
+    for (JSON_OBJECT_ELEMENT *element = object->start; element != NULL;
+         element = element->next) {
         data = M_WriteValueWrapped(data, element->name->string, element->value);
     }
     *data++ = '\0';
@@ -461,7 +457,7 @@ static char *M_WriteObject(char *data, const struct json_object_s *object)
 }
 
 static char *M_WriteObjectWrapped(
-    char *data, const char *key, const struct json_object_s *object)
+    char *data, const char *key, const JSON_OBJECT *object)
 {
     assert(data);
     assert(key);
@@ -471,16 +467,16 @@ static char *M_WriteObjectWrapped(
     return data;
 }
 
-static char *M_WriteValue(char *data, const struct json_value_s *value)
+static char *M_WriteValue(char *data, const JSON_VALUE *value)
 {
     assert(data);
     assert(value);
     switch (value->type) {
-    case json_type_array:
-        data = M_WriteArray(data, (struct json_array_s *)value->payload);
+    case JSON_TYPE_ARRAY:
+        data = M_WriteArray(data, (JSON_ARRAY *)value->payload);
         break;
-    case json_type_object:
-        data = M_WriteObject(data, (struct json_object_s *)value->payload);
+    case JSON_TYPE_OBJECT:
+        data = M_WriteObject(data, (JSON_OBJECT *)value->payload);
         break;
     default:
         assert(0);
@@ -489,53 +485,49 @@ static char *M_WriteValue(char *data, const struct json_value_s *value)
 }
 
 static char *M_WriteValueWrapped(
-    char *data, const char *key, const struct json_value_s *value)
+    char *data, const char *key, const JSON_VALUE *value)
 {
     assert(data);
     assert(key);
     assert(value);
     switch (value->type) {
-    case json_type_null:
+    case JSON_TYPE_NULL:
         return M_WriteNullWrapped(data, key);
-    case json_type_true:
+    case JSON_TYPE_TRUE:
         return M_WriteBoolWrapped(data, key, true);
-    case json_type_false:
+    case JSON_TYPE_FALSE:
         return M_WriteBoolWrapped(data, key, false);
-    case json_type_number:
-        return M_WriteNumberWrapped(
-            data, key, (struct json_number_s *)value->payload);
-    case json_type_string:
-        return M_WriteStringWrapped(
-            data, key, (struct json_string_s *)value->payload);
-    case json_type_array:
-        return M_WriteArrayWrapped(
-            data, key, (struct json_array_s *)value->payload);
-    case json_type_object:
-        return M_WriteObjectWrapped(
-            data, key, (struct json_object_s *)value->payload);
+    case JSON_TYPE_NUMBER:
+        return M_WriteNumberWrapped(data, key, (JSON_NUMBER *)value->payload);
+    case JSON_TYPE_STRING:
+        return M_WriteStringWrapped(data, key, (JSON_STRING *)value->payload);
+    case JSON_TYPE_ARRAY:
+        return M_WriteArrayWrapped(data, key, (JSON_ARRAY *)value->payload);
+    case JSON_TYPE_OBJECT:
+        return M_WriteObjectWrapped(data, key, (JSON_OBJECT *)value->payload);
     default:
-        return json_null;
+        return NULL;
     }
 }
 
-void *bson_write(const struct json_value_s *value, size_t *out_size)
+void *BSON_Write(const JSON_VALUE *value, size_t *out_size)
 {
     assert(value);
     *out_size = -1;
-    if (value == json_null) {
-        return json_null;
+    if (value == NULL) {
+        return NULL;
     }
 
     size_t size = 0;
     if (!M_GetValueSize(&size, value)) {
-        return json_null;
+        return NULL;
     }
 
     char *data = Memory_Alloc(size);
     char *data_end = M_WriteValue(data, value);
     assert((size_t)(data_end - data) == size);
 
-    if (out_size != json_null) {
+    if (out_size != NULL) {
         *out_size = size;
     }
 
diff --git a/src/json/json_base.c b/src/json/json_base.c
index 4ee5f61..e4e02f2 100644
--- a/src/json/json_base.c
+++ b/src/json/json_base.c
@@ -7,91 +7,91 @@
 #include <stdlib.h>
 #include <string.h>
 
-struct json_string_s *json_value_as_string(struct json_value_s *const value)
+JSON_STRING *JSON_ValueAsString(JSON_VALUE *const value)
 {
-    if (!value || value->type != json_type_string) {
-        return json_null;
+    if (!value || value->type != JSON_TYPE_STRING) {
+        return NULL;
     }
 
-    return (struct json_string_s *)value->payload;
+    return (JSON_STRING *)value->payload;
 }
 
-struct json_number_s *json_value_as_number(struct json_value_s *const value)
+JSON_NUMBER *JSON_ValueAsNumber(JSON_VALUE *const value)
 {
-    if (!value || value->type != json_type_number) {
-        return json_null;
+    if (!value || value->type != JSON_TYPE_NUMBER) {
+        return NULL;
     }
 
-    return (struct json_number_s *)value->payload;
+    return (JSON_NUMBER *)value->payload;
 }
 
-struct json_object_s *json_value_as_object(struct json_value_s *const value)
+JSON_OBJECT *JSON_ValueAsObject(JSON_VALUE *const value)
 {
-    if (!value || value->type != json_type_object) {
-        return json_null;
+    if (!value || value->type != JSON_TYPE_OBJECT) {
+        return NULL;
     }
 
-    return (struct json_object_s *)value->payload;
+    return (JSON_OBJECT *)value->payload;
 }
 
-struct json_array_s *json_value_as_array(struct json_value_s *const value)
+JSON_ARRAY *JSON_ValueAsArray(JSON_VALUE *const value)
 {
-    if (!value || value->type != json_type_array) {
-        return json_null;
+    if (!value || value->type != JSON_TYPE_ARRAY) {
+        return NULL;
     }
 
-    return (struct json_array_s *)value->payload;
+    return (JSON_ARRAY *)value->payload;
 }
 
-int json_value_is_true(const struct json_value_s *const value)
+int JSON_ValueIsTrue(const JSON_VALUE *const value)
 {
-    return value && value->type == json_type_true;
+    return value && value->type == JSON_TYPE_TRUE;
 }
 
-int json_value_is_false(const struct json_value_s *const value)
+int JSON_ValueIsFalse(const JSON_VALUE *const value)
 {
-    return value && value->type == json_type_false;
+    return value && value->type == JSON_TYPE_FALSE;
 }
 
-int json_value_is_null(const struct json_value_s *const value)
+int JSON_ValueIsNull(const JSON_VALUE *const value)
 {
-    return value && value->type == json_type_null;
+    return value && value->type == JSON_TYPE_NULL;
 }
 
-struct json_number_s *json_number_new_int(int number)
+JSON_NUMBER *JSON_NumberNewInt(int number)
 {
     size_t size = snprintf(NULL, 0, "%d", number) + 1;
     char *buf = Memory_Alloc(size);
     sprintf(buf, "%d", number);
-    struct json_number_s *elem = Memory_Alloc(sizeof(struct json_number_s));
+    JSON_NUMBER *elem = Memory_Alloc(sizeof(JSON_NUMBER));
     elem->number = buf;
     elem->number_size = strlen(buf);
     return elem;
 }
 
-struct json_number_s *json_number_new_int64(int64_t number)
+JSON_NUMBER *JSON_NumberNewInt64(int64_t number)
 {
     size_t size = snprintf(NULL, 0, "%" PRId64, number) + 1;
     char *buf = Memory_Alloc(size);
     sprintf(buf, "%" PRId64, number);
-    struct json_number_s *elem = Memory_Alloc(sizeof(struct json_number_s));
+    JSON_NUMBER *elem = Memory_Alloc(sizeof(JSON_NUMBER));
     elem->number = buf;
     elem->number_size = strlen(buf);
     return elem;
 }
 
-struct json_number_s *json_number_new_double(double number)
+JSON_NUMBER *JSON_NumberNewDouble(double number)
 {
     size_t size = snprintf(NULL, 0, "%f", number) + 1;
     char *buf = Memory_Alloc(size);
     sprintf(buf, "%f", number);
-    struct json_number_s *elem = Memory_Alloc(sizeof(struct json_number_s));
+    JSON_NUMBER *elem = Memory_Alloc(sizeof(JSON_NUMBER));
     elem->number = buf;
     elem->number_size = strlen(buf);
     return elem;
 }
 
-void json_number_free(struct json_number_s *num)
+void JSON_NumberFree(JSON_NUMBER *num)
 {
     if (!num->ref_count) {
         Memory_Free(num->number);
@@ -99,15 +99,15 @@ void json_number_free(struct json_number_s *num)
     }
 }
 
-struct json_string_s *json_string_new(const char *string)
+JSON_STRING *JSON_StringNew(const char *string)
 {
-    struct json_string_s *str = Memory_Alloc(sizeof(struct json_string_s));
+    JSON_STRING *str = Memory_Alloc(sizeof(JSON_STRING));
     str->string = Memory_DupStr(string);
     str->string_size = strlen(string);
     return str;
 }
 
-void json_string_free(struct json_string_s *str)
+void JSON_StringFree(JSON_STRING *str)
 {
     if (!str->ref_count) {
         Memory_Free(str->string);
@@ -115,21 +115,21 @@ void json_string_free(struct json_string_s *str)
     }
 }
 
-struct json_array_s *json_array_new(void)
+JSON_ARRAY *JSON_ArrayNew(void)
 {
-    struct json_array_s *arr = Memory_Alloc(sizeof(struct json_array_s));
+    JSON_ARRAY *arr = Memory_Alloc(sizeof(JSON_ARRAY));
     arr->start = NULL;
     arr->length = 0;
     return arr;
 }
 
-void json_array_free(struct json_array_s *arr)
+void JSON_ArrayFree(JSON_ARRAY *arr)
 {
-    struct json_array_element_s *elem = arr->start;
+    JSON_ARRAY_ELEMENT *elem = arr->start;
     while (elem) {
-        struct json_array_element_s *next = elem->next;
-        json_value_free(elem->value);
-        json_array_element_free(elem);
+        JSON_ARRAY_ELEMENT *next = elem->next;
+        JSON_ValueFree(elem->value);
+        JSON_ArrayElementFree(elem);
         elem = next;
     }
     if (!arr->ref_count) {
@@ -137,21 +137,20 @@ void json_array_free(struct json_array_s *arr)
     }
 }
 
-void json_array_element_free(struct json_array_element_s *element)
+void JSON_ArrayElementFree(JSON_ARRAY_ELEMENT *element)
 {
     if (!element->ref_count) {
         Memory_FreePointer(&element);
     }
 }
 
-void json_array_append(struct json_array_s *arr, struct json_value_s *value)
+void JSON_ArrayAppend(JSON_ARRAY *arr, JSON_VALUE *value)
 {
-    struct json_array_element_s *elem =
-        Memory_Alloc(sizeof(struct json_array_element_s));
+    JSON_ARRAY_ELEMENT *elem = Memory_Alloc(sizeof(JSON_ARRAY_ELEMENT));
     elem->value = value;
     elem->next = NULL;
     if (arr->start) {
-        struct json_array_element_s *target = arr->start;
+        JSON_ARRAY_ELEMENT *target = arr->start;
         while (target->next) {
             target = target->next;
         }
@@ -162,127 +161,120 @@ void json_array_append(struct json_array_s *arr, struct json_value_s *value)
     arr->length++;
 }
 
-void json_array_append_bool(struct json_array_s *arr, int b)
+void JSON_ArrayApendBool(JSON_ARRAY *arr, int b)
 {
-    json_array_append(arr, json_value_from_bool(b));
+    JSON_ArrayAppend(arr, JSON_ValueFromBool(b));
 }
 
-void json_array_append_int(struct json_array_s *arr, int number)
+void JSON_ArrayAppendInt(JSON_ARRAY *arr, int number)
 {
-    json_array_append(arr, json_value_from_number(json_number_new_int(number)));
+    JSON_ArrayAppend(arr, JSON_ValueFromNumber(JSON_NumberNewInt(number)));
 }
 
-void json_array_append_double(struct json_array_s *arr, double number)
+void JSON_ArrayAppendDouble(JSON_ARRAY *arr, double number)
 {
-    json_array_append(
-        arr, json_value_from_number(json_number_new_double(number)));
+    JSON_ArrayAppend(arr, JSON_ValueFromNumber(JSON_NumberNewDouble(number)));
 }
 
-void json_array_append_string(struct json_array_s *arr, const char *string)
+void JSON_ArrayAppendString(JSON_ARRAY *arr, const char *string)
 {
-    json_array_append(arr, json_value_from_string(json_string_new(string)));
+    JSON_ArrayAppend(arr, JSON_ValueFromString(JSON_StringNew(string)));
 }
 
-void json_array_append_array(
-    struct json_array_s *arr, struct json_array_s *arr2)
+void JSON_ArrayAppendArray(JSON_ARRAY *arr, JSON_ARRAY *arr2)
 {
-    json_array_append(arr, json_value_from_array(arr2));
+    JSON_ArrayAppend(arr, JSON_ValueFromArray(arr2));
 }
 
-void json_array_append_object(
-    struct json_array_s *arr, struct json_object_s *obj)
+void JSON_ArrayAppendObject(JSON_ARRAY *arr, JSON_OBJECT *obj)
 {
-    json_array_append(arr, json_value_from_object(obj));
+    JSON_ArrayAppend(arr, JSON_ValueFromObject(obj));
 }
 
-struct json_value_s *json_array_get_value(
-    struct json_array_s *arr, const size_t idx)
+JSON_VALUE *JSON_ArrayGetValue(JSON_ARRAY *arr, const size_t idx)
 {
     if (!arr || idx >= arr->length) {
-        return json_null;
+        return NULL;
     }
-    struct json_array_element_s *elem = arr->start;
+    JSON_ARRAY_ELEMENT *elem = arr->start;
     for (size_t i = 0; i < idx; i++) {
         elem = elem->next;
     }
     return elem->value;
 }
 
-int json_array_get_bool(struct json_array_s *arr, const size_t idx, int d)
+int JSON_ArrayGetBool(JSON_ARRAY *arr, const size_t idx, int d)
 {
-    struct json_value_s *value = json_array_get_value(arr, idx);
-    if (json_value_is_true(value)) {
+    JSON_VALUE *value = JSON_ArrayGetValue(arr, idx);
+    if (JSON_ValueIsTrue(value)) {
         return 1;
-    } else if (json_value_is_false(value)) {
+    } else if (JSON_ValueIsFalse(value)) {
         return 0;
     }
     return d;
 }
 
-int json_array_get_int(struct json_array_s *arr, const size_t idx, int d)
+int JSON_ArrayGetInt(JSON_ARRAY *arr, const size_t idx, int d)
 {
-    struct json_value_s *value = json_array_get_value(arr, idx);
-    struct json_number_s *num = json_value_as_number(value);
+    JSON_VALUE *value = JSON_ArrayGetValue(arr, idx);
+    JSON_NUMBER *num = JSON_ValueAsNumber(value);
     if (num) {
         return atoi(num->number);
     }
     return d;
 }
 
-double json_array_get_double(
-    struct json_array_s *arr, const size_t idx, double d)
+double JSON_ArrayGetDouble(JSON_ARRAY *arr, const size_t idx, double d)
 {
-    struct json_value_s *value = json_array_get_value(arr, idx);
-    struct json_number_s *num = json_value_as_number(value);
+    JSON_VALUE *value = JSON_ArrayGetValue(arr, idx);
+    JSON_NUMBER *num = JSON_ValueAsNumber(value);
     if (num) {
         return atof(num->number);
     }
     return d;
 }
 
-const char *json_array_get_string(
-    struct json_array_s *arr, const size_t idx, const char *d)
+const char *JSON_ArrayGetString(
+    JSON_ARRAY *arr, const size_t idx, const char *d)
 {
-    struct json_value_s *value = json_array_get_value(arr, idx);
-    struct json_string_s *str = json_value_as_string(value);
+    JSON_VALUE *value = JSON_ArrayGetValue(arr, idx);
+    JSON_STRING *str = JSON_ValueAsString(value);
     if (str) {
         return str->string;
     }
     return d;
 }
 
-struct json_array_s *json_array_get_array(
-    struct json_array_s *arr, const size_t idx)
+JSON_ARRAY *JSON_ArrayGetArray(JSON_ARRAY *arr, const size_t idx)
 {
-    struct json_value_s *value = json_array_get_value(arr, idx);
-    struct json_array_s *arr2 = json_value_as_array(value);
+    JSON_VALUE *value = JSON_ArrayGetValue(arr, idx);
+    JSON_ARRAY *arr2 = JSON_ValueAsArray(value);
     return arr2;
 }
 
-struct json_object_s *json_array_get_object(
-    struct json_array_s *arr, const size_t idx)
+JSON_OBJECT *JSON_ArrayGetObject(JSON_ARRAY *arr, const size_t idx)
 {
-    struct json_value_s *value = json_array_get_value(arr, idx);
-    struct json_object_s *obj = json_value_as_object(value);
+    JSON_VALUE *value = JSON_ArrayGetValue(arr, idx);
+    JSON_OBJECT *obj = JSON_ValueAsObject(value);
     return obj;
 }
 
-struct json_object_s *json_object_new(void)
+JSON_OBJECT *JSON_ObjectNew(void)
 {
-    struct json_object_s *obj = Memory_Alloc(sizeof(struct json_object_s));
+    JSON_OBJECT *obj = Memory_Alloc(sizeof(JSON_OBJECT));
     obj->start = NULL;
     obj->length = 0;
     return obj;
 }
 
-void json_object_free(struct json_object_s *obj)
+void JSON_ObjectFree(JSON_OBJECT *obj)
 {
-    struct json_object_element_s *elem = obj->start;
+    JSON_OBJECT_ELEMENT *elem = obj->start;
     while (elem) {
-        struct json_object_element_s *next = elem->next;
-        json_string_free(elem->name);
-        json_value_free(elem->value);
-        json_object_element_free(elem);
+        JSON_OBJECT_ELEMENT *next = elem->next;
+        JSON_StringFree(elem->name);
+        JSON_ValueFree(elem->value);
+        JSON_ObjectElementFree(elem);
         elem = next;
     }
     if (!obj->ref_count) {
@@ -290,23 +282,21 @@ void json_object_free(struct json_object_s *obj)
     }
 }
 
-void json_object_element_free(struct json_object_element_s *element)
+void JSON_ObjectElementFree(JSON_OBJECT_ELEMENT *element)
 {
     if (!element->ref_count) {
         Memory_FreePointer(&element);
     }
 }
 
-void json_object_append(
-    struct json_object_s *obj, const char *key, struct json_value_s *value)
+void JSON_ObjectAppend(JSON_OBJECT *obj, const char *key, JSON_VALUE *value)
 {
-    struct json_object_element_s *elem =
-        Memory_Alloc(sizeof(struct json_object_element_s));
-    elem->name = json_string_new(key);
+    JSON_OBJECT_ELEMENT *elem = Memory_Alloc(sizeof(JSON_OBJECT_ELEMENT));
+    elem->name = JSON_StringNew(key);
     elem->value = value;
     elem->next = NULL;
     if (obj->start) {
-        struct json_object_element_s *target = obj->start;
+        JSON_OBJECT_ELEMENT *target = obj->start;
         while (target->next) {
             target = target->next;
         }
@@ -317,58 +307,53 @@ void json_object_append(
     obj->length++;
 }
 
-void json_object_append_bool(struct json_object_s *obj, const char *key, int b)
+void JSON_ObjectAppendBool(JSON_OBJECT *obj, const char *key, int b)
 {
-    json_object_append(obj, key, json_value_from_bool(b));
+    JSON_ObjectAppend(obj, key, JSON_ValueFromBool(b));
 }
 
-void json_object_append_int(
-    struct json_object_s *obj, const char *key, int number)
+void JSON_ObjectAppendInt(JSON_OBJECT *obj, const char *key, int number)
 {
-    json_object_append(
-        obj, key, json_value_from_number(json_number_new_int(number)));
+    JSON_ObjectAppend(
+        obj, key, JSON_ValueFromNumber(JSON_NumberNewInt(number)));
 }
 
-void json_object_append_int64(
-    struct json_object_s *obj, const char *key, int64_t number)
+void JSON_ObjectAppendInt64(JSON_OBJECT *obj, const char *key, int64_t number)
 {
-    json_object_append(
-        obj, key, json_value_from_number(json_number_new_int64(number)));
+    JSON_ObjectAppend(
+        obj, key, JSON_ValueFromNumber(JSON_NumberNewInt64(number)));
 }
 
-void json_object_append_double(
-    struct json_object_s *obj, const char *key, double number)
+void JSON_ObjectAppendDouble(JSON_OBJECT *obj, const char *key, double number)
 {
-    json_object_append(
-        obj, key, json_value_from_number(json_number_new_double(number)));
+    JSON_ObjectAppend(
+        obj, key, JSON_ValueFromNumber(JSON_NumberNewDouble(number)));
 }
 
-void json_object_append_string(
-    struct json_object_s *obj, const char *key, const char *string)
+void JSON_ObjectAppendString(
+    JSON_OBJECT *obj, const char *key, const char *string)
 {
-    json_object_append(
-        obj, key, json_value_from_string(json_string_new(string)));
+    JSON_ObjectAppend(obj, key, JSON_ValueFromString(JSON_StringNew(string)));
 }
 
-void json_object_append_array(
-    struct json_object_s *obj, const char *key, struct json_array_s *arr)
+void JSON_ObjectAppendArray(JSON_OBJECT *obj, const char *key, JSON_ARRAY *arr)
 {
-    json_object_append(obj, key, json_value_from_array(arr));
+    JSON_ObjectAppend(obj, key, JSON_ValueFromArray(arr));
 }
 
-void json_object_append_object(
-    struct json_object_s *obj, const char *key, struct json_object_s *obj2)
+void JSON_ObjectAppendObject(
+    JSON_OBJECT *obj, const char *key, JSON_OBJECT *obj2)
 {
-    json_object_append(obj, key, json_value_from_object(obj2));
+    JSON_ObjectAppend(obj, key, JSON_ValueFromObject(obj2));
 }
 
-void json_object_evict_key(struct json_object_s *obj, const char *key)
+void JSON_ObjectEvictKey(JSON_OBJECT *obj, const char *key)
 {
     if (!obj) {
         return;
     }
-    struct json_object_element_s *elem = obj->start;
-    struct json_object_element_s *prev = json_null;
+    JSON_OBJECT_ELEMENT *elem = obj->start;
+    JSON_OBJECT_ELEMENT *prev = NULL;
     while (elem) {
         if (!strcmp(elem->name->string, key)) {
             if (!prev) {
@@ -376,7 +361,7 @@ void json_object_evict_key(struct json_object_s *obj, const char *key)
             } else {
                 prev->next = elem->next;
             }
-            json_object_element_free(elem);
+            JSON_ObjectElementFree(elem);
             return;
         }
         prev = elem;
@@ -384,154 +369,149 @@ void json_object_evict_key(struct json_object_s *obj, const char *key)
     }
 }
 
-struct json_value_s *json_object_get_value(
-    struct json_object_s *obj, const char *key)
+JSON_VALUE *JSON_ObjectGetValue(JSON_OBJECT *obj, const char *key)
 {
     if (!obj) {
-        return json_null;
+        return NULL;
     }
-    struct json_object_element_s *elem = obj->start;
+    JSON_OBJECT_ELEMENT *elem = obj->start;
     while (elem) {
         if (!strcmp(elem->name->string, key)) {
             return elem->value;
         }
         elem = elem->next;
     }
-    return json_null;
+    return NULL;
 }
 
-int json_object_get_bool(struct json_object_s *obj, const char *key, int d)
+int JSON_ObjectGetBool(JSON_OBJECT *obj, const char *key, int d)
 {
-    struct json_value_s *value = json_object_get_value(obj, key);
-    if (json_value_is_true(value)) {
+    JSON_VALUE *value = JSON_ObjectGetValue(obj, key);
+    if (JSON_ValueIsTrue(value)) {
         return 1;
-    } else if (json_value_is_false(value)) {
+    } else if (JSON_ValueIsFalse(value)) {
         return 0;
     }
     return d;
 }
 
-int json_object_get_int(struct json_object_s *obj, const char *key, int d)
+int JSON_ObjectGetInt(JSON_OBJECT *obj, const char *key, int d)
 {
-    struct json_value_s *value = json_object_get_value(obj, key);
-    struct json_number_s *num = json_value_as_number(value);
+    JSON_VALUE *value = JSON_ObjectGetValue(obj, key);
+    JSON_NUMBER *num = JSON_ValueAsNumber(value);
     if (num) {
         return atoi(num->number);
     }
     return d;
 }
 
-int64_t json_object_get_int64(
-    struct json_object_s *obj, const char *key, int64_t d)
+int64_t JSON_ObjectGetInt64(JSON_OBJECT *obj, const char *key, int64_t d)
 {
-    struct json_value_s *value = json_object_get_value(obj, key);
-    struct json_number_s *num = json_value_as_number(value);
+    JSON_VALUE *value = JSON_ObjectGetValue(obj, key);
+    JSON_NUMBER *num = JSON_ValueAsNumber(value);
     if (num) {
         return strtoll(num->number, NULL, 10);
     }
     return d;
 }
 
-double json_object_get_double(
-    struct json_object_s *obj, const char *key, double d)
+double JSON_ObjectGetDouble(JSON_OBJECT *obj, const char *key, double d)
 {
-    struct json_value_s *value = json_object_get_value(obj, key);
-    struct json_number_s *num = json_value_as_number(value);
+    JSON_VALUE *value = JSON_ObjectGetValue(obj, key);
+    JSON_NUMBER *num = JSON_ValueAsNumber(value);
     if (num) {
         return atof(num->number);
     }
     return d;
 }
 
-const char *json_object_get_string(
-    struct json_object_s *obj, const char *key, const char *d)
+const char *JSON_ObjectGetString(
+    JSON_OBJECT *obj, const char *key, const char *d)
 {
-    struct json_value_s *value = json_object_get_value(obj, key);
-    struct json_string_s *str = json_value_as_string(value);
+    JSON_VALUE *value = JSON_ObjectGetValue(obj, key);
+    JSON_STRING *str = JSON_ValueAsString(value);
     if (str) {
         return str->string;
     }
     return d;
 }
 
-struct json_array_s *json_object_get_array(
-    struct json_object_s *obj, const char *key)
+JSON_ARRAY *JSON_ObjectGetArray(JSON_OBJECT *obj, const char *key)
 {
-    struct json_value_s *value = json_object_get_value(obj, key);
-    struct json_array_s *arr = json_value_as_array(value);
+    JSON_VALUE *value = JSON_ObjectGetValue(obj, key);
+    JSON_ARRAY *arr = JSON_ValueAsArray(value);
     return arr;
 }
 
-struct json_object_s *json_object_get_object(
-    struct json_object_s *obj, const char *key)
+JSON_OBJECT *JSON_ObjectGetObject(JSON_OBJECT *obj, const char *key)
 {
-    struct json_value_s *value = json_object_get_value(obj, key);
-    struct json_object_s *obj2 = json_value_as_object(value);
+    JSON_VALUE *value = JSON_ObjectGetValue(obj, key);
+    JSON_OBJECT *obj2 = JSON_ValueAsObject(value);
     return obj2;
 }
 
-struct json_value_s *json_value_from_bool(int b)
+JSON_VALUE *JSON_ValueFromBool(int b)
 {
-    struct json_value_s *value = Memory_Alloc(sizeof(struct json_value_s));
-    value->type = b ? json_type_true : json_type_false;
+    JSON_VALUE *value = Memory_Alloc(sizeof(JSON_VALUE));
+    value->type = b ? JSON_TYPE_TRUE : JSON_TYPE_FALSE;
     value->payload = NULL;
     return value;
 }
 
-struct json_value_s *json_value_from_number(struct json_number_s *num)
+JSON_VALUE *JSON_ValueFromNumber(JSON_NUMBER *num)
 {
-    struct json_value_s *value = Memory_Alloc(sizeof(struct json_value_s));
-    value->type = json_type_number;
+    JSON_VALUE *value = Memory_Alloc(sizeof(JSON_VALUE));
+    value->type = JSON_TYPE_NUMBER;
     value->payload = num;
     return value;
 }
 
-struct json_value_s *json_value_from_string(struct json_string_s *str)
+JSON_VALUE *JSON_ValueFromString(JSON_STRING *str)
 {
-    struct json_value_s *value = Memory_Alloc(sizeof(struct json_value_s));
-    value->type = json_type_string;
+    JSON_VALUE *value = Memory_Alloc(sizeof(JSON_VALUE));
+    value->type = JSON_TYPE_STRING;
     value->payload = str;
     return value;
 }
 
-struct json_value_s *json_value_from_array(struct json_array_s *arr)
+JSON_VALUE *JSON_ValueFromArray(JSON_ARRAY *arr)
 {
-    struct json_value_s *value = Memory_Alloc(sizeof(struct json_value_s));
-    value->type = json_type_array;
+    JSON_VALUE *value = Memory_Alloc(sizeof(JSON_VALUE));
+    value->type = JSON_TYPE_ARRAY;
     value->payload = arr;
     return value;
 }
 
-struct json_value_s *json_value_from_object(struct json_object_s *obj)
+JSON_VALUE *JSON_ValueFromObject(JSON_OBJECT *obj)
 {
-    struct json_value_s *value = Memory_Alloc(sizeof(struct json_value_s));
-    value->type = json_type_object;
+    JSON_VALUE *value = Memory_Alloc(sizeof(JSON_VALUE));
+    value->type = JSON_TYPE_OBJECT;
     value->payload = obj;
     return value;
 }
 
-void json_value_free(struct json_value_s *value)
+void JSON_ValueFree(JSON_VALUE *value)
 {
     if (!value) {
         return;
     }
     if (!value->ref_count) {
         switch (value->type) {
-        case json_type_number:
-            json_number_free((struct json_number_s *)value->payload);
+        case JSON_TYPE_NUMBER:
+            JSON_NumberFree((JSON_NUMBER *)value->payload);
             break;
-        case json_type_string:
-            json_string_free((struct json_string_s *)value->payload);
+        case JSON_TYPE_STRING:
+            JSON_StringFree((JSON_STRING *)value->payload);
             break;
-        case json_type_array:
-            json_array_free((struct json_array_s *)value->payload);
+        case JSON_TYPE_ARRAY:
+            JSON_ArrayFree((JSON_ARRAY *)value->payload);
             break;
-        case json_type_object:
-            json_object_free((struct json_object_s *)value->payload);
+        case JSON_TYPE_OBJECT:
+            JSON_ObjectFree((JSON_OBJECT *)value->payload);
             break;
-        case json_type_true:
-        case json_type_null:
-        case json_type_false:
+        case JSON_TYPE_TRUE:
+        case JSON_TYPE_NULL:
+        case JSON_TYPE_FALSE:
             break;
         }
 
diff --git a/src/json/json_parse.c b/src/json/json_parse.c
index 653f611..1176b18 100644
--- a/src/json/json_parse.c
+++ b/src/json/json_parse.c
@@ -2,7 +2,7 @@
 
 #include "memory.h"
 
-struct json_parse_state_s {
+typedef struct {
     const char *src;
     size_t size;
     size_t offset;
@@ -14,40 +14,32 @@ struct json_parse_state_s {
     size_t line_no;
     size_t line_offset;
     size_t error;
-};
+} M_STATE;
 
 static int M_HexDigit(const char c);
 static int M_HexValue(
     const char *c, const unsigned long size, unsigned long *result);
 
-static int M_SkipWhitespace(struct json_parse_state_s *state);
-static int M_SkipCStyleComments(struct json_parse_state_s *state);
-static int M_SkipAllSkippables(struct json_parse_state_s *state);
+static int M_SkipWhitespace(M_STATE *state);
+static int M_SkipCStyleComments(M_STATE *state);
+static int M_SkipAllSkippables(M_STATE *state);
 
-static int M_GetValueSize(
-    struct json_parse_state_s *state, int is_global_object);
-static int M_GetStringSize(struct json_parse_state_s *state, size_t is_key);
+static int M_GetValueSize(M_STATE *state, int is_global_object);
+static int M_GetStringSize(M_STATE *state, size_t is_key);
 static int M_IsValidUnquotedKeyChar(const char c);
-static int M_GetKeySize(struct json_parse_state_s *state);
-static int M_GetObjectSize(
-    struct json_parse_state_s *state, int is_global_object);
-static int M_GetArraySize(struct json_parse_state_s *state);
-static int M_GetNumberSize(struct json_parse_state_s *state);
+static int M_GetKeySize(M_STATE *state);
+static int M_GetObjectSize(M_STATE *state, int is_global_object);
+static int M_GetArraySize(M_STATE *state);
+static int M_GetNumberSize(M_STATE *state);
 
 static void M_HandleValue(
-    struct json_parse_state_s *state, int is_global_object,
-    struct json_value_s *value);
-static void M_HandleString(
-    struct json_parse_state_s *state, struct json_string_s *string);
-static void M_HandleKey(
-    struct json_parse_state_s *state, struct json_string_s *string);
+    M_STATE *state, int is_global_object, JSON_VALUE *value);
+static void M_HandleString(M_STATE *state, JSON_STRING *string);
+static void M_HandleKey(M_STATE *state, JSON_STRING *string);
 static void M_HandleObject(
-    struct json_parse_state_s *state, int is_global_object,
-    struct json_object_s *object);
-static void M_HandleArray(
-    struct json_parse_state_s *state, struct json_array_s *array);
-static void M_HandleNumber(
-    struct json_parse_state_s *state, struct json_number_s *number);
+    M_STATE *state, int is_global_object, JSON_OBJECT *object);
+static void M_HandleArray(M_STATE *state, JSON_ARRAY *array);
+static void M_HandleNumber(M_STATE *state, JSON_NUMBER *number);
 
 static int M_HexDigit(const char c)
 {
@@ -85,7 +77,7 @@ static int M_HexValue(
     return 1;
 }
 
-static int M_SkipWhitespace(struct json_parse_state_s *state)
+static int M_SkipWhitespace(M_STATE *state)
 {
     size_t offset = state->offset;
     const size_t size = state->size;
@@ -127,7 +119,7 @@ static int M_SkipWhitespace(struct json_parse_state_s *state)
     return 1;
 }
 
-static int M_SkipCStyleComments(struct json_parse_state_s *state)
+static int M_SkipCStyleComments(M_STATE *state)
 {
     /* do we have a comment?. */
     if ('/' == state->src[state->offset]) {
@@ -191,7 +183,7 @@ static int M_SkipCStyleComments(struct json_parse_state_s *state)
     return 0;
 }
 
-static int M_SkipAllSkippables(struct json_parse_state_s *state)
+static int M_SkipAllSkippables(M_STATE *state)
 {
     /* skip all whitespace and other skippables until there are none left. note
      * that the previous version suffered from read past errors should. the
@@ -201,10 +193,10 @@ static int M_SkipAllSkippables(struct json_parse_state_s *state)
     int did_consume = 0;
     const size_t size = state->size;
 
-    if (json_parse_flags_allow_c_style_comments & state->flags_bitset) {
+    if (JSON_PARSE_FLAGS_ALLOW_C_STYLE_COMMENTS & state->flags_bitset) {
         do {
             if (state->offset == size) {
-                state->error = json_parse_error_premature_end_of_buffer;
+                state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
                 return 1;
             }
 
@@ -214,7 +206,7 @@ static int M_SkipAllSkippables(struct json_parse_state_s *state)
              * call.
              */
             if (state->offset == size) {
-                state->error = json_parse_error_premature_end_of_buffer;
+                state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
                 return 1;
             }
 
@@ -223,7 +215,7 @@ static int M_SkipAllSkippables(struct json_parse_state_s *state)
     } else {
         do {
             if (state->offset == size) {
-                state->error = json_parse_error_premature_end_of_buffer;
+                state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
                 return 1;
             }
 
@@ -232,14 +224,14 @@ static int M_SkipAllSkippables(struct json_parse_state_s *state)
     }
 
     if (state->offset == size) {
-        state->error = json_parse_error_premature_end_of_buffer;
+        state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         return 1;
     }
 
     return 0;
 }
 
-static int M_GetStringSize(struct json_parse_state_s *state, size_t is_key)
+static int M_GetStringSize(M_STATE *state, size_t is_key)
 {
     size_t offset = state->offset;
     const size_t size = state->size;
@@ -251,18 +243,18 @@ static int M_GetStringSize(struct json_parse_state_s *state, size_t is_key)
     unsigned long codepoint;
     unsigned long high_surrogate = 0;
 
-    if ((json_parse_flags_allow_location_information & flags_bitset) != 0
+    if ((JSON_PARSE_FLAGS_ALLOW_LOCATION_INFORMATION & flags_bitset) != 0
         && is_key != 0) {
-        state->dom_size += sizeof(struct json_string_ex_s);
+        state->dom_size += sizeof(JSON_STRING_EX);
     } else {
-        state->dom_size += sizeof(struct json_string_s);
+        state->dom_size += sizeof(JSON_STRING);
     }
 
     if ('"' != src[offset]) {
         /* if we are allowed single quoted strings check for that too. */
-        if (!((json_parse_flags_allow_single_quoted_strings & flags_bitset)
+        if (!((JSON_PARSE_FLAGS_ALLOW_SINGLE_QUOTED_STRINGS & flags_bitset)
               && is_single_quote)) {
-            state->error = json_parse_error_expected_opening_quote;
+            state->error = JSON_PARSE_ERROR_EXPECTED_OPENING_QUOTE;
             state->offset = offset;
             return 1;
         }
@@ -278,7 +270,7 @@ static int M_GetStringSize(struct json_parse_state_s *state, size_t is_key)
         switch (src[offset]) {
         case '\0':
         case '\t':
-            state->error = json_parse_error_invalid_string;
+            state->error = JSON_PARSE_ERROR_INVALID_STRING;
             state->offset = offset;
             return 1;
         }
@@ -288,14 +280,14 @@ static int M_GetStringSize(struct json_parse_state_s *state, size_t is_key)
             offset++;
 
             if (offset == size) {
-                state->error = json_parse_error_premature_end_of_buffer;
+                state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
                 state->offset = offset;
                 return 1;
             }
 
             switch (src[offset]) {
             default:
-                state->error = json_parse_error_invalid_string_escape_sequence;
+                state->error = JSON_PARSE_ERROR_INVALID_STRING_ESCAPE_SEQUENCE;
                 state->offset = offset;
                 return 1;
             case '"':
@@ -313,7 +305,7 @@ static int M_GetStringSize(struct json_parse_state_s *state, size_t is_key)
                 if (!(offset + 5 < size)) {
                     /* invalid escaped unicode sequence! */
                     state->error =
-                        json_parse_error_invalid_string_escape_sequence;
+                        JSON_PARSE_ERROR_INVALID_STRING_ESCAPE_SEQUENCE;
                     state->offset = offset;
                     return 1;
                 }
@@ -323,7 +315,7 @@ static int M_GetStringSize(struct json_parse_state_s *state, size_t is_key)
                     /* escaped unicode sequences must contain 4 hexadecimal
                      * digits! */
                     state->error =
-                        json_parse_error_invalid_string_escape_sequence;
+                        JSON_PARSE_ERROR_INVALID_STRING_ESCAPE_SEQUENCE;
                     state->offset = offset;
                     return 1;
                 }
@@ -350,7 +342,7 @@ static int M_GetStringSize(struct json_parse_state_s *state, size_t is_key)
                         high_surrogate = 0;
                     } else {
                         state->error =
-                            json_parse_error_invalid_string_escape_sequence;
+                            JSON_PARSE_ERROR_INVALID_STRING_ESCAPE_SEQUENCE;
                         state->offset = offset;
                         return 1;
                     }
@@ -369,7 +361,7 @@ static int M_GetStringSize(struct json_parse_state_s *state, size_t is_key)
                     if (offset + 11 > size || '\\' != src[offset + 5]
                         || 'u' != src[offset + 6]) {
                         state->error =
-                            json_parse_error_invalid_string_escape_sequence;
+                            JSON_PARSE_ERROR_INVALID_STRING_ESCAPE_SEQUENCE;
                         state->offset = offset;
                         return 1;
                     }
@@ -381,7 +373,7 @@ static int M_GetStringSize(struct json_parse_state_s *state, size_t is_key)
                                                                    */
                     /* we did not read the other half before. */
                     state->error =
-                        json_parse_error_invalid_string_escape_sequence;
+                        JSON_PARSE_ERROR_INVALID_STRING_ESCAPE_SEQUENCE;
                     state->offset = offset;
                     return 1;
                 } else {
@@ -394,9 +386,9 @@ static int M_GetStringSize(struct json_parse_state_s *state, size_t is_key)
                 break;
             }
         } else if (('\r' == src[offset]) || ('\n' == src[offset])) {
-            if (!(json_parse_flags_allow_multi_line_strings & flags_bitset)) {
+            if (!(JSON_PARSE_FLAGS_ALLOW_MULTI_LINE_STRINGS & flags_bitset)) {
                 /* invalid escaped unicode sequence! */
-                state->error = json_parse_error_invalid_string_escape_sequence;
+                state->error = JSON_PARSE_ERROR_INVALID_STRING_ESCAPE_SEQUENCE;
                 state->offset = offset;
                 return 1;
             }
@@ -410,7 +402,7 @@ static int M_GetStringSize(struct json_parse_state_s *state, size_t is_key)
 
     /* If the offset is equal to the size, we had a non-terminated string! */
     if (offset == size) {
-        state->error = json_parse_error_premature_end_of_buffer;
+        state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         state->offset = offset - 1;
         return 1;
     }
@@ -437,11 +429,11 @@ static int M_IsValidUnquotedKeyChar(const char c)
         || ('A' <= c && c <= 'Z') || ('_' == c));
 }
 
-static int M_GetKeySize(struct json_parse_state_s *state)
+static int M_GetKeySize(M_STATE *state)
 {
     const size_t flags_bitset = state->flags_bitset;
 
-    if (json_parse_flags_allow_unquoted_keys & flags_bitset) {
+    if (JSON_PARSE_FLAGS_ALLOW_UNQUOTED_KEYS & flags_bitset) {
         size_t offset = state->offset;
         const size_t size = state->size;
         const char *const src = state->src;
@@ -453,7 +445,7 @@ static int M_GetKeySize(struct json_parse_state_s *state)
              */
             return M_GetStringSize(state, 1);
         } else if (
-            (json_parse_flags_allow_single_quoted_strings & flags_bitset)
+            (JSON_PARSE_FLAGS_ALLOW_SINGLE_QUOTED_STRINGS & flags_bitset)
             && ('\'' == src[offset])) {
             /* ... if we got a comma, just parse the key as a string as normal.
              */
@@ -467,10 +459,10 @@ static int M_GetKeySize(struct json_parse_state_s *state)
             /* one more byte for null terminator ending the string! */
             data_size++;
 
-            if (json_parse_flags_allow_location_information & flags_bitset) {
-                state->dom_size += sizeof(struct json_string_ex_s);
+            if (JSON_PARSE_FLAGS_ALLOW_LOCATION_INFORMATION & flags_bitset) {
+                state->dom_size += sizeof(JSON_STRING_EX);
             } else {
-                state->dom_size += sizeof(struct json_string_s);
+                state->dom_size += sizeof(JSON_STRING);
             }
 
             /* update offset. */
@@ -487,8 +479,7 @@ static int M_GetKeySize(struct json_parse_state_s *state)
     }
 }
 
-static int M_GetObjectSize(
-    struct json_parse_state_s *state, int is_global_object)
+static int M_GetObjectSize(M_STATE *state, int is_global_object)
 {
     const size_t flags_bitset = state->flags_bitset;
     const char *const src = state->src;
@@ -508,7 +499,7 @@ static int M_GetObjectSize(
 
     if (!is_global_object) {
         if ('{' != src[state->offset]) {
-            state->error = json_parse_error_unknown;
+            state->error = JSON_PARSE_ERROR_UNKNOWN;
             return 1;
         }
 
@@ -516,17 +507,17 @@ static int M_GetObjectSize(
         state->offset++;
     }
 
-    state->dom_size += sizeof(struct json_object_s);
+    state->dom_size += sizeof(JSON_OBJECT);
 
     if ((state->offset == size) && !is_global_object) {
-        state->error = json_parse_error_premature_end_of_buffer;
+        state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         return 1;
     }
 
     do {
         if (!is_global_object) {
             if (M_SkipAllSkippables(state)) {
-                state->error = json_parse_error_premature_end_of_buffer;
+                state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
                 return 1;
             }
 
@@ -553,7 +544,7 @@ static int M_GetObjectSize(
                 /* skip comma. */
                 state->offset++;
                 allow_comma = 0;
-            } else if (json_parse_flags_allow_no_commas & flags_bitset) {
+            } else if (JSON_PARSE_FLAGS_ALLOW_NO_COMMAS & flags_bitset) {
                 /* we don't require a comma, and we didn't find one, which is
                  * ok! */
                 allow_comma = 0;
@@ -561,15 +552,15 @@ static int M_GetObjectSize(
                 /* otherwise we are required to have a comma, and we found none.
                  */
                 state->error =
-                    json_parse_error_expected_comma_or_closing_bracket;
+                    JSON_PARSE_ERROR_EXPECTED_COMMA_OR_CLOSING_BRACKET;
                 return 1;
             }
 
-            if (json_parse_flags_allow_trailing_comma & flags_bitset) {
+            if (JSON_PARSE_FLAGS_ALLOW_TRAILING_COMMA & flags_bitset) {
                 continue;
             } else {
                 if (M_SkipAllSkippables(state)) {
-                    state->error = json_parse_error_premature_end_of_buffer;
+                    state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
                     return 1;
                 }
             }
@@ -577,24 +568,24 @@ static int M_GetObjectSize(
 
         if (M_GetKeySize(state)) {
             /* key parsing failed! */
-            state->error = json_parse_error_invalid_string;
+            state->error = JSON_PARSE_ERROR_INVALID_STRING;
             return 1;
         }
 
         if (M_SkipAllSkippables(state)) {
-            state->error = json_parse_error_premature_end_of_buffer;
+            state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
             return 1;
         }
 
-        if (json_parse_flags_allow_equals_in_object & flags_bitset) {
+        if (JSON_PARSE_FLAGS_ALLOW_EQUALS_IN_OBJECT & flags_bitset) {
             const char current = src[state->offset];
             if ((':' != current) && ('=' != current)) {
-                state->error = json_parse_error_expected_colon;
+                state->error = JSON_PARSE_ERROR_EXPECTED_COLON;
                 return 1;
             }
         } else {
             if (':' != src[state->offset]) {
-                state->error = json_parse_error_expected_colon;
+                state->error = JSON_PARSE_ERROR_EXPECTED_COLON;
                 return 1;
             }
         }
@@ -603,7 +594,7 @@ static int M_GetObjectSize(
         state->offset++;
 
         if (M_SkipAllSkippables(state)) {
-            state->error = json_parse_error_premature_end_of_buffer;
+            state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
             return 1;
         }
 
@@ -618,16 +609,16 @@ static int M_GetObjectSize(
     } while (state->offset < size);
 
     if ((state->offset == size) && !is_global_object && !found_closing_brace) {
-        state->error = json_parse_error_premature_end_of_buffer;
+        state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
         return 1;
     }
 
-    state->dom_size += sizeof(struct json_object_element_s) * elements;
+    state->dom_size += sizeof(JSON_OBJECT_ELEMENT) * elements;
 
     return 0;
 }
 
-static int M_GetArraySize(struct json_parse_state_s *state)
+static int M_GetArraySize(M_STATE *state)
 {
     const size_t flags_bitset = state->flags_bitset;
     size_t elements = 0;
@@ -637,18 +628,18 @@ static int M_GetArraySize(struct json_parse_state_s *state)
 
     if ('[' != src[state->offset]) {
         /* expected array to begin with leading '['. */
-        state->error = json_parse_error_unknown;
+        state->error = JSON_PARSE_ERROR_UNKNOWN;
         return 1;
     }
 
     /* skip leading '['. */
     state->offset++;
 
-    state->dom_size += sizeof(struct json_array_s);
+    state->dom_size += sizeof(JSON_ARRAY);
 
     while (state->offset < size) {
         if (M_SkipAllSkippables(state)) {
-            state->error = json_parse_error_premature_end_of_buffer;
+            state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
             return 1;
         }
 
@@ -656,7 +647,7 @@ static int M_GetArraySize(struct json_parse_state_s *state)
             /* skip trailing ']'. */
             state->offset++;
 
-            state->dom_size += sizeof(struct json_array_element_s) * elements;
+            state->dom_size += sizeof(JSON_ARRAY_ELEMENT) * elements;
 
             /* finished the object! */
             return 0;
@@ -668,18 +659,18 @@ static int M_GetArraySize(struct json_parse_state_s *state)
                 /* skip comma. */
                 state->offset++;
                 allow_comma = 0;
-            } else if (!(json_parse_flags_allow_no_commas & flags_bitset)) {
+            } else if (!(JSON_PARSE_FLAGS_ALLOW_NO_COMMAS & flags_bitset)) {
                 state->error =
-                    json_parse_error_expected_comma_or_closing_bracket;
+                    JSON_PARSE_ERROR_EXPECTED_COMMA_OR_CLOSING_BRACKET;
                 return 1;
             }
 
-            if (json_parse_flags_allow_trailing_comma & flags_bitset) {
+            if (JSON_PARSE_FLAGS_ALLOW_TRAILING_COMMA & flags_bitset) {
                 allow_comma = 0;
                 continue;
             } else {
                 if (M_SkipAllSkippables(state)) {
-                    state->error = json_parse_error_premature_end_of_buffer;
+                    state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
                     return 1;
                 }
             }
@@ -697,11 +688,11 @@ static int M_GetArraySize(struct json_parse_state_s *state)
 
     /* we consumed the entire input before finding the closing ']' of the array!
      */
-    state->error = json_parse_error_premature_end_of_buffer;
+    state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
     return 1;
 }
 
-static int M_GetNumberSize(struct json_parse_state_s *state)
+static int M_GetNumberSize(M_STATE *state)
 {
     const size_t flags_bitset = state->flags_bitset;
     size_t offset = state->offset;
@@ -709,9 +700,9 @@ static int M_GetNumberSize(struct json_parse_state_s *state)
     int had_leading_digits = 0;
     const char *const src = state->src;
 
-    state->dom_size += sizeof(struct json_number_s);
+    state->dom_size += sizeof(JSON_NUMBER);
 
-    if ((json_parse_flags_allow_hexadecimal_numbers & flags_bitset)
+    if ((JSON_PARSE_FLAGS_ALLOW_HEXADECIMAL_NUMBERS & flags_bitset)
         && (offset + 1 < size) && ('0' == src[offset])
         && (('x' == src[offset + 1]) || ('X' == src[offset + 1]))) {
         /* skip the leading 0x that identifies a hexadecimal number. */
@@ -730,7 +721,7 @@ static int M_GetNumberSize(struct json_parse_state_s *state)
 
         if ((offset < size)
             && (('-' == src[offset])
-                || ((json_parse_flags_allow_leading_plus_sign & flags_bitset)
+                || ((JSON_PARSE_FLAGS_ALLOW_LEADING_PLUS_SIGN & flags_bitset)
                     && ('+' == src[offset])))) {
             /* skip valid leading '-' or '+'. */
             offset++;
@@ -738,7 +729,7 @@ static int M_GetNumberSize(struct json_parse_state_s *state)
             found_sign = 1;
         }
 
-        if (json_parse_flags_allow_inf_and_nan & flags_bitset) {
+        if (JSON_PARSE_FLAGS_ALLOW_INF_AND_NAN & flags_bitset) {
             const char inf[9] = "Infinity";
             const size_t inf_strlen = sizeof(inf) - 1;
             const char nan[4] = "NaN";
@@ -784,11 +775,11 @@ static int M_GetNumberSize(struct json_parse_state_s *state)
         if (found_sign && !inf_or_nan && (offset < size)
             && !('0' <= src[offset] && src[offset] <= '9')) {
             /* check if we are allowing leading '.'. */
-            if (!(json_parse_flags_allow_leading_or_trailing_decimal_point
+            if (!(JSON_PARSE_FLAGS_ALLOW_LEADING_OR_TRAILING_DECIMAL_POINT
                   & flags_bitset)
                 || ('.' != src[offset])) {
                 /* a leading '-' must be immediately followed by any digit! */
-                state->error = json_parse_error_invalid_number_format;
+                state->error = JSON_PARSE_ERROR_INVALID_NUMBER_FORMAT;
                 state->offset = offset;
                 return 1;
             }
@@ -806,7 +797,7 @@ static int M_GetNumberSize(struct json_parse_state_s *state)
             if ((offset < size) && ('0' <= src[offset] && src[offset] <= '9')) {
                 /* a leading '0' must not be immediately followed by any digit!
                  */
-                state->error = json_parse_error_invalid_number_format;
+                state->error = JSON_PARSE_ERROR_INVALID_NUMBER_FORMAT;
                 state->offset = offset;
                 return 1;
             }
@@ -826,12 +817,12 @@ static int M_GetNumberSize(struct json_parse_state_s *state)
             offset++;
 
             if (!('0' <= src[offset] && src[offset] <= '9')) {
-                if (!(json_parse_flags_allow_leading_or_trailing_decimal_point
+                if (!(JSON_PARSE_FLAGS_ALLOW_LEADING_OR_TRAILING_DECIMAL_POINT
                       & flags_bitset)
                     || !had_leading_digits) {
                     /* a decimal point must be followed by at least one digit.
                      */
-                    state->error = json_parse_error_invalid_number_format;
+                    state->error = JSON_PARSE_ERROR_INVALID_NUMBER_FORMAT;
                     state->offset = offset;
                     return 1;
                 }
@@ -856,7 +847,7 @@ static int M_GetNumberSize(struct json_parse_state_s *state)
             if ((offset < size)
                 && !('0' <= src[offset] && src[offset] <= '9')) {
                 /* an exponent must have at least one digit! */
-                state->error = json_parse_error_invalid_number_format;
+                state->error = JSON_PARSE_ERROR_INVALID_NUMBER_FORMAT;
                 state->offset = offset;
                 return 1;
             }
@@ -881,15 +872,15 @@ static int M_GetNumberSize(struct json_parse_state_s *state)
             /* all of the above are ok. */
             break;
         case '=':
-            if (json_parse_flags_allow_equals_in_object & flags_bitset) {
+            if (JSON_PARSE_FLAGS_ALLOW_EQUALS_IN_OBJECT & flags_bitset) {
                 break;
             }
 
-            state->error = json_parse_error_invalid_number_format;
+            state->error = JSON_PARSE_ERROR_INVALID_NUMBER_FORMAT;
             state->offset = offset;
             return 1;
         default:
-            state->error = json_parse_error_invalid_number_format;
+            state->error = JSON_PARSE_ERROR_INVALID_NUMBER_FORMAT;
             state->offset = offset;
             return 1;
         }
@@ -906,25 +897,24 @@ static int M_GetNumberSize(struct json_parse_state_s *state)
     return 0;
 }
 
-static int M_GetValueSize(
-    struct json_parse_state_s *state, int is_global_object)
+static int M_GetValueSize(M_STATE *state, int is_global_object)
 {
     const size_t flags_bitset = state->flags_bitset;
     const char *const src = state->src;
     size_t offset;
     const size_t size = state->size;
 
-    if (json_parse_flags_allow_location_information & flags_bitset) {
-        state->dom_size += sizeof(struct json_value_ex_s);
+    if (JSON_PARSE_FLAGS_ALLOW_LOCATION_INFORMATION & flags_bitset) {
+        state->dom_size += sizeof(JSON_VALUE_EX);
     } else {
-        state->dom_size += sizeof(struct json_value_s);
+        state->dom_size += sizeof(JSON_VALUE);
     }
 
     if (is_global_object) {
         return M_GetObjectSize(state, /* is_global_object = */ 1);
     } else {
         if (M_SkipAllSkippables(state)) {
-            state->error = json_parse_error_premature_end_of_buffer;
+            state->error = JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER;
             return 1;
         }
 
@@ -935,11 +925,11 @@ static int M_GetValueSize(
         case '"':
             return M_GetStringSize(state, 0);
         case '\'':
-            if (json_parse_flags_allow_single_quoted_strings & flags_bitset) {
+            if (JSON_PARSE_FLAGS_ALLOW_SINGLE_QUOTED_STRINGS & flags_bitset) {
                 return M_GetStringSize(state, 0);
             } else {
                 /* invalid value! */
-                state->error = json_parse_error_invalid_value;
+                state->error = JSON_PARSE_ERROR_INVALID_VALUE;
                 return 1;
             }
         case '{':
@@ -959,20 +949,20 @@ static int M_GetValueSize(
         case '9':
             return M_GetNumberSize(state);
         case '+':
-            if (json_parse_flags_allow_leading_plus_sign & flags_bitset) {
+            if (JSON_PARSE_FLAGS_ALLOW_LEADING_PLUS_SIGN & flags_bitset) {
                 return M_GetNumberSize(state);
             } else {
                 /* invalid value! */
-                state->error = json_parse_error_invalid_number_format;
+                state->error = JSON_PARSE_ERROR_INVALID_NUMBER_FORMAT;
                 return 1;
             }
         case '.':
-            if (json_parse_flags_allow_leading_or_trailing_decimal_point
+            if (JSON_PARSE_FLAGS_ALLOW_LEADING_OR_TRAILING_DECIMAL_POINT
                 & flags_bitset) {
                 return M_GetNumberSize(state);
             } else {
                 /* invalid value! */
-                state->error = json_parse_error_invalid_number_format;
+                state->error = JSON_PARSE_ERROR_INVALID_NUMBER_FORMAT;
                 return 1;
             }
         default:
@@ -995,12 +985,12 @@ static int M_GetValueSize(
                 state->offset += 4;
                 return 0;
             } else if (
-                (json_parse_flags_allow_inf_and_nan & flags_bitset)
+                (JSON_PARSE_FLAGS_ALLOW_INF_AND_NAN & flags_bitset)
                 && (offset + 3) <= size && 'N' == src[offset + 0]
                 && 'a' == src[offset + 1] && 'N' == src[offset + 2]) {
                 return M_GetNumberSize(state);
             } else if (
-                (json_parse_flags_allow_inf_and_nan & flags_bitset)
+                (JSON_PARSE_FLAGS_ALLOW_INF_AND_NAN & flags_bitset)
                 && (offset + 8) <= size && 'I' == src[offset + 0]
                 && 'n' == src[offset + 1] && 'f' == src[offset + 2]
                 && 'i' == src[offset + 3] && 'n' == src[offset + 4]
@@ -1010,14 +1000,13 @@ static int M_GetValueSize(
             }
 
             /* invalid value! */
-            state->error = json_parse_error_invalid_value;
+            state->error = JSON_PARSE_ERROR_INVALID_VALUE;
             return 1;
         }
     }
 }
 
-static void M_HandleString(
-    struct json_parse_state_s *state, struct json_string_s *string)
+static void M_HandleString(M_STATE *state, JSON_STRING *string)
 {
     size_t offset = state->offset;
     size_t bytes_written = 0;
@@ -1159,10 +1148,9 @@ static void M_HandleString(
     state->offset = offset;
 }
 
-static void M_HandleKey(
-    struct json_parse_state_s *state, struct json_string_s *string)
+static void M_HandleKey(M_STATE *state, JSON_STRING *string)
 {
-    if (json_parse_flags_allow_unquoted_keys & state->flags_bitset) {
+    if (JSON_PARSE_FLAGS_ALLOW_UNQUOTED_KEYS & state->flags_bitset) {
         const char *const src = state->src;
         char *const data = state->data;
         size_t offset = state->offset;
@@ -1201,15 +1189,14 @@ static void M_HandleKey(
 }
 
 static void M_HandleObject(
-    struct json_parse_state_s *state, int is_global_object,
-    struct json_object_s *object)
+    M_STATE *state, int is_global_object, JSON_OBJECT *object)
 {
     const size_t flags_bitset = state->flags_bitset;
     const size_t size = state->size;
     const char *const src = state->src;
     size_t elements = 0;
     int allow_comma = 0;
-    struct json_object_element_s *previous = json_null;
+    JSON_OBJECT_ELEMENT *previous = NULL;
 
     if (is_global_object) {
         /* if we skipped some whitespace, and then found an opening '{' of an.
@@ -1234,9 +1221,9 @@ static void M_HandleObject(
     elements = 0;
 
     while (state->offset < size) {
-        struct json_object_element_s *element = json_null;
-        struct json_string_s *string = json_null;
-        struct json_value_s *value = json_null;
+        JSON_OBJECT_ELEMENT *element = NULL;
+        JSON_STRING *string = NULL;
+        JSON_VALUE *value = NULL;
 
         if (!is_global_object) {
             M_SkipAllSkippables(state);
@@ -1265,12 +1252,12 @@ static void M_HandleObject(
             }
         }
 
-        element = (struct json_object_element_s *)state->dom;
+        element = (JSON_OBJECT_ELEMENT *)state->dom;
         element->ref_count = 1;
 
-        state->dom += sizeof(struct json_object_element_s);
+        state->dom += sizeof(JSON_OBJECT_ELEMENT);
 
-        if (json_null == previous) {
+        if (NULL == previous) {
             /* this is our first element, so record it in our object. */
             object->start = element;
         } else {
@@ -1279,10 +1266,9 @@ static void M_HandleObject(
 
         previous = element;
 
-        if (json_parse_flags_allow_location_information & flags_bitset) {
-            struct json_string_ex_s *string_ex =
-                (struct json_string_ex_s *)state->dom;
-            state->dom += sizeof(struct json_string_ex_s);
+        if (JSON_PARSE_FLAGS_ALLOW_LOCATION_INFORMATION & flags_bitset) {
+            JSON_STRING_EX *string_ex = (JSON_STRING_EX *)state->dom;
+            state->dom += sizeof(JSON_STRING_EX);
 
             string_ex->offset = state->offset;
             string_ex->line_no = state->line_no;
@@ -1290,8 +1276,8 @@ static void M_HandleObject(
 
             string = &(string_ex->string);
         } else {
-            string = (struct json_string_s *)state->dom;
-            state->dom += sizeof(struct json_string_s);
+            string = (JSON_STRING *)state->dom;
+            state->dom += sizeof(JSON_STRING);
         }
 
         element->name = string;
@@ -1305,10 +1291,9 @@ static void M_HandleObject(
 
         M_SkipAllSkippables(state);
 
-        if (json_parse_flags_allow_location_information & flags_bitset) {
-            struct json_value_ex_s *value_ex =
-                (struct json_value_ex_s *)state->dom;
-            state->dom += sizeof(struct json_value_ex_s);
+        if (JSON_PARSE_FLAGS_ALLOW_LOCATION_INFORMATION & flags_bitset) {
+            JSON_VALUE_EX *value_ex = (JSON_VALUE_EX *)state->dom;
+            state->dom += sizeof(JSON_VALUE_EX);
 
             value_ex->offset = state->offset;
             value_ex->line_no = state->line_no;
@@ -1316,8 +1301,8 @@ static void M_HandleObject(
 
             value = &(value_ex->value);
         } else {
-            value = (struct json_value_s *)state->dom;
-            state->dom += sizeof(struct json_value_s);
+            value = (JSON_VALUE *)state->dom;
+            state->dom += sizeof(JSON_VALUE);
         }
 
         element->value = value;
@@ -1331,25 +1316,24 @@ static void M_HandleObject(
 
     /* if we had at least one element, end the linked list. */
     if (previous) {
-        previous->next = json_null;
+        previous->next = NULL;
     }
 
     if (elements == 0) {
-        object->start = json_null;
+        object->start = NULL;
     }
 
     object->ref_count = 1;
     object->length = elements;
 }
 
-static void M_HandleArray(
-    struct json_parse_state_s *state, struct json_array_s *array)
+static void M_HandleArray(M_STATE *state, JSON_ARRAY *array)
 {
     const char *const src = state->src;
     const size_t size = state->size;
     size_t elements = 0;
     int allow_comma = 0;
-    struct json_array_element_s *previous = json_null;
+    JSON_ARRAY_ELEMENT *previous = NULL;
 
     /* skip leading '['. */
     state->offset++;
@@ -1360,8 +1344,8 @@ static void M_HandleArray(
     elements = 0;
 
     do {
-        struct json_array_element_s *element = json_null;
-        struct json_value_s *value = json_null;
+        JSON_ARRAY_ELEMENT *element = NULL;
+        JSON_VALUE *value = NULL;
 
         M_SkipAllSkippables(state);
 
@@ -1383,12 +1367,12 @@ static void M_HandleArray(
             }
         }
 
-        element = (struct json_array_element_s *)state->dom;
+        element = (JSON_ARRAY_ELEMENT *)state->dom;
         element->ref_count = 1;
 
-        state->dom += sizeof(struct json_array_element_s);
+        state->dom += sizeof(JSON_ARRAY_ELEMENT);
 
-        if (json_null == previous) {
+        if (NULL == previous) {
             /* this is our first element, so record it in our array. */
             array->start = element;
         } else {
@@ -1397,10 +1381,9 @@ static void M_HandleArray(
 
         previous = element;
 
-        if (json_parse_flags_allow_location_information & state->flags_bitset) {
-            struct json_value_ex_s *value_ex =
-                (struct json_value_ex_s *)state->dom;
-            state->dom += sizeof(struct json_value_ex_s);
+        if (JSON_PARSE_FLAGS_ALLOW_LOCATION_INFORMATION & state->flags_bitset) {
+            JSON_VALUE_EX *value_ex = (JSON_VALUE_EX *)state->dom;
+            state->dom += sizeof(JSON_VALUE_EX);
 
             value_ex->offset = state->offset;
             value_ex->line_no = state->line_no;
@@ -1408,8 +1391,8 @@ static void M_HandleArray(
 
             value = &(value_ex->value);
         } else {
-            value = (struct json_value_s *)state->dom;
-            state->dom += sizeof(struct json_value_s);
+            value = (JSON_VALUE *)state->dom;
+            state->dom += sizeof(JSON_VALUE);
         }
 
         element->value = value;
@@ -1423,19 +1406,18 @@ static void M_HandleArray(
 
     /* end the linked list. */
     if (previous) {
-        previous->next = json_null;
+        previous->next = NULL;
     }
 
     if (elements == 0) {
-        array->start = json_null;
+        array->start = NULL;
     }
 
     array->ref_count = 1;
     array->length = elements;
 }
 
-static void M_HandleNumber(
-    struct json_parse_state_s *state, struct json_number_s *number)
+static void M_HandleNumber(M_STATE *state, JSON_NUMBER *number)
 {
     const size_t flags_bitset = state->flags_bitset;
     size_t offset = state->offset;
@@ -1447,7 +1429,7 @@ static void M_HandleNumber(
     number->ref_count = 1;
     number->number = data;
 
-    if (json_parse_flags_allow_hexadecimal_numbers & flags_bitset) {
+    if (JSON_PARSE_FLAGS_ALLOW_HEXADECIMAL_NUMBERS & flags_bitset) {
         if (('0' == src[offset])
             && (('x' == src[offset + 1]) || ('X' == src[offset + 1]))) {
             /* consume hexadecimal digits. */
@@ -1492,7 +1474,7 @@ static void M_HandleNumber(
         }
     }
 
-    if (json_parse_flags_allow_inf_and_nan & flags_bitset) {
+    if (JSON_PARSE_FLAGS_ALLOW_INF_AND_NAN & flags_bitset) {
         const size_t inf_strlen = 8; /* = strlen("Infinity");. */
         const size_t nan_strlen = 3; /* = strlen("NaN");. */
 
@@ -1528,8 +1510,7 @@ static void M_HandleNumber(
 }
 
 static void M_HandleValue(
-    struct json_parse_state_s *state, int is_global_object,
-    struct json_value_s *value)
+    M_STATE *state, int is_global_object, JSON_VALUE *value)
 {
     const size_t flags_bitset = state->flags_bitset;
     const char *const src = state->src;
@@ -1542,35 +1523,34 @@ static void M_HandleValue(
     offset = state->offset;
 
     if (is_global_object) {
-        value->type = json_type_object;
+        value->type = JSON_TYPE_OBJECT;
         value->payload = state->dom;
-        state->dom += sizeof(struct json_object_s);
+        state->dom += sizeof(JSON_OBJECT);
         M_HandleObject(
-            state, /* is_global_object = */ 1,
-            (struct json_object_s *)value->payload);
+            state, /* is_global_object = */ 1, (JSON_OBJECT *)value->payload);
     } else {
         value->ref_count = 1;
         switch (src[offset]) {
         case '"':
         case '\'':
-            value->type = json_type_string;
+            value->type = JSON_TYPE_STRING;
             value->payload = state->dom;
-            state->dom += sizeof(struct json_string_s);
-            M_HandleString(state, (struct json_string_s *)value->payload);
+            state->dom += sizeof(JSON_STRING);
+            M_HandleString(state, (JSON_STRING *)value->payload);
             break;
         case '{':
-            value->type = json_type_object;
+            value->type = JSON_TYPE_OBJECT;
             value->payload = state->dom;
-            state->dom += sizeof(struct json_object_s);
+            state->dom += sizeof(JSON_OBJECT);
             M_HandleObject(
                 state, /* is_global_object = */ 0,
-                (struct json_object_s *)value->payload);
+                (JSON_OBJECT *)value->payload);
             break;
         case '[':
-            value->type = json_type_array;
+            value->type = JSON_TYPE_ARRAY;
             value->payload = state->dom;
-            state->dom += sizeof(struct json_array_s);
-            M_HandleArray(state, (struct json_array_s *)value->payload);
+            state->dom += sizeof(JSON_ARRAY);
+            M_HandleArray(state, (JSON_ARRAY *)value->payload);
             break;
         case '-':
         case '+':
@@ -1585,85 +1565,84 @@ static void M_HandleValue(
         case '8':
         case '9':
         case '.':
-            value->type = json_type_number;
+            value->type = JSON_TYPE_NUMBER;
             value->payload = state->dom;
-            state->dom += sizeof(struct json_number_s);
-            M_HandleNumber(state, (struct json_number_s *)value->payload);
+            state->dom += sizeof(JSON_NUMBER);
+            M_HandleNumber(state, (JSON_NUMBER *)value->payload);
             break;
         default:
             if ((offset + 4) <= size && 't' == src[offset + 0]
                 && 'r' == src[offset + 1] && 'u' == src[offset + 2]
                 && 'e' == src[offset + 3]) {
-                value->type = json_type_true;
-                value->payload = json_null;
+                value->type = JSON_TYPE_TRUE;
+                value->payload = NULL;
                 state->offset += 4;
             } else if (
                 (offset + 5) <= size && 'f' == src[offset + 0]
                 && 'a' == src[offset + 1] && 'l' == src[offset + 2]
                 && 's' == src[offset + 3] && 'e' == src[offset + 4]) {
-                value->type = json_type_false;
-                value->payload = json_null;
+                value->type = JSON_TYPE_FALSE;
+                value->payload = NULL;
                 state->offset += 5;
             } else if (
                 (offset + 4) <= size && 'n' == src[offset + 0]
                 && 'u' == src[offset + 1] && 'l' == src[offset + 2]
                 && 'l' == src[offset + 3]) {
-                value->type = json_type_null;
-                value->payload = json_null;
+                value->type = JSON_TYPE_NULL;
+                value->payload = NULL;
                 state->offset += 4;
             } else if (
-                (json_parse_flags_allow_inf_and_nan & flags_bitset)
+                (JSON_PARSE_FLAGS_ALLOW_INF_AND_NAN & flags_bitset)
                 && (offset + 3) <= size && 'N' == src[offset + 0]
                 && 'a' == src[offset + 1] && 'N' == src[offset + 2]) {
-                value->type = json_type_number;
+                value->type = JSON_TYPE_NUMBER;
                 value->payload = state->dom;
-                state->dom += sizeof(struct json_number_s);
-                M_HandleNumber(state, (struct json_number_s *)value->payload);
+                state->dom += sizeof(JSON_NUMBER);
+                M_HandleNumber(state, (JSON_NUMBER *)value->payload);
             } else if (
-                (json_parse_flags_allow_inf_and_nan & flags_bitset)
+                (JSON_PARSE_FLAGS_ALLOW_INF_AND_NAN & flags_bitset)
                 && (offset + 8) <= size && 'I' == src[offset + 0]
                 && 'n' == src[offset + 1] && 'f' == src[offset + 2]
                 && 'i' == src[offset + 3] && 'n' == src[offset + 4]
                 && 'i' == src[offset + 5] && 't' == src[offset + 6]
                 && 'y' == src[offset + 7]) {
-                value->type = json_type_number;
+                value->type = JSON_TYPE_NUMBER;
                 value->payload = state->dom;
-                state->dom += sizeof(struct json_number_s);
-                M_HandleNumber(state, (struct json_number_s *)value->payload);
+                state->dom += sizeof(JSON_NUMBER);
+                M_HandleNumber(state, (JSON_NUMBER *)value->payload);
             }
             break;
         }
     }
 }
 
-struct json_value_s *json_parse(const void *src, size_t src_size)
+JSON_VALUE *JSON_Parse(const void *src, size_t src_size)
 {
-    return json_parse_ex(
-        src, src_size, json_parse_flags_default, json_null, json_null,
-        json_null);
+    return JSON_ParseEx(
+        src, src_size, JSON_PARSE_FLAGS_DEFAULT, NULL, NULL, NULL);
 }
 
-struct json_value_s *json_parse_ex(
+JSON_VALUE *JSON_ParseEx(
     const void *src, size_t src_size, size_t flags_bitset,
     void *(*alloc_func_ptr)(void *user_data, size_t size), void *user_data,
-    struct json_parse_result_s *result)
+    JSON_PARSE_RESULT *result)
 {
-    struct json_parse_state_s state;
+    M_STATE state;
     void *allocation;
-    struct json_value_s *value;
+    JSON_VALUE *value;
     size_t total_size;
     int input_error;
 
     if (result) {
-        result->error = json_parse_error_none;
+        result->error = JSON_PARSE_ERROR_NONE;
         result->error_offset = 0;
         result->error_line_no = 0;
         result->error_row_no = 0;
     }
 
-    if (json_null == src) {
+    if (NULL == src) {
         /* invalid src pointer was null! */
-        return json_null;
+        return NULL;
     }
 
     state.src = (const char *)src;
@@ -1671,14 +1650,14 @@ struct json_value_s *json_parse_ex(
     state.offset = 0;
     state.line_no = 1;
     state.line_offset = 0;
-    state.error = json_parse_error_none;
+    state.error = JSON_PARSE_ERROR_NONE;
     state.dom_size = 0;
     state.data_size = 0;
     state.flags_bitset = flags_bitset;
 
     input_error = M_GetValueSize(
         &state,
-        (int)(json_parse_flags_allow_global_object & state.flags_bitset));
+        (int)(JSON_PARSE_FLAGS_ALLOW_GLOBAL_OBJECT & state.flags_bitset));
 
     if (input_error == 0) {
         M_SkipAllSkippables(&state);
@@ -1687,7 +1666,7 @@ struct json_value_s *json_parse_ex(
             /* our parsing didn't have an error, but there are characters
              * remaining in the input that weren't part of the JSON! */
 
-            state.error = json_parse_error_unexpected_trailing_characters;
+            state.error = JSON_PARSE_ERROR_UNEXPECTED_TRAILING_CHARACTERS;
             input_error = 1;
         }
     }
@@ -1700,7 +1679,7 @@ struct json_value_s *json_parse_ex(
             result->error_line_no = state.line_no;
             result->error_row_no = state.offset - state.line_offset;
         }
-        return json_null;
+        return NULL;
     }
 
     /* our total allocation is the combination of the dom and data sizes (we. */
@@ -1709,22 +1688,22 @@ struct json_value_s *json_parse_ex(
     /* the JSON values). */
     total_size = state.dom_size + state.data_size;
 
-    if (json_null == alloc_func_ptr) {
+    if (NULL == alloc_func_ptr) {
         allocation = Memory_Alloc(total_size);
     } else {
         allocation = alloc_func_ptr(user_data, total_size);
     }
 
-    if (json_null == allocation) {
+    if (NULL == allocation) {
         /* malloc failed! */
         if (result) {
-            result->error = json_parse_error_allocator_failed;
+            result->error = JSON_PARSE_ERROR_ALLOCATOR_FAILED;
             result->error_offset = 0;
             result->error_line_no = 0;
             result->error_row_no = 0;
         }
 
-        return json_null;
+        return NULL;
     }
 
     /* reset offset so we can reuse it. */
@@ -1737,9 +1716,9 @@ struct json_value_s *json_parse_ex(
     state.dom = (char *)allocation;
     state.data = state.dom + state.dom_size;
 
-    if (json_parse_flags_allow_location_information & state.flags_bitset) {
-        struct json_value_ex_s *value_ex = (struct json_value_ex_s *)state.dom;
-        state.dom += sizeof(struct json_value_ex_s);
+    if (JSON_PARSE_FLAGS_ALLOW_LOCATION_INFORMATION & state.flags_bitset) {
+        JSON_VALUE_EX *value_ex = (JSON_VALUE_EX *)state.dom;
+        state.dom += sizeof(JSON_VALUE_EX);
 
         value_ex->offset = state.offset;
         value_ex->line_no = state.line_no;
@@ -1747,57 +1726,57 @@ struct json_value_s *json_parse_ex(
 
         value = &(value_ex->value);
     } else {
-        value = (struct json_value_s *)state.dom;
-        state.dom += sizeof(struct json_value_s);
+        value = (JSON_VALUE *)state.dom;
+        state.dom += sizeof(JSON_VALUE);
     }
 
     M_HandleValue(
         &state,
-        (int)(json_parse_flags_allow_global_object & state.flags_bitset),
+        (int)(JSON_PARSE_FLAGS_ALLOW_GLOBAL_OBJECT & state.flags_bitset),
         value);
 
-    ((struct json_value_s *)allocation)->ref_count = 0;
+    ((JSON_VALUE *)allocation)->ref_count = 0;
 
-    return (struct json_value_s *)allocation;
+    return (JSON_VALUE *)allocation;
 }
 
-const char *json_get_error_description(enum json_parse_error_e error)
+const char *JSON_GetErrorDescription(JSON_PARSE_ERROR error)
 {
     switch (error) {
-    case json_parse_error_none:
+    case JSON_PARSE_ERROR_NONE:
         return "no error";
 
-    case json_parse_error_expected_comma_or_closing_bracket:
+    case JSON_PARSE_ERROR_EXPECTED_COMMA_OR_CLOSING_BRACKET:
         return "expected comma or closing bracket";
 
-    case json_parse_error_expected_colon:
+    case JSON_PARSE_ERROR_EXPECTED_COLON:
         return "expected colon";
 
-    case json_parse_error_expected_opening_quote:
+    case JSON_PARSE_ERROR_EXPECTED_OPENING_QUOTE:
         return "expected opening quote";
 
-    case json_parse_error_invalid_string_escape_sequence:
+    case JSON_PARSE_ERROR_INVALID_STRING_ESCAPE_SEQUENCE:
         return "invalid string escape sequence";
 
-    case json_parse_error_invalid_number_format:
+    case JSON_PARSE_ERROR_INVALID_NUMBER_FORMAT:
         return "invalid number format";
 
-    case json_parse_error_invalid_value:
+    case JSON_PARSE_ERROR_INVALID_VALUE:
         return "invalid value";
 
-    case json_parse_error_premature_end_of_buffer:
+    case JSON_PARSE_ERROR_PREMATURE_END_OF_BUFFER:
         return "premature end of buffer";
 
-    case json_parse_error_invalid_string:
+    case JSON_PARSE_ERROR_INVALID_STRING:
         return "allocator failed";
 
-    case json_parse_error_allocator_failed:
+    case JSON_PARSE_ERROR_ALLOCATOR_FAILED:
         return "allocator failed";
 
-    case json_parse_error_unexpected_trailing_characters:
+    case JSON_PARSE_ERROR_UNEXPECTED_TRAILING_CHARACTERS:
         return "unexpected trailing characters";
 
-    case json_parse_error_unknown:
+    case JSON_PARSE_ERROR_UNKNOWN:
     default:
         return "unknown";
     }
diff --git a/src/json/json_write.c b/src/json/json_write.c
index cbde566..4c63cb2 100644
--- a/src/json/json_write.c
+++ b/src/json/json_write.c
@@ -2,42 +2,36 @@
 
 #include "memory.h"
 
-static int M_GetValueSize_Minified(
-    const struct json_value_s *value, size_t *size);
-static int M_GetNumberSize(const struct json_number_s *number, size_t *size);
-static int M_GetStringSize(const struct json_string_s *string, size_t *size);
-static int M_GetArraySize_Minified(
-    const struct json_array_s *array, size_t *size);
-static int M_GetObjectSize_Minified(
-    const struct json_object_s *object, size_t *size);
-static char *M_WriteValue_Minified(
-    const struct json_value_s *value, char *data);
-static char *M_WriteNumber(const struct json_number_s *number, char *data);
-static char *M_WriteString(const struct json_string_s *string, char *data);
-static char *M_WriteArray_Minified(
-    const struct json_array_s *array, char *data);
-static char *M_WriteObject_Minified(
-    const struct json_object_s *object, char *data);
+static int M_GetValueSize_Minified(const JSON_VALUE *value, size_t *size);
+static int M_GetNumberSize(const JSON_NUMBER *number, size_t *size);
+static int M_GetStringSize(const JSON_STRING *string, size_t *size);
+static int M_GetArraySize_Minified(const JSON_ARRAY *array, size_t *size);
+static int M_GetObjectSize_Minified(const JSON_OBJECT *object, size_t *size);
+static char *M_WriteValue_Minified(const JSON_VALUE *value, char *data);
+static char *M_WriteNumber(const JSON_NUMBER *number, char *data);
+static char *M_WriteString(const JSON_STRING *string, char *data);
+static char *M_WriteArray_Minified(const JSON_ARRAY *array, char *data);
+static char *M_WriteObject_Minified(const JSON_OBJECT *object, char *data);
 static int M_GetValueSize_Pretty(
-    const struct json_value_s *value, size_t depth, size_t indent_size,
+    const JSON_VALUE *value, size_t depth, size_t indent_size,
     size_t newline_size, size_t *size);
 static int M_GetArraySize_Pretty(
-    const struct json_array_s *array, size_t depth, size_t indent_size,
+    const JSON_ARRAY *array, size_t depth, size_t indent_size,
     size_t newline_size, size_t *size);
 static int M_GetObjectSize_Pretty(
-    const struct json_object_s *object, size_t depth, size_t indent_size,
+    const JSON_OBJECT *object, size_t depth, size_t indent_size,
     size_t newline_size, size_t *size);
 static char *M_WriteValue_Pretty(
-    const struct json_value_s *value, size_t depth, const char *indent,
+    const JSON_VALUE *value, size_t depth, const char *indent,
     const char *newline, char *data);
 static char *M_WriteArray_Pretty(
-    const struct json_array_s *array, size_t depth, const char *indent,
+    const JSON_ARRAY *array, size_t depth, const char *indent,
     const char *newline, char *data);
 static char *M_WriteObject_Pretty(
-    const struct json_object_s *object, size_t depth, const char *indent,
+    const JSON_OBJECT *object, size_t depth, const char *indent,
     const char *newline, char *data);
 
-static int M_GetNumberSize(const struct json_number_s *number, size_t *size)
+static int M_GetNumberSize(const JSON_NUMBER *number, size_t *size)
 {
     json_uintmax_t parsed_number;
     size_t i;
@@ -46,10 +40,10 @@ static int M_GetNumberSize(const struct json_number_s *number, size_t *size)
         switch (number->number[1]) {
         case 'x':
         case 'X':
-            /* the number is a json_parse_flags_allow_hexadecimal_numbers
+            /* the number is a JSON_PARSE_FLAGS_ALLOW_HEXADECIMAL_NUMBERS
              * hexadecimal so we have to do extra work to convert it to a
              * non-hexadecimal for JSON output. */
-            parsed_number = json_strtoumax(number->number, json_null, 0);
+            parsed_number = json_strtoumax(number->number, NULL, 0);
 
             i = 0;
 
@@ -159,7 +153,7 @@ static int M_GetNumberSize(const struct json_number_s *number, size_t *size)
     return 0;
 }
 
-static int M_GetStringSize(const struct json_string_s *string, size_t *size)
+static int M_GetStringSize(const JSON_STRING *string, size_t *size)
 {
     size_t i;
     for (i = 0; i < string->string_size; i++) {
@@ -184,10 +178,9 @@ static int M_GetStringSize(const struct json_string_s *string, size_t *size)
     return 0;
 }
 
-static int M_GetArraySize_Minified(
-    const struct json_array_s *array, size_t *size)
+static int M_GetArraySize_Minified(const JSON_ARRAY *array, size_t *size)
 {
-    struct json_array_element_s *element;
+    JSON_ARRAY_ELEMENT *element;
 
     *size += 2; /* '[' and ']'. */
 
@@ -195,8 +188,7 @@ static int M_GetArraySize_Minified(
         *size += array->length - 1; /* ','s seperate each element. */
     }
 
-    for (element = array->start; json_null != element;
-         element = element->next) {
+    for (element = array->start; NULL != element; element = element->next) {
         if (M_GetValueSize_Minified(element->value, size)) {
             /* value was malformed! */
             return 1;
@@ -206,10 +198,9 @@ static int M_GetArraySize_Minified(
     return 0;
 }
 
-static int M_GetObjectSize_Minified(
-    const struct json_object_s *object, size_t *size)
+static int M_GetObjectSize_Minified(const JSON_OBJECT *object, size_t *size)
 {
-    struct json_object_element_s *element;
+    JSON_OBJECT_ELEMENT *element;
 
     *size += 2; /* '{' and '}'. */
 
@@ -219,8 +210,7 @@ static int M_GetObjectSize_Minified(
         *size += object->length - 1; /* ','s seperate each element. */
     }
 
-    for (element = object->start; json_null != element;
-         element = element->next) {
+    for (element = object->start; NULL != element; element = element->next) {
         if (M_GetStringSize(element->name, size)) {
             /* string was malformed! */
             return 1;
@@ -235,36 +225,33 @@ static int M_GetObjectSize_Minified(
     return 0;
 }
 
-static int M_GetValueSize_Minified(
-    const struct json_value_s *value, size_t *size)
+static int M_GetValueSize_Minified(const JSON_VALUE *value, size_t *size)
 {
     switch (value->type) {
     default:
         /* unknown value type found! */
         return 1;
-    case json_type_number:
-        return M_GetNumberSize((struct json_number_s *)value->payload, size);
-    case json_type_string:
-        return M_GetStringSize((struct json_string_s *)value->payload, size);
-    case json_type_array:
-        return M_GetArraySize_Minified(
-            (struct json_array_s *)value->payload, size);
-    case json_type_object:
-        return M_GetObjectSize_Minified(
-            (struct json_object_s *)value->payload, size);
-    case json_type_true:
+    case JSON_TYPE_NUMBER:
+        return M_GetNumberSize((JSON_NUMBER *)value->payload, size);
+    case JSON_TYPE_STRING:
+        return M_GetStringSize((JSON_STRING *)value->payload, size);
+    case JSON_TYPE_ARRAY:
+        return M_GetArraySize_Minified((JSON_ARRAY *)value->payload, size);
+    case JSON_TYPE_OBJECT:
+        return M_GetObjectSize_Minified((JSON_OBJECT *)value->payload, size);
+    case JSON_TYPE_TRUE:
         *size += 4; /* the string "true". */
         return 0;
-    case json_type_false:
+    case JSON_TYPE_FALSE:
         *size += 5; /* the string "false". */
         return 0;
-    case json_type_null:
+    case JSON_TYPE_NULL:
         *size += 4; /* the string "null". */
         return 0;
     }
 }
 
-static char *M_WriteNumber(const struct json_number_s *number, char *data)
+static char *M_WriteNumber(const JSON_NUMBER *number, char *data)
 {
     json_uintmax_t parsed_number, backup;
     size_t i;
@@ -273,10 +260,10 @@ static char *M_WriteNumber(const struct json_number_s *number, char *data)
         switch (number->number[1]) {
         case 'x':
         case 'X':
-            /* The number is a json_parse_flags_allow_hexadecimal_numbers
+            /* The number is a JSON_PARSE_FLAGS_ALLOW_HEXADECIMAL_NUMBERS
              * hexadecimal so we have to do extra work to convert it to a
              * non-hexadecimal for JSON output. */
-            parsed_number = json_strtoumax(number->number, json_null, 0);
+            parsed_number = json_strtoumax(number->number, NULL, 0);
 
             /* We need a copy of parsed number twice, so take a backup of it. */
             backup = parsed_number;
@@ -449,7 +436,7 @@ static char *M_WriteNumber(const struct json_number_s *number, char *data)
     return data;
 }
 
-static char *M_WriteString(const struct json_string_s *string, char *data)
+static char *M_WriteString(const JSON_STRING *string, char *data)
 {
     size_t i;
 
@@ -496,23 +483,22 @@ static char *M_WriteString(const struct json_string_s *string, char *data)
     return data;
 }
 
-static char *M_WriteArray_Minified(const struct json_array_s *array, char *data)
+static char *M_WriteArray_Minified(const JSON_ARRAY *array, char *data)
 {
-    struct json_array_element_s *element = json_null;
+    JSON_ARRAY_ELEMENT *element = NULL;
 
     *data++ = '['; /* open the array. */
 
-    for (element = array->start; json_null != element;
-         element = element->next) {
+    for (element = array->start; NULL != element; element = element->next) {
         if (element != array->start) {
             *data++ = ','; /* ','s seperate each element. */
         }
 
         data = M_WriteValue_Minified(element->value, data);
 
-        if (json_null == data) {
+        if (NULL == data) {
             /* value was malformed! */
-            return json_null;
+            return NULL;
         }
     }
 
@@ -521,33 +507,31 @@ static char *M_WriteArray_Minified(const struct json_array_s *array, char *data)
     return data;
 }
 
-static char *M_WriteObject_Minified(
-    const struct json_object_s *object, char *data)
+static char *M_WriteObject_Minified(const JSON_OBJECT *object, char *data)
 {
-    struct json_object_element_s *element = json_null;
+    JSON_OBJECT_ELEMENT *element = NULL;
 
     *data++ = '{'; /* open the object. */
 
-    for (element = object->start; json_null != element;
-         element = element->next) {
+    for (element = object->start; NULL != element; element = element->next) {
         if (element != object->start) {
             *data++ = ','; /* ','s seperate each element. */
         }
 
         data = M_WriteString(element->name, data);
 
-        if (json_null == data) {
+        if (NULL == data) {
             /* string was malformed! */
-            return json_null;
+            return NULL;
         }
 
         *data++ = ':'; /* ':'s seperate each name/value pair. */
 
         data = M_WriteValue_Minified(element->value, data);
 
-        if (json_null == data) {
+        if (NULL == data) {
             /* value was malformed! */
-            return json_null;
+            return NULL;
         }
     }
 
@@ -556,36 +540,34 @@ static char *M_WriteObject_Minified(
     return data;
 }
 
-static char *M_WriteValue_Minified(const struct json_value_s *value, char *data)
+static char *M_WriteValue_Minified(const JSON_VALUE *value, char *data)
 {
     switch (value->type) {
     default:
         /* unknown value type found! */
-        return json_null;
-    case json_type_number:
-        return M_WriteNumber((struct json_number_s *)value->payload, data);
-    case json_type_string:
-        return M_WriteString((struct json_string_s *)value->payload, data);
-    case json_type_array:
-        return M_WriteArray_Minified(
-            (struct json_array_s *)value->payload, data);
-    case json_type_object:
-        return M_WriteObject_Minified(
-            (struct json_object_s *)value->payload, data);
-    case json_type_true:
+        return NULL;
+    case JSON_TYPE_NUMBER:
+        return M_WriteNumber((JSON_NUMBER *)value->payload, data);
+    case JSON_TYPE_STRING:
+        return M_WriteString((JSON_STRING *)value->payload, data);
+    case JSON_TYPE_ARRAY:
+        return M_WriteArray_Minified((JSON_ARRAY *)value->payload, data);
+    case JSON_TYPE_OBJECT:
+        return M_WriteObject_Minified((JSON_OBJECT *)value->payload, data);
+    case JSON_TYPE_TRUE:
         data[0] = 't';
         data[1] = 'r';
         data[2] = 'u';
         data[3] = 'e';
         return data + 4;
-    case json_type_false:
+    case JSON_TYPE_FALSE:
         data[0] = 'f';
         data[1] = 'a';
         data[2] = 'l';
         data[3] = 's';
         data[4] = 'e';
         return data + 5;
-    case json_type_null:
+    case JSON_TYPE_NULL:
         data[0] = 'n';
         data[1] = 'u';
         data[2] = 'l';
@@ -594,42 +576,42 @@ static char *M_WriteValue_Minified(const struct json_value_s *value, char *data)
     }
 }
 
-void *json_write_minified(const struct json_value_s *value, size_t *out_size)
+void *JSON_WriteMinified(const JSON_VALUE *value, size_t *out_size)
 {
     size_t size = 0;
-    char *data = json_null;
-    char *data_end = json_null;
+    char *data = NULL;
+    char *data_end = NULL;
 
-    if (json_null == value) {
-        return json_null;
+    if (NULL == value) {
+        return NULL;
     }
 
     if (M_GetValueSize_Minified(value, &size)) {
         /* value was malformed! */
-        return json_null;
+        return NULL;
     }
 
     size += 1; /* for the '\0' null terminating character. */
 
     data = (char *)Memory_Alloc(size);
 
-    if (json_null == data) {
+    if (NULL == data) {
         /* malloc failed! */
-        return json_null;
+        return NULL;
     }
 
     data_end = M_WriteValue_Minified(value, data);
 
-    if (json_null == data_end) {
+    if (NULL == data_end) {
         /* bad chi occurred! */
         Memory_Free(data);
-        return json_null;
+        return NULL;
     }
 
     /* null terminated the string. */
     *data_end = '\0';
 
-    if (json_null != out_size) {
+    if (NULL != out_size) {
         *out_size = size;
     }
 
@@ -637,10 +619,10 @@ void *json_write_minified(const struct json_value_s *value, size_t *out_size)
 }
 
 static int M_GetArraySize_Pretty(
-    const struct json_array_s *array, size_t depth, size_t indent_size,
+    const JSON_ARRAY *array, size_t depth, size_t indent_size,
     size_t newline_size, size_t *size)
 {
-    struct json_array_element_s *element;
+    JSON_ARRAY_ELEMENT *element;
 
     *size += 1; /* '['. */
 
@@ -650,8 +632,7 @@ static int M_GetArraySize_Pretty(
 
         *size += array->length - 1; /* ','s seperate each element. */
 
-        for (element = array->start; json_null != element;
-             element = element->next) {
+        for (element = array->start; NULL != element; element = element->next) {
             /* each element gets an indent. */
             *size += (depth + 1) * indent_size;
 
@@ -679,10 +660,10 @@ static int M_GetArraySize_Pretty(
 }
 
 static int M_GetObjectSize_Pretty(
-    const struct json_object_s *object, size_t depth, size_t indent_size,
+    const JSON_OBJECT *object, size_t depth, size_t indent_size,
     size_t newline_size, size_t *size)
 {
-    struct json_object_element_s *element;
+    JSON_OBJECT_ELEMENT *element;
 
     *size += 1; /* '{'. */
 
@@ -691,7 +672,7 @@ static int M_GetObjectSize_Pretty(
 
         *size += object->length - 1; /* ','s seperate each element. */
 
-        for (element = object->start; json_null != element;
+        for (element = object->start; NULL != element;
              element = element->next) {
             /* each element gets an indent and newline. */
             *size += (depth + 1) * indent_size;
@@ -721,43 +702,43 @@ static int M_GetObjectSize_Pretty(
 }
 
 static int M_GetValueSize_Pretty(
-    const struct json_value_s *value, size_t depth, size_t indent_size,
+    const JSON_VALUE *value, size_t depth, size_t indent_size,
     size_t newline_size, size_t *size)
 {
     switch (value->type) {
     default:
         /* unknown value type found! */
         return 1;
-    case json_type_number:
-        return M_GetNumberSize((struct json_number_s *)value->payload, size);
-    case json_type_string:
-        return M_GetStringSize((struct json_string_s *)value->payload, size);
-    case json_type_array:
+    case JSON_TYPE_NUMBER:
+        return M_GetNumberSize((JSON_NUMBER *)value->payload, size);
+    case JSON_TYPE_STRING:
+        return M_GetStringSize((JSON_STRING *)value->payload, size);
+    case JSON_TYPE_ARRAY:
         return M_GetArraySize_Pretty(
-            (struct json_array_s *)value->payload, depth, indent_size,
-            newline_size, size);
-    case json_type_object:
+            (JSON_ARRAY *)value->payload, depth, indent_size, newline_size,
+            size);
+    case JSON_TYPE_OBJECT:
         return M_GetObjectSize_Pretty(
-            (struct json_object_s *)value->payload, depth, indent_size,
-            newline_size, size);
-    case json_type_true:
+            (JSON_OBJECT *)value->payload, depth, indent_size, newline_size,
+            size);
+    case JSON_TYPE_TRUE:
         *size += 4; /* the string "true". */
         return 0;
-    case json_type_false:
+    case JSON_TYPE_FALSE:
         *size += 5; /* the string "false". */
         return 0;
-    case json_type_null:
+    case JSON_TYPE_NULL:
         *size += 4; /* the string "null". */
         return 0;
     }
 }
 
 static char *M_WriteArray_Pretty(
-    const struct json_array_s *array, size_t depth, const char *indent,
+    const JSON_ARRAY *array, size_t depth, const char *indent,
     const char *newline, char *data)
 {
     size_t k, m;
-    struct json_array_element_s *element;
+    JSON_ARRAY_ELEMENT *element;
 
     *data++ = '['; /* open the array. */
 
@@ -766,8 +747,7 @@ static char *M_WriteArray_Pretty(
             *data++ = newline[k];
         }
 
-        for (element = array->start; json_null != element;
-             element = element->next) {
+        for (element = array->start; NULL != element; element = element->next) {
             if (element != array->start) {
                 *data++ = ','; /* ','s seperate each element. */
 
@@ -785,9 +765,9 @@ static char *M_WriteArray_Pretty(
             data = M_WriteValue_Pretty(
                 element->value, depth + 1, indent, newline, data);
 
-            if (json_null == data) {
+            if (NULL == data) {
                 /* value was malformed! */
-                return json_null;
+                return NULL;
             }
         }
 
@@ -808,11 +788,11 @@ static char *M_WriteArray_Pretty(
 }
 
 static char *M_WriteObject_Pretty(
-    const struct json_object_s *object, size_t depth, const char *indent,
+    const JSON_OBJECT *object, size_t depth, const char *indent,
     const char *newline, char *data)
 {
     size_t k, m;
-    struct json_object_element_s *element;
+    JSON_OBJECT_ELEMENT *element;
 
     *data++ = '{'; /* open the object. */
 
@@ -821,7 +801,7 @@ static char *M_WriteObject_Pretty(
             *data++ = newline[k];
         }
 
-        for (element = object->start; json_null != element;
+        for (element = object->start; NULL != element;
              element = element->next) {
             if (element != object->start) {
                 *data++ = ','; /* ','s seperate each element. */
@@ -839,9 +819,9 @@ static char *M_WriteObject_Pretty(
 
             data = M_WriteString(element->name, data);
 
-            if (json_null == data) {
+            if (NULL == data) {
                 /* string was malformed! */
-                return json_null;
+                return NULL;
             }
 
             /* " : "s seperate each name/value pair. */
@@ -852,9 +832,9 @@ static char *M_WriteObject_Pretty(
             data = M_WriteValue_Pretty(
                 element->value, depth + 1, indent, newline, data);
 
-            if (json_null == data) {
+            if (NULL == data) {
                 /* value was malformed! */
-                return json_null;
+                return NULL;
             }
         }
 
@@ -875,39 +855,37 @@ static char *M_WriteObject_Pretty(
 }
 
 static char *M_WriteValue_Pretty(
-    const struct json_value_s *value, size_t depth, const char *indent,
+    const JSON_VALUE *value, size_t depth, const char *indent,
     const char *newline, char *data)
 {
     switch (value->type) {
     default:
         /* unknown value type found! */
-        return json_null;
-    case json_type_number:
-        return M_WriteNumber((struct json_number_s *)value->payload, data);
-    case json_type_string:
-        return M_WriteString((struct json_string_s *)value->payload, data);
-    case json_type_array:
+        return NULL;
+    case JSON_TYPE_NUMBER:
+        return M_WriteNumber((JSON_NUMBER *)value->payload, data);
+    case JSON_TYPE_STRING:
+        return M_WriteString((JSON_STRING *)value->payload, data);
+    case JSON_TYPE_ARRAY:
         return M_WriteArray_Pretty(
-            (struct json_array_s *)value->payload, depth, indent, newline,
-            data);
-    case json_type_object:
+            (JSON_ARRAY *)value->payload, depth, indent, newline, data);
+    case JSON_TYPE_OBJECT:
         return M_WriteObject_Pretty(
-            (struct json_object_s *)value->payload, depth, indent, newline,
-            data);
-    case json_type_true:
+            (JSON_OBJECT *)value->payload, depth, indent, newline, data);
+    case JSON_TYPE_TRUE:
         data[0] = 't';
         data[1] = 'r';
         data[2] = 'u';
         data[3] = 'e';
         return data + 4;
-    case json_type_false:
+    case JSON_TYPE_FALSE:
         data[0] = 'f';
         data[1] = 'a';
         data[2] = 'l';
         data[3] = 's';
         data[4] = 'e';
         return data + 5;
-    case json_type_null:
+    case JSON_TYPE_NULL:
         data[0] = 'n';
         data[1] = 'u';
         data[2] = 'l';
@@ -916,25 +894,25 @@ static char *M_WriteValue_Pretty(
     }
 }
 
-void *json_write_pretty(
-    const struct json_value_s *value, const char *indent, const char *newline,
+void *JSON_WritePretty(
+    const JSON_VALUE *value, const char *indent, const char *newline,
     size_t *out_size)
 {
     size_t size = 0;
     size_t indent_size = 0;
     size_t newline_size = 0;
-    char *data = json_null;
-    char *data_end = json_null;
+    char *data = NULL;
+    char *data_end = NULL;
 
-    if (json_null == value) {
-        return json_null;
+    if (NULL == value) {
+        return NULL;
     }
 
-    if (json_null == indent) {
+    if (NULL == indent) {
         indent = "  "; /* default to two spaces. */
     }
 
-    if (json_null == newline) {
+    if (NULL == newline) {
         newline = "\n"; /* default to linux newlines. */
     }
 
@@ -948,30 +926,30 @@ void *json_write_pretty(
 
     if (M_GetValueSize_Pretty(value, 0, indent_size, newline_size, &size)) {
         /* value was malformed! */
-        return json_null;
+        return NULL;
     }
 
     size += 1; /* for the '\0' null terminating character. */
 
     data = (char *)Memory_Alloc(size);
 
-    if (json_null == data) {
+    if (NULL == data) {
         /* malloc failed! */
-        return json_null;
+        return NULL;
     }
 
     data_end = M_WriteValue_Pretty(value, 0, indent, newline, data);
 
-    if (json_null == data_end) {
+    if (NULL == data_end) {
         /* bad chi occurred! */
         Memory_Free(data);
-        return json_null;
+        return NULL;
     }
 
     /* null terminated the string. */
     *data_end = '\0';
 
-    if (json_null != out_size) {
+    if (NULL != out_size) {
         *out_size = size;
     }