diff --git a/Built‐In-DMG-Palettes.md b/Built‐In-DMG-Palettes.md
index 4424017..3da8e25 100644
--- a/Built‐In-DMG-Palettes.md
+++ b/Built‐In-DMG-Palettes.md
@@ -11,11 +11,11 @@ In `display.h`
 
 ## Description
 
-Four built-in presets palettes to be used with [[GB_set_palette|GB_set_palette and GB_get_palette]]:
- * `GB_PALETTE_GREY`: A palette with four evenly-spaced shades of grey.
- * `GB_PALETTE_DMG`: A green palette mimicking the look of the original Game Boy (DMG)
- * `GB_PALETTE_MGB`: An olive palette mimicking the look of the Game Boy Pocket (MGB)
- * `GB_PALETTE_GBL`: A teal palette mimicking the look of the Game Boy Light (GBL/MGL)
+Four built-in preset palettes to be used with [[GB_set_palette|GB_set_palette and GB_get_palette]]:
+* `GB_PALETTE_GREY`: A palette with four evenly-spaced shades of grey.
+* `GB_PALETTE_DMG`: A green palette mimicking the look of the original Game Boy (DMG)
+* `GB_PALETTE_MGB`: An olive palette mimicking the look of the Game Boy Pocket (MGB)
+* `GB_PALETTE_GBL`: A teal palette mimicking the look of the Game Boy Light (GBL/MGL)
 
 
 ## See Also
diff --git a/GB_CONTEXT_SAFETY.md b/GB_CONTEXT_SAFETY.md
index e3ff688..7a5d2ec 100644
--- a/GB_CONTEXT_SAFETY.md
+++ b/GB_CONTEXT_SAFETY.md
@@ -10,4 +10,4 @@ In `gb.h`
 
 ## Description
 
-When this macro is defined, SameBoy is built with thread-safety assertions. It is implicitly defined in release builds where `NDEBUG` is not defined.
\ No newline at end of file
+When this macro is defined, SameBoy is built with thread-safety assertions. It is implicitly defined in release builds where `NDEBUG` is not defined. 
diff --git a/GB_apu_set_sample_callback.md b/GB_apu_set_sample_callback.md
index c01822c..a70d8b8 100644
--- a/GB_apu_set_sample_callback.md
+++ b/GB_apu_set_sample_callback.md
@@ -10,7 +10,7 @@ In `apu.h`
 
 ## Description
 
-This function sets a callback that's whenever the emulator instance has a rendered sample ready. The rate in which the callback is called is controlled by the [[sample rate|GB_set_sample_rate]].
+This function sets a callback that triggers whenever the emulator instance has a rendered sample ready. The rate at which the callback is called is controlled by the [[sample rate|GB_set_sample_rate]].
 
 ## Thread Safety
 
@@ -23,4 +23,4 @@ The callback isn't called when the sample rate is set to 0.
 ## See Also
 
 * [[GB_sample_t]]
-* [[GB_set_sample_rate]]
\ No newline at end of file
+* [[GB_set_sample_rate]]
diff --git a/GB_attributed_log.md b/GB_attributed_log.md
index 95e2205..2dd0cfe 100644
--- a/GB_attributed_log.md
+++ b/GB_attributed_log.md
@@ -6,7 +6,7 @@ In `gb.h`
 
 ## Description
 
-A convenient function used to log formatted string (following `printf` semantics), along with [[attributes|GB_log_attributes_t]] through an emulator instance's [[log callback|GB_set_log_callback]].
+A convenient function used to log a formatted string (following `printf` semantics), along with [[attributes|GB_log_attributes_t]] through an emulator instance's [[log callback|GB_set_log_callback]].
 
 ## Thread Safety
 
@@ -16,4 +16,4 @@ A convenient function used to log formatted string (following `printf` semantics
 
 * [[GB_log]]
 * [[GB_log_attributes_t]]
-* [[GB_set_log_callback]]
\ No newline at end of file
+* [[GB_set_log_callback]]
diff --git a/GB_clear_joyp_accessed.md b/GB_clear_joyp_accessed.md
index 3ae42c7..eebc228 100644
--- a/GB_clear_joyp_accessed.md
+++ b/GB_clear_joyp_accessed.md
@@ -14,4 +14,4 @@ Resets the value returned by [[GB_get_joyp_accessed]] back to `false`. See [[GB_
 
 ## See Also
 
-* [[GB_get_joyp_accessed]]
\ No newline at end of file
+* [[GB_get_joyp_accessed]]
diff --git a/GB_debugger_break.md b/GB_debugger_break.md
index ff43fc2..0469186 100644
--- a/GB_debugger_break.md
+++ b/GB_debugger_break.md
@@ -14,4 +14,4 @@ Breaks the debugger. This will cause the emulator instance to [[wait for the use
 
 ## See Also
 
-* [[GB_debugger_is_stopped]]
\ No newline at end of file
+* [[GB_debugger_is_stopped]]
diff --git a/GB_debugger_evaluate.md b/GB_debugger_evaluate.md
index b5598e9..7ed0679 100644
--- a/GB_debugger_evaluate.md
+++ b/GB_debugger_evaluate.md
@@ -6,7 +6,7 @@ In `debugger.h`
 
 ## Description
 
-Evaluates the expression `string` in the context of an emulator instance. Return `true` if the expression was evaluated successfully.
+Evaluates the expression `string` in the context of an emulator instance. Returns `true` if the expression was evaluated successfully.
 
 If `result` is not `NULL`, it will be populated with the 16-bit result of the evaluated expression upon success.
 
@@ -18,4 +18,4 @@ If `result_bank` is not `NULL`, it will be populated with the bank of the evalua
 
 ## See Also
 
-* [[GB_debugger_execute_command]]
\ No newline at end of file
+* [[GB_debugger_execute_command]]
diff --git a/GB_debugger_execute_command.md b/GB_debugger_execute_command.md
index 626f000..64ddb28 100644
--- a/GB_debugger_execute_command.md
+++ b/GB_debugger_execute_command.md
@@ -6,7 +6,7 @@ In `debugger.h`
 
 ## Description
 
-Executes a debugger command `input` in an emulator instance, and returns its (potentially formatted) output via the [[logging interface|GB_set_log_callback]].
+Executes a debugger command `input` in an emulator instance and returns its (potentially formatted) output via the [[logging interface|GB_set_log_callback]].
 
 The contents of `input` are destroyed upon returning from this function.
 
@@ -16,8 +16,8 @@ The contents of `input` are destroyed upon returning from this function.
 
 ## Notes
 
-Some flow-control commands, such as `continue` and `step`, are not supported by this function and may not behave as expected.
+Some flow control commands, such as `continue` and `step`, are not supported by this function and may not behave as expected.
 
 ## See Also
 
-* [[GB_debugger_evaluate]]
\ No newline at end of file
+* [[GB_debugger_evaluate]]
diff --git a/GB_debugger_is_stopped.md b/GB_debugger_is_stopped.md
index bda3b6d..ac0ea6a 100644
--- a/GB_debugger_is_stopped.md
+++ b/GB_debugger_is_stopped.md
@@ -6,7 +6,7 @@ In `debugger.h`
 
 ## Description
 
-Returns `true` if the debugger has stopped (due to a [[break|GB_debugger_break]] or a stop condition), and hasn't been resumed by a command yet.
+Returns `true` if the debugger has stopped (due to a [[break|GB_debugger_break]] or a stop condition) and has not been resumed by a command yet.
 
 ## Thread Safety
 
@@ -14,4 +14,4 @@ Returns `true` if the debugger has stopped (due to a [[break|GB_debugger_break]]
 
 ## See Also
 
-* [[GB_debugger_break]]
\ No newline at end of file
+* [[GB_debugger_break]]
diff --git a/GB_gameboy_t.md b/GB_gameboy_t.md
index f11716a..e3006a8 100644
--- a/GB_gameboy_t.md
+++ b/GB_gameboy_t.md
@@ -12,7 +12,7 @@ An object representing an emulated Game Boy instance, normally passed as a refer
 
 ## Notes
 
-The size of this struct changes between versions of SameBoy. If the version of SameBoy you're linking against is not known in compile-time, you must not allocate instance statically. See [[Instance Allocation]].
+The size of this struct changes between versions of SameBoy. If the version of SameBoy you're linking against is not known at compile time, you must not allocate the instance statically. See [[Instance Allocation]].
 
 ## See Also
-* [[Instance Allocation]]
\ No newline at end of file
+* [[Instance Allocation]]
diff --git a/GB_gbs_switch_track.md b/GB_gbs_switch_track.md
index 4f91631..fd405d7 100644
--- a/GB_gbs_switch_track.md
+++ b/GB_gbs_switch_track.md
@@ -16,7 +16,7 @@ Resets the emulator instance and sets it to play the specified `track` number in
 
 This function replaces [[GB_reset]] and [[GB_quick_reset]] on emulator instances that successfully loaded a GBS file. Do not call this function on emulator instances that have a different type of file loaded, and vice versa.
 
-You must call this function some time after [[GB_load_gbs]] or [[GB_load_gbs_from_buffer]] and before the first call to [[GB_run]] or [[GB_run_frame]].
+You must call this function sometime after [[GB_load_gbs]] or [[GB_load_gbs_from_buffer]] and before the first call to [[GB_run]] or [[GB_run_frame]].
 
 If you call [[GB_switch_model_and_reset]] on an emulator instance that has a GBS file loaded, you must call this function before the first call to [[GB_run]] or [[GB_run_frame]].
 
@@ -24,4 +24,4 @@ If you call [[GB_switch_model_and_reset]] on an emulator instance that has a GBS
 
 * [[GB_load_gbs]]
 * [[GB_load_gbs_from_buffer]]
-* [[GB_gbs_info_t]]
\ No newline at end of file
+* [[GB_gbs_info_t]]
diff --git a/GB_get_clock_rate.md b/GB_get_clock_rate.md
index 1e840ca..701a0a4 100644
--- a/GB_get_clock_rate.md
+++ b/GB_get_clock_rate.md
@@ -6,7 +6,7 @@ In `gb.h`
 
 ## Description
 
-Returns the current clock rate of the emulator instance, in Hertz. The value returned by this function is affected by the [[clock multiplier|GB_set_clock_multiplier]].
+Returns the current clock rate of the emulator instance in Hertz. The value returned by this function is affected by the [[clock multiplier|GB_set_clock_multiplier]].
 
 ## Thread Safety
 
@@ -15,4 +15,4 @@ Returns the current clock rate of the emulator instance, in Hertz. The value ret
 ## See Also
 
 * [[GB_set_clock_multiplier]]
-* [[GB_get_unmultiplied_clock_rate]]
\ No newline at end of file
+* [[GB_get_unmultiplied_clock_rate]]
diff --git a/GB_get_direct_access.md b/GB_get_direct_access.md
index a16a399..b30a0b1 100644
--- a/GB_get_direct_access.md
+++ b/GB_get_direct_access.md
@@ -46,11 +46,11 @@ The regions supported by this function are:
 
 ## Notes
 
-The pointers returned by this function may become invalid upon calling a function that loads a different ROM (e.g. [[GB_load_rom]]) or by [[switching the emulated model|GB_switch_model_and_reset]]. Make sure to not retain pointers to these buffers after they stop being valid.
+The pointers returned by this function may become invalid upon calling a function that loads a different ROM (e.g. [[GB_load_rom]]) or by [[switching the emulated model|GB_switch_model_and_reset]]. Make sure not to retain pointers to these buffers after they stop being valid.
 
-Some MMIO registers will not appear in the `GB_DIRECT_ACCESS_IO` region in the same way they actually appear in the emulator instance's memory, and writes to this region might not always have the desired effect. It is recommended to use [[GB_read_memory]] and [[GB_write_memory]] to access this region, when possible.
+Some MMIO registers will not appear in the `GB_DIRECT_ACCESS_IO` region in the same way they actually appear in the emulator instance's memory, and writes to this region might not always have the desired effect. It is recommended to use [[GB_read_memory]] and [[GB_write_memory]] to access this region when possible.
 
-Writes to `GB_DIRECT_ACCESS_IE` can have unexpected results and needs to be avoided.
+Writes to `GB_DIRECT_ACCESS_IE` can have unexpected results and need to be avoided.
 
 Writes to the `GB_DIRECT_ACCESS_BGP` and `GB_DIRECT_ACCESS_OBP` regions might not have an immediate visual effect.
 
@@ -58,4 +58,4 @@ Writes to the `GB_DIRECT_ACCESS_BGP` and `GB_DIRECT_ACCESS_OBP` regions might no
 
 * [[GB_read_memory]]
 * [[GB_safe_read_memory]]
-* [[GB_write_memory]]
\ No newline at end of file
+* [[GB_write_memory]]
diff --git a/GB_get_joyp_accessed.md b/GB_get_joyp_accessed.md
index b449452..12fd7d8 100644
--- a/GB_get_joyp_accessed.md
+++ b/GB_get_joyp_accessed.md
@@ -14,4 +14,4 @@ Return `true` if the JOYP/P1 register was read, directly (via a memory read) or
 
 ## See Also
 
-* [[GB_clear_joyp_accessed]]
\ No newline at end of file
+* [[GB_clear_joyp_accessed]]
diff --git a/GB_get_model.md b/GB_get_model.md
index 232b2b0..19bb380 100644
--- a/GB_get_model.md
+++ b/GB_get_model.md
@@ -20,4 +20,4 @@ Returns the currently emulated [[model|GB_model_t]] of an emulator instance.
 * [[GB_get_state_model]]
 * [[GB_is_cgb]]
 * [[GB_is_hle_sgb]]
-* [[GB_is_sgb]]
\ No newline at end of file
+* [[GB_is_sgb]]
diff --git a/GB_get_player_count.md b/GB_get_player_count.md
index b5a1574..ec309f9 100644
--- a/GB_get_player_count.md
+++ b/GB_get_player_count.md
@@ -6,7 +6,7 @@ In `sgb.h`
 
 ## Description
 
-Returns the current number of players in an emulated instance. When emulating a Super Game Boy, the emulated ROM can dynamically change the number of players to 1, 2 or 4.
+Returns the current number of players in an emulated instance. When emulating a Super Game Boy, the emulated ROM can dynamically change the number of players to 1, 2, or 4.
 
 ## Thread Safety
 
@@ -15,4 +15,4 @@ Returns the current number of players in an emulated instance. When emulating a
 ## See Also
 
 * [[GB_set_key_state_for_player]]
-* [[GB_set_key_mask_for_player]]
\ No newline at end of file
+* [[GB_set_key_mask_for_player]]
diff --git a/GB_get_registers.md b/GB_get_registers.md
index 1d3ae0d..ac7c66e 100644
--- a/GB_get_registers.md
+++ b/GB_get_registers.md
@@ -14,4 +14,4 @@ Returns a pointer to the [[register set|GB_registers_t]] of the emulator instanc
 
 ## See Also
 
-* [[GB_registers_t]]
\ No newline at end of file
+* [[GB_registers_t]]
diff --git a/GB_get_screen_width-and-GB_get_screen_height.md b/GB_get_screen_width-and-GB_get_screen_height.md
index 91de0f3..5b61180 100644
--- a/GB_get_screen_width-and-GB_get_screen_height.md
+++ b/GB_get_screen_width-and-GB_get_screen_height.md
@@ -8,7 +8,7 @@ In `display.h`
 
 ## Description
 
-These function return the dimensions of the video output of an emulator instance. The dimensions are affected by the [[emulated model|GB_model_t]] and the current [[border mode|GB_set_border_mode]] of the emulator instance, and can be either 160×144 or 256×224.
+These functions return the dimensions of the video output of an emulator instance. The dimensions are affected by the [[emulated model|GB_model_t]] and the current [[border mode|GB_set_border_mode]] of the emulator instance and can be either 160×144 or 256×224.
 
 ## Thread Safety
 
@@ -17,4 +17,4 @@ These function return the dimensions of the video output of an emulator instance
 ## See Also
 
 * [[GB_set_pixels_output]]
-* [[GB_set_border_mode]]
\ No newline at end of file
+* [[GB_set_border_mode]]
diff --git a/GB_get_state_model.md b/GB_get_state_model.md
index 6f0e4a5..aed5c4d 100644
--- a/GB_get_state_model.md
+++ b/GB_get_state_model.md
@@ -6,7 +6,7 @@ In `save_state.h`
 
 ## Description
 
-Retrieves the [[model|GB_model_t]] used by a a save state file stored under `path`. Populates `model` and returns 0 on success. Returns a positive `errno` value on a POSIX failure, and -1 on other failures.
+Retrieves the [[model|GB_model_t]] used by a save state file stored under `path`. Populates `model` and returns 0 on success. Returns a positive `errno` value on a POSIX failure and -1 on other failures.
 
 ## Thread Safety
 
diff --git a/GB_get_state_model_from_buffer.md b/GB_get_state_model_from_buffer.md
index eb8d1b4..a94df85 100644
--- a/GB_get_state_model_from_buffer.md
+++ b/GB_get_state_model_from_buffer.md
@@ -18,4 +18,4 @@ This function also works on save states created by other emulators if they follo
 
 ## See Also
 
-* [[GB_get_state_model]]
\ No newline at end of file
+* [[GB_get_state_model]]
diff --git a/GB_get_unmultiplied_clock_rate.md b/GB_get_unmultiplied_clock_rate.md
index 6f0b9aa..c0240a6 100644
--- a/GB_get_unmultiplied_clock_rate.md
+++ b/GB_get_unmultiplied_clock_rate.md
@@ -15,4 +15,4 @@ Returns the current clock rate of the emulator instance, in Hertz. The value ret
 ## See Also
 
 * [[GB_get_clock_rate]]
-* [[GB_set_clock_multiplier]]
\ No newline at end of file
+* [[GB_set_clock_multiplier]]
diff --git a/GB_is_cgb.md b/GB_is_cgb.md
index 9309660..7073e87 100644
--- a/GB_is_cgb.md
+++ b/GB_is_cgb.md
@@ -17,4 +17,4 @@ Returns `true` if the emulator instance currently emulates a Game Boy Color or a
 * [[GB_model_t]]
 * [[GB_get_model]]
 * [[GB_is_hle_sgb]]
-* [[GB_is_sgb]]
\ No newline at end of file
+* [[GB_is_sgb]]
diff --git a/GB_is_cgb_in_cgb_mode.md b/GB_is_cgb_in_cgb_mode.md
index 74805e6..9153705 100644
--- a/GB_is_cgb_in_cgb_mode.md
+++ b/GB_is_cgb_in_cgb_mode.md
@@ -12,6 +12,6 @@ Returns `true` if the emulator instance currently emulates a Game Boy Color or a
 
 `GB_is_cgb_in_cgb_mode` is thread-safe and can be called from any thread and context.
 
-## See Also 
+## See Also
 
-* [[GB_is_cgb]]
\ No newline at end of file
+* [[GB_is_cgb]]
diff --git a/GB_is_hle_sgb.md b/GB_is_hle_sgb.md
index 7506bfc..78cc874 100644
--- a/GB_is_hle_sgb.md
+++ b/GB_is_hle_sgb.md
@@ -6,7 +6,7 @@ In `gb.h`
 
 ## Description
 
-Returns `true` if the emulator instance emulates a variant of the Super Game Boy, and also emulates the SFC or SNES side via high-level-emulation.
+Returns `true` if the emulator instance emulates a variant of the Super Game Boy and also emulates the SFC or SNES side via high-level emulation.
 
 ## Thread Safety
 
@@ -17,4 +17,4 @@ Returns `true` if the emulator instance emulates a variant of the Super Game Boy
 * [[GB_model_t]]
 * [[GB_get_model]]
 * [[GB_is_sgb]]
-* [[GB_is_cgb]]
\ No newline at end of file
+* [[GB_is_cgb]]
diff --git a/GB_is_save_state.md b/GB_is_save_state.md
index 051a2f7..d96a99f 100644
--- a/GB_is_save_state.md
+++ b/GB_is_save_state.md
@@ -6,7 +6,7 @@ In `save_state.h`
 
 ## Description
 
-Returns `true` if the file at `path` contains a SameBoy or [BESS](https://github.com/LIJI32/SameBoy/blob/master/BESS.md) save state. 
+Returns `true` if the file at `path` contains a SameBoy or [BESS](https://github.com/LIJI32/SameBoy/blob/master/BESS.md) save state.
 
 ## Thread Safety
 
@@ -19,4 +19,4 @@ This function merely checks for header and footer magic values, it does not guar
 ## See Also
 
 * [[GB_get_state_model]]
-* [[GB_get_state_model_from_buffer]]
\ No newline at end of file
+* [[GB_get_state_model_from_buffer]]
diff --git a/GB_is_sgb.md b/GB_is_sgb.md
index b6aed38..07b15df 100644
--- a/GB_is_sgb.md
+++ b/GB_is_sgb.md
@@ -17,4 +17,4 @@ Returns `true` if the emulator instance emulates any variant of the Super Game B
 * [[GB_model_t]]
 * [[GB_get_model]]
 * [[GB_is_hle_sgb]]
-* [[GB_is_cgb]]
\ No newline at end of file
+* [[GB_is_cgb]]
diff --git a/GB_key_mask_t.md b/GB_key_mask_t.md
index 49c3f9e..07f74db 100644
--- a/GB_key_mask_t.md
+++ b/GB_key_mask_t.md
@@ -11,17 +11,15 @@ typedef enum {
     GB_KEY_SELECT_MASK = 1 << <a href="GB_key_t.md">GB_KEY_SELECT</a>,
     GB_KEY_START_MASK = 1 << <a href="GB_key_t.md">GB_KEY_START</a>,
 } GB_key_mask_t;
-
-#define GB_MASK_FOR_PLAYER(mask, player) ((x) << (player * 8))
 </pre>
 
 In `joypad.h`
 
 ## Description
 
-An enum representing each of the 8 buttons of a Game Boy as a mask value. Multiple values can be combine with `|` and used with functions such as [[GB_set_key_mask]].
+An enum representing each of the 8 buttons of a Game Boy as a mask value. Multiple values can be combined with `|` and used with functions such as [[GB_set_key_mask]].
 
 ## See Also
 
 * [[GB_set_key_mask]]
-* [[GB_set_key_mask_for_player]]
\ No newline at end of file
+* [[GB_set_key_mask_for_player]]
diff --git a/GB_key_t.md b/GB_key_t.md
index 0a91210..303ab27 100644
--- a/GB_key_t.md
+++ b/GB_key_t.md
@@ -23,4 +23,4 @@ An enum representing each of the 8 buttons of a Game Boy, for use with functions
 ## See Also
 
 * [[GB_set_key_state]]
-* [[GB_set_key_state_for_player]]
\ No newline at end of file
+* [[GB_set_key_state_for_player]]
diff --git a/GB_load_battery.md b/GB_load_battery.md
index 6037549..d075561 100644
--- a/GB_load_battery.md
+++ b/GB_load_battery.md
@@ -6,7 +6,7 @@ In `gb.h`
 
 ## Description
 
-Loads battery-backed information (e.g. battery-powered cartridge RAM or Real Time Clock information) from the file at `path` into the emulator instance. Return `0` on success and a positive value for `POSIX` failures`.
+Loads battery-backed information (e.g. battery-powered cartridge RAM or Real-Time Clock information) from the file at `path` into the emulator instance. Returns `0` on success and a positive value for POSIX failures.
 
 ## Thread Safety
 
@@ -14,9 +14,9 @@ Loads battery-backed information (e.g. battery-powered cartridge RAM or Real Tim
 
 ## Notes
 
-This function does not considered truncated files as failures. SameBoy battery saves are compatible with most other emulators and vice versa.
+This function does not consider truncated files as failures. SameBoy battery saves are compatible with most other emulators and vice versa.
 
 ## See Also
 
 * [[GB_load_battery_from_buffer]]
-* [[GB_save_battery]]
\ No newline at end of file
+* [[GB_save_battery]]
diff --git a/GB_load_battery_from_buffer.md b/GB_load_battery_from_buffer.md
index f8a222b..6c5e93e 100644
--- a/GB_load_battery_from_buffer.md
+++ b/GB_load_battery_from_buffer.md
@@ -6,7 +6,7 @@ In `gb.h`
 
 ## Description
 
-Loads battery-backed information (e.g. battery-powered cartridge RAM or Real Time Clock information) from `buffer` with length `size` into the emulator instance. This function never fails, and will load partial information if the buffer isn't large enough.
+Loads battery-backed information (e.g., battery-powered cartridge RAM or Real-Time Clock information) from `buffer` with a length of `size` into the emulator instance. This function never fails and will load partial information if the buffer is not large enough.
 
 ## Thread Safety
 
@@ -14,9 +14,9 @@ Loads battery-backed information (e.g. battery-powered cartridge RAM or Real Tim
 
 ## Notes
 
-SameBoy battery saves are compatible with most other emulators and vice versa.
+SameBoy battery saves are compatible with most other emulators, and vice versa.
 
 ## See Also
 
 * [[GB_load_battery]]
-* [[GB_save_battery_to_buffer]]
\ No newline at end of file
+* [[GB_save_battery_to_buffer]]
diff --git a/GB_load_boot_rom_from_buffer.md b/GB_load_boot_rom_from_buffer.md
index 1ced508..4e4fd50 100644
--- a/GB_load_boot_rom_from_buffer.md
+++ b/GB_load_boot_rom_from_buffer.md
@@ -15,4 +15,4 @@ Loads a boot ROM from a file into an emulator instance. If you're not using [[GB
 ## See Also
 
 * [[GB_set_boot_rom_load_callback]]
-* [[GB_load_boot_rom]]
\ No newline at end of file
+* [[GB_load_boot_rom]]
diff --git a/GB_load_gbs.md b/GB_load_gbs.md
index ea05d85..32bbbc2 100644
--- a/GB_load_gbs.md
+++ b/GB_load_gbs.md
@@ -24,4 +24,4 @@ After loading a GBS file, you must call [[GB_gbs_switch_track]] to specify the t
 * [[GB_gbs_info_t]]
 * [[GB_gbs_switch_track]]
 * [[GB_load_rom]]
-* [[GB_load_isx]]
\ No newline at end of file
+* [[GB_load_isx]]
diff --git a/GB_load_rom_from_buffer.md b/GB_load_rom_from_buffer.md
index 020ea18..243fa46 100644
--- a/GB_load_rom_from_buffer.md
+++ b/GB_load_rom_from_buffer.md
@@ -15,4 +15,4 @@ Loads ROM data into an emulator instance. Warning messages may be output to the
 ## See Also 
 
 * [[GB_load_rom]]
-* [[GB_load_gbs_from_buffer]]
\ No newline at end of file
+* [[GB_load_gbs_from_buffer]]
diff --git a/GB_load_state.md b/GB_load_state.md
index 9fd9295..aac5019 100644
--- a/GB_load_state.md
+++ b/GB_load_state.md
@@ -14,11 +14,11 @@ Loads a snapshot of an emulation state of the emulator instance from `path`. Ret
 
 ## Notes
 
-SameBoy follows the [BESS](https://github.com/LIJI32/SameBoy/blob/master/BESS.md) specification, and will load save states from other BESS-compliant emulators.
+SameBoy follows the [BESS](https://github.com/LIJI32/SameBoy/blob/master/BESS.md) specification and will load save states from other BESS-compliant emulators.
 
 Loading a save state will fail if [[the save state's model|GB_get_state_model]] is from a different [[model family|GB_model_t]]. Loading a save state from a different model in the same model family will not change the current model in the emulator instance. If this behavior is not desired, call [[GB_switch_model_and_reset]] with [[the correct model|GB_get_state_model]] before loading the save state.
 
 ## See Also
 
 * [[GB_load_state_from_buffer]]
-* [[GB_save_state]]
\ No newline at end of file
+* [[GB_save_state]]
diff --git a/GB_load_state_from_buffer.md b/GB_load_state_from_buffer.md
index bcf35bc..c242370 100644
--- a/GB_load_state_from_buffer.md
+++ b/GB_load_state_from_buffer.md
@@ -6,7 +6,7 @@ In `save_state.h`
 
 ## Description
 
-Loads a snapshot of an emulation state of the emulator instance from `buffer` with size `length`. Returns `0` on success, `EIO if the buffer is too short, and `-1` on other failures. Detailed error messages will be written to the [[log|GB_set_log_callback]] on failure.
+Loads a snapshot of an emulation state of the emulator instance from `buffer` with size `length`. Returns `0` on success, `EIO` if the buffer is too short, and `-1` on other failures. Detailed error messages will be written to the [[log|GB_set_log_callback]] on failure.
 
 ## Thread Safety
 
@@ -14,11 +14,11 @@ Loads a snapshot of an emulation state of the emulator instance from `buffer` wi
 
 ## Notes
 
-SameBoy follows the [BESS](https://github.com/LIJI32/SameBoy/blob/master/BESS.md) specification, and will load save states from other BESS-compliant emulators.
+SameBoy follows the [BESS](https://github.com/LIJI32/SameBoy/blob/master/BESS.md) specification and will load save states from other BESS-compliant emulators.
 
 Loading a save state will fail if [[the save state's model|GB_get_state_model_from_buffer]] is from a different [[model family|GB_model_t]]. Loading a save state from a different model in the same model family will not change the current model in the emulator instance. If this behavior is not desired, call [[GB_switch_model_and_reset]] with [[the correct model|GB_get_state_model_from_buffer]] before loading the save state.
 
 ## See Also
 
 * [[GB_load_state]]
-* [[GB_save_state_to_buffer]]
\ No newline at end of file
+* [[GB_save_state_to_buffer]]
diff --git a/GB_log.md b/GB_log.md
index 099b3bc..ea302f7 100644
--- a/GB_log.md
+++ b/GB_log.md
@@ -6,7 +6,7 @@ In `gb.h`
 
 ## Description
 
-A convenient function used to log formatted string (following `printf` semantics) through an emulator instance's [[log callback|GB_set_log_callback]]. Calling this function is equivalent to calling [[GB_attributed_log]] with the `attributes` argument passed as `0`.
+A convenient function used to log a formatted string (following `printf` semantics) through an emulator instance's [[log callback|GB_set_log_callback]]. Calling this function is equivalent to calling [[GB_attributed_log]] with the `attributes` argument passed as `0`.
 
 ## Thread Safety
 
@@ -15,4 +15,4 @@ A convenient function used to log formatted string (following `printf` semantics
 ## See Also
 
 * [[GB_attributed_log]]
-* [[GB_set_log_callback]]
\ No newline at end of file
+* [[GB_set_log_callback]]
diff --git a/GB_log_attributes_t.md b/GB_log_attributes_t.md
index 4244ea4..544aa5b 100644
--- a/GB_log_attributes_t.md
+++ b/GB_log_attributes_t.md
@@ -5,7 +5,7 @@ typedef enum {
     GB_LOG_BOLD = 1,
     GB_LOG_DASHED_UNDERLINE = 2,
     GB_LOG_UNDERLINE = 4,
-    GB_LOG_UNDERLINE_MASK =  GB_LOG_DASHED_UNDERLINE | GB_LOG_UNDERLINE
+    GB_LOG_UNDERLINE_MASK = GB_LOG_DASHED_UNDERLINE | GB_LOG_UNDERLINE
 } GB_log_attributes_t;
 ```
 
@@ -18,4 +18,4 @@ A bitfield of string attributes denoting the style of a string delivered to the
 ## See Also
 
 * [[GB_set_log_callback]]
-* [[GB_attributed_log]]
\ No newline at end of file
+* [[GB_attributed_log]]
diff --git a/GB_model_t.md b/GB_model_t.md
index b9433c9..b93390b 100644
--- a/GB_model_t.md
+++ b/GB_model_t.md
@@ -44,30 +44,28 @@ In `model.h`
 
 ## Description
 
-Each value in this enum represents a Game Boy model and SOC revision that can be passed to [[GB_init]] or [[GB_switch_model_and_reset]]. Commented out values are currently not supported, and have their values reserved for future use.
+Each value in this enum represents a Game Boy model and SOC revision that can be passed to [[GB_init]] or [[GB_switch_model_and_reset]]. Commented-out values are currently not supported and have their values reserved for future use.
 
 The values in this enum are:
 
-* `GB_MODEL_DMG_*`: A SOC revision of an original Game Boy
-* `GB_MODEL_SGB` and `GB_MODEL_SGB_NTSC`: A Super Game Boy SOC inside a high-level-emulated SFC or NTSC SNES
-* `GB_MODEL_SGB_PAL`: A Super Game Boy SOC inside a high-level-emulated PAL SNES
-* `GB_MODEL_SGB_NO_SFC` and `GB_MODEL_SGB_NTSC_NO_SFC`: A Super Game Boy SOC, for used with integration with SFC or NTSC SNES emulators
-* `GB_MODEL_SGB_PAL_NO_SFC`: A Super Game Boy SOC, for used with integration with PAL SNES emulators
-* `GB_MODEL_SGB2`: A Super Game Boy 2 SOC inside a high-level-emulated SFC or SNES
-* `GB_MODEL_SGB2_NO_SFC`: A Super Game Boy 2 SOC, for used with integration with SFC or SNES emulators
-* `GB_MODEL_MGB`: A Game Boy Pocket SOC, also found in a Game Boy Light
+* `GB_MODEL_DMG_*`: A SOC revision of an original Game Boy.
+* `GB_MODEL_SGB` and `GB_MODEL_SGB_NTSC`: A Super Game Boy SOC inside a high-level-emulated SFC or NTSC SNES.
+* `GB_MODEL_SGB_PAL`: A Super Game Boy SOC inside a high-level-emulated PAL SNES.
+* `GB_MODEL_SGB_NO_SFC` and `GB_MODEL_SGB_NTSC_NO_SFC`: A Super Game Boy SOC, for use with integration with SFC or NTSC SNES emulators.
+* `GB_MODEL_SGB_PAL_NO_SFC`: A Super Game Boy SOC, for use with integration with PAL SNES emulators.
+* `GB_MODEL_SGB2`: A Super Game Boy 2 SOC inside a high-level-emulated SFC or SNES.
+* `GB_MODEL_SGB2_NO_SFC`: A Super Game Boy 2 SOC, for use with integration with SFC or SNES emulators.
+* `GB_MODEL_MGB`: A Game Boy Pocket SOC, also found in a Game Boy Light.
 * `GB_MODEL_CGB_*`: A SOC revision of a Game Boy Color. The recommended revision is `GB_MODEL_CGB_E`.
 * `GB_MODEL_AGB_*`: A SOC revision of a Game Boy Advance.
-* `GB_MODEL_GBP_*`: A SOC revision of a Game Boy Advance inside a Game Boy Player
+* `GB_MODEL_GBP_*`: A SOC revision of a Game Boy Advance inside a Game Boy Player.
 
-
-Additionally, the following macros can extract properties from a `GB_model_t` value:
 * `GB_MODEL_FAMILY_MASK`: Use this mask to extract the model family of a `GB_model_t` value:
- * `GB_MODEL_DMG_FAMILY`: This model belongs to the original Game Boy and Super Game Boy line of SOCs
- * `GB_MODEL_MGB_FAMILY`: This model belongs to the Game Boy Pocket and Super Game Boy 2 line of SOCs
- * `GB_MODEL_CGB_FAMILY`: This model belongs to the Game Boy Color or Game Boy Advance lines of SOCs
-* `GB_MODEL_GBP_BIT`: This bit will be set if this model is a Game Boy Advance SOC in a Game Boy Player
-* `GB_MODEL_PAL_BIT`: This bit will be set if this model is a Super Game Boy inside a PAL console
+ * `GB_MODEL_DMG_FAMILY`: This model belongs to the original Game Boy and Super Game Boy line of SOCs.
+ * `GB_MODEL_MGB_FAMILY`: This model belongs to the Game Boy Pocket and Super Game Boy 2 line of SOCs.
+ * `GB_MODEL_CGB_FAMILY`: This model belongs to the Game Boy Color or Game Boy Advance lines of SOCs.
+* `GB_MODEL_GBP_BIT`: This bit will be set if this model is a Game Boy Advance SOC in a Game Boy Player.
+* `GB_MODEL_PAL_BIT`: This bit will be set if this model is a Super Game Boy inside a PAL console.
 * `GB_MODEL_NO_SFC_BIT`: This bit will be set if this model is a Super Game Boy that delegates emulation of the SFC or SNES side to outside of the core.
 
 ## See Also
@@ -77,4 +75,4 @@ Additionally, the following macros can extract properties from a `GB_model_t` va
 * [[GB_get_state_model]]
 * [[GB_is_cgb]]
 * [[GB_is_hle_sgb]]
-* [[GB_is_sgb]]
\ No newline at end of file
+* [[GB_is_sgb]]
diff --git a/GB_palette_t.md b/GB_palette_t.md
index c283ae2..7513845 100644
--- a/GB_palette_t.md
+++ b/GB_palette_t.md
@@ -12,9 +12,9 @@ In `display.h`
 
 ## Description
 
-A structure describing a color palette, used for rendering the screen of a monochrome [[model|GB_model_t]]. The first 4 colors represent the 4 different shades of grey (or green) rendered by a Game Boy LCD, with the first color being the darkest and the last color being the lightest. The 5th color is used when rendering a turned off LCD.
+A structure describing a color palette, used for rendering the screen of a monochrome [[model|GB_model_t]]. The first 4 colors represent the 4 different shades of grey (or green) rendered by a Game Boy LCD, with the first color being the darkest and the last color being the lightest. The 5th color is used when rendering a turned-off LCD.
 
 ## See Also
 
 * [[GB_set_palette and GB_get_palette]]
-* [[Built‐In DMG Palettes]]
\ No newline at end of file
+* [[Built‐In DMG Palettes]]
diff --git a/GB_random_seed.md b/GB_random_seed.md
index a5f2ef5..384a1fc 100644
--- a/GB_random_seed.md
+++ b/GB_random_seed.md
@@ -6,7 +6,7 @@ In `random.h`
 
 ## Description
 
-Sets the current random seed to a specific 64-bit value, which will be used when an emulator instance is [[initialized|Instance Allocation]] or [[reset|GB_reset]]. This function can be used to force a newly reset or initialized emulator instance to a specific state. 
+Sets the current random seed to a specific 64-bit value, which will be used when an emulator instance is [[initialized|Instance Allocation]] or [[reset|GB_reset]]. This function can be used to force a newly reset or initialized emulator instance to a specific state.
 
 
 ## Thread Safety
@@ -19,4 +19,4 @@ The seed is automatically initialized on process launch to a value based on the
 
 ## See Also
 
-* [[GB_random_set_enabled]]
\ No newline at end of file
+* [[GB_random_set_enabled]]
diff --git a/GB_random_set_enabled.md b/GB_random_set_enabled.md
index 75e4ad0..b9692fe 100644
--- a/GB_random_set_enabled.md
+++ b/GB_random_set_enabled.md
@@ -14,8 +14,8 @@ When an emulator instance is [[initialized|Instance Allocation]] or [[reset|GB_r
 
 ## Notes
 
-This setting is global, and will affect all emulator instances in the process.
+This setting is global and will affect all emulator instances in the process.
 
 ## See Also
 
-* [[GB_random_seed]]
\ No newline at end of file
+* [[GB_random_seed]]
diff --git a/GB_read_memory.md b/GB_read_memory.md
index 7240771..a0c77e6 100644
--- a/GB_read_memory.md
+++ b/GB_read_memory.md
@@ -6,7 +6,7 @@ In `memory.h`
 
 ## Description
 
-Performs a memory read on a 16-bit address on the emulator instance, as if it was performed by the SM83 CPU, and returns the 8-bit read value.
+Performs a memory read on a 16-bit address on the emulator instance, as if it were performed by the SM83 CPU, and returns the 8-bit read value.
 
 ## Thread Safety
 
@@ -14,12 +14,12 @@ Performs a memory read on a 16-bit address on the emulator instance, as if it wa
 
 ## Notes
 
-To read data outside of a currently mapped bank, or to read from a memory region that might not be currently readable (e.g. VRAM during mode 3), you can use [[GB_get_direct_access]].
+To read data outside of a currently mapped bank, or to read from a memory region that might not be currently readable (e.g., VRAM during mode 3), you can use [[GB_get_direct_access]].
 
-Because this functions goes through the same routines used by a CPU memory read, it will trigger any side effect caused by a memory read, including, for example, OAM corruption. If you wish you avoid this behavior, you can use either [[GB_safe_read_memory]] or [[GB_get_direct_access]].
+Because this function goes through the same routines used by a CPU memory read, it will trigger any side effect caused by a memory read, including, for example, OAM corruption. If you wish to avoid this behavior, you can use either [[GB_safe_read_memory]] or [[GB_get_direct_access]].
 
 ## See Also
 
 * [[GB_safe_read_memory]]
 * [[GB_write_memory]]
-* [[GB_get_direct_access]]
\ No newline at end of file
+* [[GB_get_direct_access]]
diff --git a/GB_registers_t.md b/GB_registers_t.md
index 0049173..4d814e3 100644
--- a/GB_registers_t.md
+++ b/GB_registers_t.md
@@ -69,4 +69,4 @@ A structure that represents the internal state of the SM83 CPU in an emulator co
 
 ## See Also
 
-* [[GB_get_registers]]
\ No newline at end of file
+* [[GB_get_registers]]
diff --git a/GB_reset.md b/GB_reset.md
index 041f5a9..3a2fd07 100644
--- a/GB_reset.md
+++ b/GB_reset.md
@@ -16,4 +16,4 @@ This function emulates a power cycle in an emulator instance. All internal RAM t
 
 * [[GB_quick_reset]]
 * [[GB_switch_model_and_reset]]
-* [[GB_random_set_enabled]]
\ No newline at end of file
+* [[GB_random_set_enabled]]
diff --git a/GB_rewind_pop.md b/GB_rewind_pop.md
index 69d581e..7dfd853 100644
--- a/GB_rewind_pop.md
+++ b/GB_rewind_pop.md
@@ -20,4 +20,3 @@ Rewinding a frame will not re-render the popped frame or call the [[vblank callb
 
 * [[GB_set_rewind_length]]
 * [[GB_rewind_reset]]
-
diff --git a/GB_rewind_reset.md b/GB_rewind_reset.md
index b97a30b..1eac05c 100644
--- a/GB_rewind_reset.md
+++ b/GB_rewind_reset.md
@@ -14,9 +14,9 @@ Clears the current contents of the emulator instance's rewind buffer.
 
 ## Note
 
-You should call this function after performing changes that invalidate the internal save states in the rewind buffer, such as hot-swapping into an incompatible ROM. This function can be implicitly called by other APIs if such change is detected.
+You should call this function after performing changes that invalidate the internal save states in the rewind buffer, such as hot-swapping into an incompatible ROM. This function can be implicitly called by other APIs if such changes are detected.
 
 ## See Also
 
 * [[GB_set_rewind_length]]
-* [[GB_rewind_pop]]
\ No newline at end of file
+* [[GB_rewind_pop]]
diff --git a/GB_run.md b/GB_run.md
index 7768e05..eceb9d2 100644
--- a/GB_run.md
+++ b/GB_run.md
@@ -6,7 +6,7 @@ In `gb.h`
 
 ## Description
 
-Runs an emulator instance for an atomic amount of time (usually a single instruction). Returns the number of time passed, in units of 8MHz (8,388,608Hz) ticks. If SameBoy was not compiled with time keeping disabled, and [[turbo mode|GB_set_turbo_mode]] was not enabled, this function can potentially sleep before returning to keep a correct frame rate.
+Runs an emulator instance for an atomic amount of time (usually a single instruction). Returns the number of time passed, in units of 8MHz (8,388,608Hz) ticks. If SameBoy was not compiled with timekeeping disabled, and [[turbo mode|GB_set_turbo_mode]] was not enabled, this function can potentially sleep before returning to maintain a correct frame rate.
 
 ## Thread Safety
 
@@ -14,4 +14,4 @@ Runs an emulator instance for an atomic amount of time (usually a single instruc
 
 ## See Also
 * [[GB_run_frame]]
-* [[GB_set_turbo_mode]]
\ No newline at end of file
+* [[GB_set_turbo_mode]]
diff --git a/GB_run_frame.md b/GB_run_frame.md
index cb4e7ca..757072f 100644
--- a/GB_run_frame.md
+++ b/GB_run_frame.md
@@ -6,7 +6,7 @@ In `gb.h`
 
 ## Description
 
-Runs an emulator instance until a [[vblank callback|GB_set_vblank_callback]] is called. Returns the number of time passed, in units of 8MHz (8,388,608Hz) ticks. Unlike [[GB_run]], this function does not handle time keeping, and will not sleep.
+Runs an emulator instance until a [[vblank callback|GB_set_vblank_callback]] is called. Returns the number of time passed, in units of 8MHz (8,388,608Hz) ticks. Unlike [[GB_run]], this function does not handle timekeeping and will not sleep.
 
 ## Thread Safety
 
@@ -15,4 +15,4 @@ Runs an emulator instance until a [[vblank callback|GB_set_vblank_callback]] is
 ## See Also
 
 * [[GB_run]]
-* [[GB_set_vblank_callback]]
\ No newline at end of file
+* [[GB_set_vblank_callback]]
diff --git a/GB_safe_read_memory.md b/GB_safe_read_memory.md
index 3cd7f03..4e1bb0b 100644
--- a/GB_safe_read_memory.md
+++ b/GB_safe_read_memory.md
@@ -6,7 +6,7 @@ In `memory.h`
 
 ## Description
 
-Performs a memory read on a 16-bit address on the emulator instance and returns the 8-bit read value, while avoiding side-effects that would occur of the CPU was to perform the same read.
+Performs a memory read on a 16-bit address in the emulator instance and returns the 8-bit read value, while avoiding side effects that would occur if the CPU were to perform the same read.
 
 ## Thread Safety
 
@@ -14,10 +14,10 @@ Performs a memory read on a 16-bit address on the emulator instance and returns
 
 ## Notes
 
-To read data outside of a currently mapped bank, or to read from a memory region that might not be currently readable (e.g. VRAM during mode 3), you can use [[GB_get_direct_access]].
+To read data outside of a currently mapped bank, or to read from a memory region that might not be currently readable (e.g., VRAM during mode 3), you can use [[GB_get_direct_access]].
 
 ## See Also
 
 * [[GB_read_memory]]
 * [[GB_write_memory]]
-* [[GB_get_direct_access]]
\ No newline at end of file
+* [[GB_get_direct_access]]
diff --git a/GB_sample_t.md b/GB_sample_t.md
index f15406c..6663164 100644
--- a/GB_sample_t.md
+++ b/GB_sample_t.md
@@ -12,9 +12,9 @@ In `apu.h`
 
 ## Description
 
-A struct representing a single stereo sample, in signed 16-bit format.
+A struct representing a single stereo sample in signed 16-bit format.
 
 ## See Also
 
 * [[GB_apu_set_sample_callback]]
-* [[GB_set_sample_rate]]
\ No newline at end of file
+* [[GB_set_sample_rate]]
diff --git a/GB_save_battery.md b/GB_save_battery.md
index 42ca702..4e6abd1 100644
--- a/GB_save_battery.md
+++ b/GB_save_battery.md
@@ -6,7 +6,7 @@ In `gb.h`
 
 ## Description
 
-Saves battery-backed information (e.g. battery-powered cartridge RAM or Real Time Clock information) from the emulator instance into the file at `path`. Returns `0` on success and a positive `errno` value on POSIX failures. Will do nothing and return `0` if the currently loaded ROM has no battery-backed information.
+Saves battery-backed information (e.g., battery-powered cartridge RAM or Real-Time Clock information) from the emulator instance into the file at `path`. Returns `0` on success and a positive `errno` value on POSIX failures. It will do nothing and return `0` if the currently loaded ROM has no battery-backed information.
 
 ## Thread Safety
 
@@ -15,4 +15,4 @@ Saves battery-backed information (e.g. battery-powered cartridge RAM or Real Tim
 ## See Also
 
 * [[GB_load_battery]]
-* [[GB_save_battery_to_buffer]]
\ No newline at end of file
+* [[GB_save_battery_to_buffer]]
diff --git a/GB_save_battery_size.md b/GB_save_battery_size.md
index e4cdd32..9548a90 100644
--- a/GB_save_battery_size.md
+++ b/GB_save_battery_size.md
@@ -6,7 +6,7 @@ In `gb.h`
 
 ## Description
 
-Returns the battery-backed save size required by the emulator instance's currently loaded ROM, which may be 0. For use with [[GB_save_battery_to_buffer]].
+Returns the battery-backed save size required by the emulator instance's currently loaded ROM, which may be 0. This function is used with [[GB_save_battery_to_buffer]].
 
 ## Thread Safety
 
@@ -15,4 +15,4 @@ Returns the battery-backed save size required by the emulator instance's current
 
 ## See Also
 
-* [[GB_save_battery_to_buffer]]
\ No newline at end of file
+* [[GB_save_battery_to_buffer]]
diff --git a/GB_save_battery_to_buffer.md b/GB_save_battery_to_buffer.md
index 37eaa32..8e67f19 100644
--- a/GB_save_battery_to_buffer.md
+++ b/GB_save_battery_to_buffer.md
@@ -6,7 +6,7 @@ In `gb.h`
 
 ## Description
 
-Saves battery-backed information (e.g. battery-powered cartridge RAM or Real Time Clock information) from the emulator instance into `buffer`. Returns `0` on success and `EIO` if `size` is less than the value returned by [[GB_save_battery_size]].
+Saves battery-backed information (e.g. battery-powered cartridge RAM or Real-Time Clock information) from the emulator instance into `buffer`. Returns `0` on success and `EIO` if `size` is less than the value returned by [[GB_save_battery_size]].
 
 ## Thread Safety
 
@@ -16,4 +16,4 @@ Saves battery-backed information (e.g. battery-powered cartridge RAM or Real Tim
 
 * [[GB_save_battery_size]]
 * [[GB_load_battery_from_buffer]]
-* [[GB_save_battery]]
\ No newline at end of file
+* [[GB_save_battery]]
diff --git a/GB_save_state.md b/GB_save_state.md
index 7fad2a9..d953870 100644
--- a/GB_save_state.md
+++ b/GB_save_state.md
@@ -14,9 +14,9 @@ Saves a snapshot of the current emulation state of the emulator instance into `p
 
 ## Notes
 
-SameBoy follows the [BESS](https://github.com/LIJI32/SameBoy/blob/master/BESS.md) specification, and generates save states compatible with other BESS-compliant emulators.
+SameBoy follows the [BESS](https://github.com/LIJI32/SameBoy/blob/master/BESS.md) specification and generates save states compatible with other BESS-compliant emulators.
 
 ## See Also
 
 * [[GB_save_state_to_buffer]]
-* [[GB_load_state]]
\ No newline at end of file
+* [[GB_load_state]]
diff --git a/GB_save_state_to_buffer.md b/GB_save_state_to_buffer.md
index 7aa74e5..aeef70a 100644
--- a/GB_save_state_to_buffer.md
+++ b/GB_save_state_to_buffer.md
@@ -14,9 +14,9 @@ Saves a snapshot of the current emulation state of the emulator instance into `b
 
 ## Notes
 
-SameBoy follows the [BESS](https://github.com/LIJI32/SameBoy/blob/master/BESS.md) specification, and generates save states compatible with other BESS-compliant emulators.
+SameBoy follows the [BESS](https://github.com/LIJI32/SameBoy/blob/master/BESS.md) specification and generates save states compatible with other BESS-compliant emulators.
 
 ## See Also
 
 * [[GB_save_state]]
-* [[GB_load_state_from_buffer]]
\ No newline at end of file
+* [[GB_load_state_from_buffer]]
diff --git a/GB_set_allow_illegal_inputs.md b/GB_set_allow_illegal_inputs.md
index 8464ce5..a468463 100644
--- a/GB_set_allow_illegal_inputs.md
+++ b/GB_set_allow_illegal_inputs.md
@@ -6,7 +6,7 @@ In `joypad.h`
 
 ## Description
 
-A Super Game Boy and Game Boy Player forbid pressing opposing directional buttons (Up + Down or Left + Right) together via software, while other models have their shells physically built to make such button combinations impossible. By default, trying to input these illegal combinations will cause the emulator instance to drop one of the inputs. Use this function to disable this behavior.
+Super Game Boy and Game Boy Player forbid pressing opposing directional buttons (Up + Down or Left + Right) together via software, while other models have their shells physically built to make such button combinations impossible. By default, trying to input these illegal combinations will cause the emulator instance to drop one of the inputs. Use this function to disable this behavior.
 
 ## Thread Safety
 
@@ -14,4 +14,4 @@ A Super Game Boy and Game Boy Player forbid pressing opposing directional button
 
 ## Notes
 
-Some commercial games are known to crash when illegal inputs are made.
\ No newline at end of file
+Some commercial games are known to crash when illegal inputs are made.
diff --git a/GB_set_boot_rom_load_callback.md b/GB_set_boot_rom_load_callback.md
index 294e125..c3ca4b9 100644
--- a/GB_set_boot_rom_load_callback.md
+++ b/GB_set_boot_rom_load_callback.md
@@ -23,7 +23,7 @@ In `gb.h`
 
 ## Description
 
-Sets an optional, but recommended callback that lets the emulator instance request a specific boot ROM. This callback is required to allow the `GB_BORDER_ALWAYS` [[border mode|GB_set_border_mode]] to use Super Game Boy borders while emulating a non-Super Game Boy model. When the callback is called, the callee must call either [[GB_load_boot_rom]] or [[GB_load_boot_rom_from_buffer]] to load a suitable boot ROM before returning.
+Sets an optional but recommended callback that lets the emulator instance request a specific boot ROM. This callback is required to allow the `GB_BORDER_ALWAYS` [[border mode|GB_set_border_mode]] to use Super Game Boy borders while emulating a non-Super Game Boy model. When the callback is called, the callee must call either [[GB_load_boot_rom]] or [[GB_load_boot_rom_from_buffer]] to load a suitable boot ROM before returning.
 
 The possible values for `GB_boot_rom_t` are:
 * `GB_BOOT_ROM_DMG_0`: A boot ROM for the original DMG revision, usually saved as `dmg0_boot.bin`
@@ -34,9 +34,9 @@ The possible values for `GB_boot_rom_t` are:
 * `GB_BOOT_ROM_CGB_0`: A boot ROM for the original CGB revision, usually saved as `cgb0_boot.bin`
 * `GB_BOOT_ROM_CGB`: A boot ROM for the CGB revisions A to D, usually saved as `cgb_boot.bin`
 * `GB_BOOT_ROM_CGB_E`: A boot ROM for CGB revision E, usually saved as `cgbE_boot.bin`
-  * If this boot ROM revision is not available, the callback can safely fall-back to treating this value as `GB_BOOT_ROM_CGB`.
+  * If this boot ROM revision is not available, the callback can safely fall back to treating this value as `GB_BOOT_ROM_CGB`.
 * `GB_BOOT_ROM_AGB_0`: A boot ROM for the original AGB revision, usually saved as `agb0_boot.bin`
-  * If this boot ROM revision is not available, the callback can safely fall-back to treating this value as `GB_BOOT_ROM_AGB`.
+  * If this boot ROM revision is not available, the callback can safely fall back to treating this value as `GB_BOOT_ROM_AGB`.
 * `GB_BOOT_ROM_AGB`: A boot ROM for all other AGB revisions, usually saved as `agb_boot.bin`
 
 ## Thread Safety
@@ -45,4 +45,4 @@ The possible values for `GB_boot_rom_t` are:
 
 ## See Also
 * [[GB_load_boot_rom]]
-* [[GB_load_boot_rom_from_buffer]]
\ No newline at end of file
+* [[GB_load_boot_rom_from_buffer]]
diff --git a/GB_set_clock_multiplier.md b/GB_set_clock_multiplier.md
index 914e430..b185ef8 100644
--- a/GB_set_clock_multiplier.md
+++ b/GB_set_clock_multiplier.md
@@ -15,4 +15,4 @@ Controls overclocking and underclocking of the emulator instance by multiplying
 ## See Also
 
 * [[GB_get_clock_rate]]
-* [[GB_get_unmultiplied_clock_rate]]
\ No newline at end of file
+* [[GB_get_unmultiplied_clock_rate]]
diff --git a/GB_set_color_correction_mode.md b/GB_set_color_correction_mode.md
index 793a20e..bd6a319 100644
--- a/GB_set_color_correction_mode.md
+++ b/GB_set_color_correction_mode.md
@@ -18,15 +18,15 @@ In `display.h`
 
 ## Description
 
-The original hardware does not use the sRGB colorspace. This function selects which color correction algorithm is used by the emulator instance to convert RGB values from the model's color space to sRGB. The values supported are:
+The original hardware does not use the sRGB color space. This function selects which color correction algorithm is used by the emulator instance to convert RGB values from the model's color space to sRGB. The values supported are:
 
-* `GB_COLOR_CORRECTION_DISABLED`: Colors are directly interpreted as sRGB, resulting in unbalanced colors and inaccurate hues
-* `GB_COLOR_CORRECTION_CORRECT_CURVES`: Colors have their brightness corrected, but hues remain unbalanced
-* `GB_COLOR_CORRECTION_MODERN_ACCURATE`: Emulates a modern display. Colors have their hues and brightness corrected
-* `GB_COLOR_CORRECTION_MODERN_BALANCED`: Emulates a modern display. Blue contrast is moderately enhanced at the cost of slight hue inaccuracy
-* `GB_COLOR_CORRECTION_MODERN_BOOST_CONTRAST`: Like Modern – Balanced, but further boosts the contrast of greens and magentas that is lacking on the original hardware
-* `GB_COLOR_CORRECTION_REDUCE_CONTRAST`: Slightly reduce the contrast to better represent the tint and contrast of the original display
-* `GB_COLOR_CORRECTION_LOW_CONTRAST`: Harshly reduce the contrast to accurately represent the tint and low constrast of the original display
+* `GB_COLOR_CORRECTION_DISABLED`: Colors are directly interpreted as sRGB, resulting in unbalanced colors and inaccurate hues.
+* `GB_COLOR_CORRECTION_CORRECT_CURVES`: Colors have their brightness corrected, but hues remain unbalanced.
+* `GB_COLOR_CORRECTION_MODERN_ACCURATE`: Emulates a modern display. Colors have their hues and brightness corrected.
+* `GB_COLOR_CORRECTION_MODERN_BALANCED`: Emulates a modern display. Blue contrast is moderately enhanced at the cost of slight hue inaccuracy.
+* `GB_COLOR_CORRECTION_MODERN_BOOST_CONTRAST`: Like Modern – Balanced, but further boosts the contrast of greens and magentas that is lacking on the original hardware.
+* `GB_COLOR_CORRECTION_REDUCE_CONTRAST`: Slightly reduce the contrast to better represent the tint and contrast of the original display.
+* `GB_COLOR_CORRECTION_LOW_CONTRAST`: Harshly reduce the contrast to accurately represent the tint and low contrast of the original display.
 
 The following values are also available as deprecated aliases:
 
@@ -39,14 +39,14 @@ The following values are also available as deprecated aliases:
 
 ## Notes
 
-The currently emulated [[model|GB_model_t]] affects how color correction behaves. Super Game Boy, Game Boy Color, and Game Boy Advanced can all render the same RGB values as different colors.
+The currently emulated [[model|GB_model_t]] affects how color correction behaves. Super Game Boy, Game Boy Color, and Game Boy Advance can all render the same RGB values as different colors.
 
 This value is not used when emulating monochrome models because they do not use RGB values. To control the appearance of these models, use [[GB_set_palette|GB_set_palette and GB_get_palette]].
 
-The Super Game Boy colorspace is very similar to sRGB and only requires a correction of the brightness curve. When emulating a Super Game Boy, any color correction mode other than `GB_COLOR_CORRECTION_DISABLED` will be treated like `GB_COLOR_CORRECTION_CORRECT_CURVES`.
+The Super Game Boy color space is very similar to sRGB and only requires a correction of the brightness curve. When emulating a Super Game Boy, any color correction mode other than `GB_COLOR_CORRECTION_DISABLED` will be treated like `GB_COLOR_CORRECTION_CORRECT_CURVES`.
 
 ## See Also
 
 * [[GB_set_light_temperature]]
 * [[GB_set_palette and GB_get_palette]]
-* [[GB_set_rgb_encode_callback]]
\ No newline at end of file
+* [[GB_set_rgb_encode_callback]]
diff --git a/GB_set_emulate_joypad_bouncing.md b/GB_set_emulate_joypad_bouncing.md
index 16b184e..2ef4856 100644
--- a/GB_set_emulate_joypad_bouncing.md
+++ b/GB_set_emulate_joypad_bouncing.md
@@ -6,7 +6,7 @@ In `joypad.h`
 
 ## Description
 
-The physical buttons of various Game Boy models suffer from button bouncing, and do not instantly transition from a released state to a pressed one, and vice versa. This functions controls whether or not this physical behavior should be emulated by software.
+The physical buttons of various Game Boy models suffer from button bouncing, and do not instantly transition from a released state to a pressed one, and vice versa. This function controls whether or not this physical behavior should be emulated by software.
 
 By default, button bouncing is emulated.
 
@@ -18,4 +18,4 @@ By default, button bouncing is emulated.
 
 The time it takes for a bouncing button to stabilize depends on the currently emulated [[model|GB_model_t]]. Super Game Boy and Game Boy Player models never emulate joypad bouncing.
 
-Despite the bouncing pattern being pseudo random, it's completely deterministic and reproducable.
\ No newline at end of file
+Despite the bouncing pattern being pseudo-random, it's completely deterministic and reproducible.
diff --git a/GB_set_highpass_filter_mode.md b/GB_set_highpass_filter_mode.md
index 81540c5..2e8e303 100644
--- a/GB_set_highpass_filter_mode.md
+++ b/GB_set_highpass_filter_mode.md
@@ -15,11 +15,11 @@ In `apu.h`
 
 ## Description
 
-A real Game Boy has its audio output going through a high-pass filter before reaching the built-in speaker or headphones, which removes the variable DC-offset the digital output generates. This function controls the high-pass filter the emulator instance uses:
+A real Game Boy has its audio output going through a high-pass filter before reaching the built-in speaker or headphones, which removes the variable DC offset the digital output generates. This function controls the high-pass filter the emulator instance uses:
 
-* `GB_HIGHPASS_OFF`: No high-pass filter is used, the DC offset remains
-* `GB_HIGHPASS_ACCURATE`: A simple high-pass filter is applied; this setting best represents the hardware behavior
-* `GB_HIGHPASS_REMOVE_DC_OFFSET`: The DC offset is separated from the actual wave form, and a simple high-pass filter is only applied to the DC offset part
+* `GB_HIGHPASS_OFF`: No high-pass filter is used, and the DC offset remains.
+* `GB_HIGHPASS_ACCURATE`: A simple high-pass filter is applied; this setting best represents the hardware behavior.
+* `GB_HIGHPASS_REMOVE_DC_OFFSET`: The DC offset is separated from the actual waveform, and a simple high-pass filter is only applied to the DC offset part.
 
 ## Thread Safety
 
@@ -27,4 +27,4 @@ A real Game Boy has its audio output going through a high-pass filter before rea
 
 ## Notes
 
-Keep in mind that the DC offset is not constant prior to applying the high-pass filter.
\ No newline at end of file
+Keep in mind that the DC offset is not constant before applying the high-pass filter.
diff --git a/GB_set_input_callback.md b/GB_set_input_callback.md
index 3bf7b8b..9430f1d 100644
--- a/GB_set_input_callback.md
+++ b/GB_set_input_callback.md
@@ -24,4 +24,4 @@ If `callback` is not NULL, `GB_set_input_callback` and `GB_set_async_input_callb
 
 ## Notes
 
-The default asynchronous input callback is not supported on Windows; provide a custom callback if you wish to support asynchronous debugger commands on Windows.
\ No newline at end of file
+The default asynchronous input callback is not supported on Windows; provide a custom callback if you wish to support asynchronous debugger commands on Windows.
diff --git a/GB_set_key_mask.md b/GB_set_key_mask.md
index 148abf7..1e310b0 100644
--- a/GB_set_key_mask.md
+++ b/GB_set_key_mask.md
@@ -17,4 +17,4 @@ Sets the state for all of player 1's buttons using a [[mask|GB_key_mask_t]].
 * [[GB_key_mask_t]]
 * [[GB_set_key_state]]
 * [[GB_set_key_mask_for_player]]
-* [[GB_get_player_count]]
\ No newline at end of file
+* [[GB_get_player_count]]
diff --git a/GB_set_key_state_for_player.md b/GB_set_key_state_for_player.md
index e5b4102..5fb0529 100644
--- a/GB_set_key_state_for_player.md
+++ b/GB_set_key_state_for_player.md
@@ -17,4 +17,4 @@ For use with Super Game Boy games that support multiplayer. Sets the state for `
 * [[GB_key_t]]
 * [[GB_set_key_state]]
 * [[GB_set_key_mask_for_player]]
-* [[GB_get_player_count]]
\ No newline at end of file
+* [[GB_get_player_count]]
diff --git a/GB_set_light_temperature.md b/GB_set_light_temperature.md
index f168dff..a3d1a4c 100644
--- a/GB_set_light_temperature.md
+++ b/GB_set_light_temperature.md
@@ -6,7 +6,7 @@ In `display.h`
 
 ## Description
 
-Game Boy Color and Game Boy Advance (excluding the SP models) did not have any form of backlight or frontlight, and their display was affected by the ambient light. This function sets the simulated light temperature used when rendering the screen of the emulator instance. The minimum value of `temperature` is `-1.0` which corresponds to a light temperature of 1000K (warm red light), and the maximum value is `1.0` which corresponds to a light temperature of 12000K (cool blue light). The default value is `0.0` which corresponds to 6500K (neutral white), and effectively disables simulation of ambient light temperature.
+Game Boy Color and Game Boy Advance (excluding the SP models) did not have any form of backlight or frontlight, and their display was affected by the ambient light. This function sets the simulated light temperature used when rendering the screen of the emulator instance. The minimum value of `temperature` is `-1.0`, which corresponds to a light temperature of 1000K (warm red light), and the maximum value is `1.0`, which corresponds to a light temperature of 12000K (cool blue light). The default value is `0.0`, which corresponds to 6500K (neutral white) and effectively disables simulation of ambient light temperature.
 
 ## Thread Safety
 
@@ -20,4 +20,4 @@ This value is not used when emulating monochrome models because they do not use
 
 * [[GB_set_color_correction_mode]]
 * [[GB_set_palette and GB_get_palette]]
-* [[GB_set_rgb_encode_callback]]
\ No newline at end of file
+* [[GB_set_rgb_encode_callback]]
diff --git a/GB_set_log_callback.md b/GB_set_log_callback.md
index 31edfae..d4b8e45 100644
--- a/GB_set_log_callback.md
+++ b/GB_set_log_callback.md
@@ -18,4 +18,4 @@ If `callback` is not NULL, `GB_set_log_callback` is thread-safe and can be calle
 
 * [[GB_log_attributes_t]]
 * [[GB_log]]
-* [[GB_attributed_log]]
\ No newline at end of file
+* [[GB_attributed_log]]
diff --git a/GB_set_palette-and-GB_get_palette.md b/GB_set_palette-and-GB_get_palette.md
index 57d9aee..f985feb 100644
--- a/GB_set_palette-and-GB_get_palette.md
+++ b/GB_set_palette-and-GB_get_palette.md
@@ -8,7 +8,7 @@ In `display.h`
 
 ## Description
 
-A monochrome [[model|GB_model_t]] renders a screen with 4 colors (usually shades of grey), and potentially a different 5th color used when the LCD display is turned off. These 5 colors are stored in a [[palette struct|GB_palette_t]]. The palette can be changed and read back using these two functions. The default palette is [[GB_PALETTE_GREY|Built‐In DMG Palettes]].
+A monochrome [[model|GB_model_t]] renders a screen with 4 colors (usually shades of grey) and potentially a different 5th color used when the LCD display is turned off. These 5 colors are stored in a [[palette struct|GB_palette_t]]. The palette can be changed and read back using these two functions. The default palette is [[GB_PALETTE_GREY|Built‐In DMG Palettes]].
 
 ## Thread Safety
 
@@ -23,4 +23,4 @@ This value is only used when emulating monochrome models.
 * [[GB_palette_t]]
 * [[Built‐In DMG Palettes]]
 * [[GB_set_rgb_encode_callback]]
-* [[GB_set_color_correction_mode]]
\ No newline at end of file
+* [[GB_set_color_correction_mode]]
diff --git a/GB_set_rendering_disabled.md b/GB_set_rendering_disabled.md
index c4ad1e5..469187a 100644
--- a/GB_set_rendering_disabled.md
+++ b/GB_set_rendering_disabled.md
@@ -6,7 +6,7 @@ In `gb.h`
 
 ## Description
 
-Call this function with `true` to disable video output in an emulator instance. This will make the [[run loop|GB_run]] of the emulator instance consume less CPU usage, and it's useful in scenarios where you don't need video output (e.g. sound-only applications or automations).
+Call this function with `true` to disable video output in an emulator instance. This action will cause the [[run loop|GB_run]] of the emulator instance to consume less CPU usage. This is useful in scenarios where video output is unnecessary (e.g., sound-only applications or automations).
 
 ## Thread Safety
 
diff --git a/GB_set_rewind_length.md b/GB_set_rewind_length.md
index 0be54db..e412a84 100644
--- a/GB_set_rewind_length.md
+++ b/GB_set_rewind_length.md
@@ -17,4 +17,4 @@ In order for the debugger to support the `backstep` command, a non-zero rewind l
 ## See Also
 
 * [[GB_rewind_pop]]
-* [[GB_rewind_reset]]
\ No newline at end of file
+* [[GB_rewind_reset]]
diff --git a/GB_set_rgb_encode_callback.md b/GB_set_rgb_encode_callback.md
index 532bac3..205183e 100644
--- a/GB_set_rgb_encode_callback.md
+++ b/GB_set_rgb_encode_callback.md
@@ -39,4 +39,4 @@ If `callback` is not NULL, `GB_set_rgb_encode_callback` is thread-safe and can b
 * [[GB_set_palette and GB_get_palette]]
 * [[GB_set_pixels_output]]
 * [[GB_set_rgb_encode_callback]]
-* [[GB_get_screen_width and GB_get_screen_height]]
\ No newline at end of file
+* [[GB_get_screen_width and GB_get_screen_height]]
diff --git a/GB_set_rtc_mode.md b/GB_set_rtc_mode.md
index c99768a..aa75d27 100644
--- a/GB_set_rtc_mode.md
+++ b/GB_set_rtc_mode.md
@@ -13,9 +13,9 @@ In `timing.h`
 
 ## Description
 
-Specifies how the emulator instances emulates a Real Time Clock inside an emulated cartridge:
+Specifies how the emulator instance emulates a Real-Time Clock inside an emulated cartridge:
 
-* `GB_RTC_MODE_SYNC_TO_HOST`: The RTC follows the time in the host's clock. Even when the emulator instance is [[overclocked, underclocked|GB_set_clock_multiplier]], set to [[turbo mode|GB_set_turbo_mode]], or paused, the in-game RTC will always advanced in one real-world-second intervals.
+* `GB_RTC_MODE_SYNC_TO_HOST`: The RTC follows the time on the host's clock. Even when the emulator instance is [[overclocked, underclocked|GB_set_clock_multiplier]], set to [[turbo mode|GB_set_turbo_mode]], or paused, the in-game RTC will always advance in one real-world-second intervals.
 * `GB_RTC_MODE_ACCURATE`: The RTC timings are accurately emulated. Pausing or changing the speed of the instance will also pause or change the speed of the RTC.
 
 ## Thread Safety
@@ -24,4 +24,4 @@ Specifies how the emulator instances emulates a Real Time Clock inside an emulat
 
 ## See Also
 
-* [[GB_set_rtc_multiplier]]
\ No newline at end of file
+* [[GB_set_rtc_multiplier]]
diff --git a/GB_set_sample_rate.md b/GB_set_sample_rate.md
index 6de1c41..c5f7f38 100644
--- a/GB_set_sample_rate.md
+++ b/GB_set_sample_rate.md
@@ -25,4 +25,4 @@ The default sample rate is `0`, which disables audio rendering.
 ## See Also
 
 * [[GB_apu_set_sample_callback]]
-* [[GB_sample_t]]
\ No newline at end of file
+* [[GB_sample_t]]
diff --git a/GB_set_update_input_hint_callback.md b/GB_set_update_input_hint_callback.md
index d602e23..aff77da 100644
--- a/GB_set_update_input_hint_callback.md
+++ b/GB_set_update_input_hint_callback.md
@@ -10,7 +10,7 @@ In `joypad.h`
 
 ## Description
 
-Set the input hint callback of an emulator instance. This optional callback is called when its "ideal" for a frontend to call [[GB_set_key_state]], etc. Frontends that use polling for user inputs can poll in this callback to minimize input lag.
+Set the input hint callback of an emulator instance. This optional callback is called when it's "ideal" for a frontend to call [[GB_set_key_state]], etc. Frontends that use polling for user inputs can poll in this callback to minimize input lag.
 
 ## Thread Safety
 
@@ -21,4 +21,4 @@ If `callback` is not NULL, `GB_set_update_input_hint_callback` is thread-safe an
 * [[GB_set_key_state]]
 * [[GB_set_key_mask]]
 * [[GB_set_key_state_for_player]]
-* [[GB_set_key_mask_for_player]]
\ No newline at end of file
+* [[GB_set_key_mask_for_player]]
diff --git a/GB_set_user_data-and-GB_get_user_data.md b/GB_set_user_data-and-GB_get_user_data.md
index 7763052..255735c 100644
--- a/GB_set_user_data-and-GB_get_user_data.md
+++ b/GB_set_user_data-and-GB_get_user_data.md
@@ -12,4 +12,4 @@ In `gb.h`
 
 ## Thread Safety
 
-`GB_set_user_data` and `GB_get_user_data` thread-safe and can be called from any thread and context.
+`GB_set_user_data` and `GB_get_user_data` are thread-safe and can be called from any thread and context.
diff --git a/GB_set_vblank_callback.md b/GB_set_vblank_callback.md
index 89e97f4..6bfbe5c 100644
--- a/GB_set_vblank_callback.md
+++ b/GB_set_vblank_callback.md
@@ -21,10 +21,10 @@ In `display.h`
 
 Sets a callback that will be called when the emulator instance finishes rendering a frame into the set [[pixel buffer|GB_set_pixels_output]], usually when the LCD controller enters the VBlank stage. The callback will be called even if [[rendering is disabled|GB_set_rendering_disabled]]. The `type` argument for the callback specifies the kind of VBlank event being reported:
 
-* `GB_VBLANK_TYPE_NORMAL_FRAME`: A normal frame has finished rendering, the pixel buffer will contain the new frame's data.
-* `GB_VBLANK_TYPE_LCD_OFF`: The LCD has been off for a period of time long enough that requires presenting it to the user, the pixel buffer will contain a solid color.
+* `GB_VBLANK_TYPE_NORMAL_FRAME`: A normal frame has finished rendering, and the pixel buffer will contain the new frame's data.
+* `GB_VBLANK_TYPE_LCD_OFF`: The LCD has been off for a period of time long enough that requires presenting it to the user, and the pixel buffer will contain a solid color.
 * `GB_VBLANK_TYPE_ARTIFICIAL`: The LCD is turned on, but the ROM is preventing the PPU (Pixel Processing Unit) from rendering a complete frame. The pixel buffer will contain a partially rendered frame that may be presented to the user.
-* `GB_VBLANK_TYPE_REPEAT`: The PPU has finished rendering a frame, but the LCD on a real Game Boy hardware would not display it. The pixels buffer will contain the new frame's data, but an accurate frontend should repeat the previous frame instead of displaying it.
+* `GB_VBLANK_TYPE_REPEAT`: The PPU has finished rendering a frame, but the LCD on a real Game Boy hardware would not display it. The pixel buffer will contain the new frame's data, but an accurate frontend should repeat the previous frame instead of displaying it.
 
 ## Thread Safety
 
diff --git a/GB_switch_model_and_reset.md b/GB_switch_model_and_reset.md
index e1166e8..951ef88 100644
--- a/GB_switch_model_and_reset.md
+++ b/GB_switch_model_and_reset.md
@@ -6,7 +6,7 @@ In `gb.h`
 
 ## Description
 
-This function will replace the emulator instance's [[model|GB_model_t]], then perform a [[reset|GB_reset]].
+This function will replace the emulator instance's [[model|GB_model_t]] and then perform a [[reset|GB_reset]].
 
 ## Thread Safety
 
@@ -17,4 +17,4 @@ This function will replace the emulator instance's [[model|GB_model_t]], then pe
 * [[GB_model_t]]
 * [[Instance Allocation (GB_init)|Instance Allocation]]
 * [[GB_reset]]
-* [[GB_quick_reset]]
\ No newline at end of file
+* [[GB_quick_reset]]
diff --git a/GB_write_memory.md b/GB_write_memory.md
index 8681547..df24fbf 100644
--- a/GB_write_memory.md
+++ b/GB_write_memory.md
@@ -6,7 +6,7 @@ In `memory.h`
 
 ## Description
 
-Performs an 8-bit memory write on a 16-bit address on the emulator instance, as if it was performed by the SM83 CPU
+Performs an 8-bit memory write on a 16-bit address on the emulator instance, as if it were performed by the SM83 CPU.
 
 ## Thread Safety
 
@@ -14,12 +14,12 @@ Performs an 8-bit memory write on a 16-bit address on the emulator instance, as
 
 ## Notes
 
-The ROM is not writable, as the CPU is unable to perform a ROM write. Attempting to write to the ROM will perform an MBC register write, just like as if the write was performed by the CPU. To dynamically modify the ROM, use [[GB_get_direct_access]].
+The ROM is not writable, as the CPU is unable to perform a ROM write. Attempting to write to the ROM will perform an MBC register write, just as if the write was performed by the CPU. To dynamically modify the ROM, use [[GB_get_direct_access]].
 
-To write data outside of a currently mapped bank, or to write to a memory region that might not be currently writeable (e.g. VRAM during mode 3), you can use [[GB_get_direct_access]].
+To write data outside of a currently mapped bank, or to write to a memory region that might not be currently writable (e.g., VRAM during mode 3), you can use [[GB_get_direct_access]].
 
 ## See Also
 
 * [[GB_read_memory]]
 * [[GB_safe_read_memory]]
-* [[GB_get_direct_access]]
\ No newline at end of file
+* [[GB_get_direct_access]]
diff --git a/IO Register Constants.md b/IO Register Constants.md
index 798c2fb..b9a28f4 100644
--- a/IO Register Constants.md	
+++ b/IO Register Constants.md	
@@ -39,7 +39,7 @@ enum {
     GB_IO_NR41       = 0x20, // Channel 4 Sound Length (R/W)
     GB_IO_NR42       = 0x21, // Channel 4 Volume Envelope (R/W)
     GB_IO_NR43       = 0x22, // Channel 4 Polynomial Counter (R/W)
-    GB_IO_NR44       = 0x23, // Channel 4 Counter/consecutive, Inital (R/W)
+    GB_IO_NR44       = 0x23, // Channel 4 Counter/consecutive, Initial (R/W)
     GB_IO_NR50       = 0x24, // Channel control / ON-OFF / Volume (R/W)
     GB_IO_NR51       = 0x25, // Selection of Sound output terminal (R/W)
     GB_IO_NR52       = 0x26, // Sound on/off
@@ -124,6 +124,6 @@ In `gb.h`
 Constants for accessing memory-mapped IO registers. `GB_IO_*` constants are offsets from the MMIO base (`0xFF00`). `GB_LCDC_*` constants are bit masks for the LCDC register.
 
 ## See Also
- * [[GB_read_memory]]
- * [[GB_write_memory]]
- * [[GB_get_direct_access]]
\ No newline at end of file
+* [[GB_read_memory]]
+* [[GB_write_memory]]
+* [[GB_get_direct_access]]
\ No newline at end of file
diff --git a/Instance-Allocation.md b/Instance-Allocation.md
index 6f829dd..7e56632 100644
--- a/Instance-Allocation.md
+++ b/Instance-Allocation.md
@@ -31,7 +31,7 @@ GB_gameboy_t *gb = GB_init(GB_alloc(), model);
 /* GB_free(gb); */ // optional
 GB_dealloc(gb);
 ```
-`GB_alloc` will allocate a buffer with the right size for your instance, which can then be initialized with `GB_init`. `GB_delloc` will call `GB_free` if it wasn't already called, and free the allocated buffer. For convenience, `GB_init` always returns the first argument back.
+`GB_alloc` will allocate a buffer with the right size for your instance, which can then be initialized with `GB_init`. `GB_dealloc` will call `GB_free` if it wasn't already called and free the allocated buffer. For convenience, `GB_init` always returns the first argument back.
 
 3. Manually allocated:
 ```c
@@ -40,9 +40,9 @@ GB_gameboy_t *gb = GB_init(my_custom_malloc(GB_allocation_size()), model);
 GB_free(gb);
 my_custom_free(gb);
 ```
-Using `GB_allocation_size` you can obtain the required buffer size for an instance, which can then be used to allocate a buffer for it using any arbitrary allocation method.
+Using `GB_allocation_size`, you can obtain the required buffer size for an instance, which can then be used to allocate a buffer for it using any arbitrary allocation method.
 
-Additionally, `GB_is_inited` will return `true` if a [[GB_gameboy_t]] instance is initialized in a given buffer. If an instance is allocated in such before, it must be first freed with `GB_free` or `GB_dealloc` before being deallocated.
+Additionally, `GB_is_inited` will return `true` if a [[GB_gameboy_t]] instance is initialized in a given buffer. If an instance is allocated in such a way before, it must be first freed with `GB_free` or `GB_dealloc` before being deallocated.
 
 ## Thread Safety
 `GB_free` and `GB_dealloc` must not be called if the instance is being run in any thread, including the current one (via a callback).
@@ -54,4 +54,4 @@ Additionally, `GB_is_inited` will return `true` if a [[GB_gameboy_t]] instance i
 * [[GB_gameboy_t]]
 * [[GB_model_t]]
 * [[GB_reset]]
-* [[GB_switch_model_and_reset]]
\ No newline at end of file
+* [[GB_switch_model_and_reset]]