diff --git a/.github/workflows/pr-test.yml b/.github/workflows/pr-test.yml
index 589caa429..829be8c7b 100644
--- a/.github/workflows/pr-test.yml
+++ b/.github/workflows/pr-test.yml
@@ -16,7 +16,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [macos-latest, ubuntu-latest, windows-latest]
-        python-version: [3.8, 3.9, "3.10", 3.11, 3.12, 3.13]
+        python-version: [3.9, "3.10", 3.11, 3.12, 3.13]
 
     steps:
     - uses: actions/checkout@v3
@@ -50,6 +50,13 @@ jobs:
         TEST_NO_UI: 1
       run: |
         python -m pytest tests/ -n auto -v
+    - name: Run PyTest Benchmark
+      env:
+        PYTEST_SECRETS_KEY: ${{ secrets.PYTEST_SECRETS_KEY }}
+        TEST_VERBOSE_IMAGES: 0
+        TEST_NO_UI: 1
+      run: |
+        python -m pytest tests/test_benchmark.py --benchmark-enable --benchmark-min-rounds=10
     - name: Build wheel
       run: |
         echo "Building wheel"
@@ -122,7 +129,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ['cp38-cp38', 'cp39-cp39', 'cp310-cp310', 'cp311-cp311', 'cp312-cp312', 'cp313-cp313']
+        python-version: ['cp39-cp39', 'cp310-cp310', 'cp311-cp311', 'cp312-cp312', 'cp313-cp313']
         manylinux-version: ['manylinux_2_28_x86_64', 'musllinux_1_2_x86_64'] # GHA doesn't support manylinux_2_24_aarch64
 
     steps:
@@ -170,10 +177,10 @@ jobs:
           echo "Dists built:"
           ls -lah dist/
 
-    - name: Set up Python 3.8 (just for PyPi upload)
+    - name: Set up Python 3.11 (just for PyPi upload)
       uses: actions/setup-python@v3
       with:
-        python-version: 3.8
+        python-version: 3.11
     - name: Upload wheel
       if: ${{ github.event_name == 'release' && github.event.action == 'published' && !github.event.release.prerelease }}
       run: |
diff --git a/Makefile b/Makefile
index ffa7f541a..61d1a0dbd 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,5 @@
 
-.PHONY: build clean run install test
+.PHONY: build clean run install test benchmark docs
 
 all: build
 
@@ -65,7 +65,7 @@ uninstall:
 	${PY} -m pip uninstall pyboy
 
 test: export DEBUG=1
-test: clean test_pypy test_cpython_doctest build test_cython
+test: clean test_pypy test_cpython_doctest build test_cython benchmark
 
 test_cpython_doctest:
 	${PY} -m pytest pyboy/ ${PYTEST_ARGS}
@@ -78,9 +78,13 @@ test_pypy:
 
 test_all: test
 
+benchmark:
+	${PY} -m pytest -m benchmark tests/test_benchmark.py --benchmark-enable --benchmark-min-rounds=10
+
 docs: clean
-	bash -O extglob -c 'rm -rf -- ${ROOT_DIR}/docs/!(templates|CNAME)'
+	find ./docs -type f ! -path "./docs/templates/*" ! -path "./docs/CNAME" ! -name "*.png" -exec rm -rf {} +
 	mkdir -p ${ROOT_DIR}/docs/templates
+	cd ${ROOT_DIR}/pyboy/plugins && ${PY} manager_gen.py
 	pdoc --html --force -c latex_math=True -c sort_identifiers=False -c show_type_annotations=True --template-dir docs/templates pyboy
 	cp -r html/pyboy/ ${ROOT_DIR}/docs/
 	rm -rf html
diff --git a/README.md b/README.md
index 93d9a38fa..a2b275f0a 100644
--- a/README.md
+++ b/README.md
@@ -2,9 +2,9 @@
 <img src="extras/README/pyboy.svg" width="480">
 </p>
 
-__If you have any questions, or just want to chat, [join us on Discord](https://discord.gg/Zrf2nyH).__
+__If you have any questions, or just want to chat, [join us on Discord](https://discord.gg/wUbag3KNqQ).__
 
-[![Discord](https://img.shields.io/discord/584149554132418570?style=for-the-badge&logo=Discord&label=PyBoy)](https://discord.gg/Zrf2nyH)
+[![Discord](https://img.shields.io/discord/584149554132418570?style=for-the-badge&logo=Discord&label=PyBoy)](https://discord.gg/wUbag3KNqQ)
 
 <!---
 Generate GIF with the layout and captions
@@ -98,7 +98,7 @@ If you are looking to make a bot or AI, then these resources are a good place to
    * [Example: Tetris](https://github.com/Baekalfen/PyBoy/wiki/Example-Tetris)
    * [Example: Super Mario Land](https://github.com/Baekalfen/PyBoy/wiki/Example-Super-Mario-Land)
    * [Code Examples](https://github.com/Baekalfen/PyBoy/tree/master/extras/examples)
- * [Discord](https://discord.gg/Zrf2nyH)
+ * [Discord](https://discord.gg/wUbag3KNqQ)
 
 
 When the emulator is running, you can easily access [PyBoy's API](https://baekalfen.github.io/PyBoy/index.html):
@@ -186,9 +186,9 @@ do 3160 hours of gameplay in 1 hour.
 
 Contributing
 ============
-Any contribution is appreciated. The currently known problems are tracked in [the Issues tab](https://github.com/Baekalfen/PyBoy/issues). Feel free to take a swing at any one of them. If you have something original in mind, come and [discuss it on on Discord](https://discord.gg/Zrf2nyH).
+Any contribution is appreciated. The currently known problems are tracked in [the Issues tab](https://github.com/Baekalfen/PyBoy/issues). Feel free to take a swing at any one of them. If you have something original in mind, come and [discuss it on on Discord](https://discord.gg/wUbag3KNqQ).
 
-[![Discord](https://img.shields.io/discord/584149554132418570?style=for-the-badge&logo=Discord&label=PyBoy)](https://discord.gg/Zrf2nyH)
+[![Discord](https://img.shields.io/discord/584149554132418570?style=for-the-badge&logo=Discord&label=PyBoy)](https://discord.gg/wUbag3KNqQ)
 
 For the more major features, there are the following that you can give a try. They are also described in more detail in the [project list in the Wiki](https://github.com/Baekalfen/PyBoy/wiki/Student-Projects):
 * Hacking games
diff --git a/extras/bootrom/bootrom_common.asm b/extras/bootrom/bootrom_common.asm
index 071e65a63..f50dc85ba 100644
--- a/extras/bootrom/bootrom_common.asm
+++ b/extras/bootrom/bootrom_common.asm
@@ -74,13 +74,13 @@ main:
 
     ; Sound Setup
     ld A, $80
-    ldh [$26], A ; Enable sound - NR52
-    ldh [$11], A ; Use 50% duty cycle - NR11
+    ldh [$FF00+$26], A ; Enable sound - NR52
+    ldh [$FF00+$11], A ; Use 50% duty cycle - NR11
     ld A, $F3
-    ldh [$12], A
-    ldh [$25], A
+    ldh [$FF00+$12], A
+    ldh [$FF00+$25], A
     ld A, $77
-    ldh [$24], A
+    ldh [$FF00+$24], A
 
     ; #########################
     ; Graphics effect and wait
@@ -123,24 +123,24 @@ main:
 .play_sound
     ; Adjust frequency sweep
     ld A, %0010011
-    ldh [$10], A
+    ldh [$FF00+$10], A
 
     ld A, $48
-    ldh [$13], A
+    ldh [$FF00+$13], A
 
     ; Trigger
     ld A, $81
-    ldh [$14], A
+    ldh [$FF00+$14], A
     ret
 
 .adj_sound
     ; Adjust frequency sweep
     ld A, %0011001
-    ldh [$10], A
+    ldh [$FF00+$10], A
 
     ; Trigger
     ld A, $81
-    ldh [$14], A
+    ldh [$FF00+$14], A
     ret
 
 
diff --git a/extras/default_rom/default_rom.asm b/extras/default_rom/default_rom.asm
index 568bf2cca..4b9b42067 100644
--- a/extras/default_rom/default_rom.asm
+++ b/extras/default_rom/default_rom.asm
@@ -99,7 +99,7 @@ Main:
 	ld a, [rWY]
 	cp a, 90
 	jr c, .loop
-
+.inner_loop ; Used in test
 	ldh a, [rDIV]
 	cp a, 255
 	jp z, .move
diff --git a/extras/default_rom/default_rom.sym b/extras/default_rom/default_rom.sym
index ea801cfcc..101aa5e86 100644
--- a/extras/default_rom/default_rom.sym
+++ b/extras/default_rom/default_rom.sym
@@ -9,6 +9,7 @@
 00:0187 Main.readTilemap
 00:01a0 Main.clearOAM
 00:01ab Main.loop
+00:01b2 Main.inner_loop
 00:01bb Main.sync
 00:01c2 Main.move
 00:01cd Tileset
diff --git a/extras/default_rom/default_rom_cgb.sym b/extras/default_rom/default_rom_cgb.sym
index ea801cfcc..101aa5e86 100644
--- a/extras/default_rom/default_rom_cgb.sym
+++ b/extras/default_rom/default_rom_cgb.sym
@@ -9,6 +9,7 @@
 00:0187 Main.readTilemap
 00:01a0 Main.clearOAM
 00:01ab Main.loop
+00:01b2 Main.inner_loop
 00:01bb Main.sync
 00:01c2 Main.move
 00:01cd Tileset
diff --git a/extras/examples/gamewrapper_kirby.py b/extras/examples/gamewrapper_kirby.py
index 14226319e..51fed80f1 100644
--- a/extras/examples/gamewrapper_kirby.py
+++ b/extras/examples/gamewrapper_kirby.py
@@ -10,8 +10,8 @@
 file_path = os.path.dirname(os.path.realpath(__file__))
 sys.path.insert(0, file_path + "/../..")
 
-from pyboy import PyBoy  # isort:skip
-from pyboy.utils import WindowEvent  # isort:skip
+from pyboy import PyBoy  # noqa
+from pyboy.utils import WindowEvent  # noqa
 
 # Check if the ROM is given through argv
 if len(sys.argv) > 1:
diff --git a/extras/examples/gamewrapper_mario.py b/extras/examples/gamewrapper_mario.py
index be05651dc..b407a8c80 100644
--- a/extras/examples/gamewrapper_mario.py
+++ b/extras/examples/gamewrapper_mario.py
@@ -10,8 +10,8 @@
 file_path = os.path.dirname(os.path.realpath(__file__))
 sys.path.insert(0, file_path + "/../..")
 
-from pyboy import PyBoy  # isort:skip
-from pyboy.utils import WindowEvent  # isort:skip
+from pyboy import PyBoy  # noqa
+from pyboy.utils import WindowEvent  # noqa
 
 # Check if the ROM is given through argv
 if len(sys.argv) > 1:
diff --git a/extras/examples/gamewrapper_tetris.py b/extras/examples/gamewrapper_tetris.py
index bbc09f512..0a86be773 100644
--- a/extras/examples/gamewrapper_tetris.py
+++ b/extras/examples/gamewrapper_tetris.py
@@ -10,8 +10,8 @@
 file_path = os.path.dirname(os.path.realpath(__file__))
 sys.path.insert(0, file_path + "/../..")
 
-from pyboy import PyBoy  # isort:skip
-from pyboy.utils import WindowEvent  # isort:skip
+from pyboy import PyBoy  # noqa
+from pyboy.utils import WindowEvent  # noqa
 
 # Check if the ROM is given through argv
 if len(sys.argv) > 1:
diff --git a/pyboy/__main__.py b/pyboy/__main__.py
index 1bc001f89..f91aaac19 100644
--- a/pyboy/__main__.py
+++ b/pyboy/__main__.py
@@ -9,9 +9,10 @@
 import os
 
 import pyboy
-from pyboy import PyBoy, core, utils
+from pyboy import PyBoy
 from pyboy.plugins.manager import parser_arguments
 from pyboy.pyboy import defaults
+from pyboy.utils import PyBoyInvalidInputException
 
 logger = pyboy.logging.get_logger(__name__)
 
@@ -20,13 +21,15 @@
 
 def color_tuple(string):
     color_palette = [int(c.strip(), 16) for c in string.split(",")]
-    assert len(color_palette) == 4, f"Not the correct amount of colors! Expected four, got {len(color_palette)}"
+    if not (len(color_palette) == 4):
+        raise PyBoyInvalidInputException(f"Not the correct amount of colors! Expected four, got {len(color_palette)}")
     return color_palette
 
 
 def cgb_color_tuple(string):
     color_palette = [int(c.strip(), 16) for c in string.split(",")]
-    assert len(color_palette) == 12, f"Not the correct amount of colors! Expected twelve, got {len(color_palette)}"
+    if not (len(color_palette) == 12):
+        raise PyBoyInvalidInputException(f"Not the correct amount of colors! Expected twelve, got {len(color_palette)}")
     return [color_palette[0:4], color_palette[4:8], color_palette[8:12]]
 
 
@@ -43,6 +46,7 @@ def valid_file_path(path):
 )
 parser.add_argument("ROM", type=valid_file_path, help="Path to a Game Boy compatible ROM file")
 parser.add_argument("-b", "--bootrom", dest="bootrom", type=valid_file_path, help="Path to a boot-ROM file")
+parser.add_argument("--no-input", action="store_true", help="Disable all user-input (mostly for autonomous testing)")
 parser.add_argument(
     "--log-level",
     default=defaults["log_level"],
@@ -168,7 +172,6 @@ def main():
         with open(state_path, "rb") as f:
             pyboy.load_state(f)
 
-    render = not argv.no_renderer
     while pyboy.tick():
         pass
 
diff --git a/pyboy/api/__init__.py b/pyboy/api/__init__.py
index 964f36905..b35d28c2c 100644
--- a/pyboy/api/__init__.py
+++ b/pyboy/api/__init__.py
@@ -17,4 +17,11 @@
 #     "constants": False,
 #     "manager": False,
 # }
-# __all__ = ["API"]
+__all__ = [
+    constants,
+    GameShark,
+    Screen,
+    Sprite,
+    Tile,
+    TileMap,
+]
diff --git a/pyboy/api/gameshark.pxd b/pyboy/api/gameshark.pxd
index 895160651..7f2aa318e 100644
--- a/pyboy/api/gameshark.pxd
+++ b/pyboy/api/gameshark.pxd
@@ -17,8 +17,8 @@ cdef class GameShark:
 
     cdef uint8_t _get_value(self, int, int) noexcept
     cdef void _set_value(self, int, int, int) noexcept
-    cdef tuple _convert_cheat(self, str code) noexcept
+    cdef tuple _convert_cheat(self, str code)
     cpdef void add(self, str code) noexcept
     cpdef void remove(self, str code, bint restore_value=*) noexcept
     cpdef void clear_all(self, bint restore_value=*) noexcept
-    cdef void tick(self) noexcept
+    cdef void tick(self) noexcept with gil
diff --git a/pyboy/api/gameshark.py b/pyboy/api/gameshark.py
index d9b81b79f..7ed4e29f1 100644
--- a/pyboy/api/gameshark.py
+++ b/pyboy/api/gameshark.py
@@ -121,7 +121,7 @@ def remove(self, code, restore_value=True):
             restore_value (bool): True to restore original value at address, otherwise don't restore
         """
 
-        if not code in self.cheats:
+        if code not in self.cheats:
             raise ValueError("GameShark code cannot be removed. Hasn't been applied.")
 
         original_value, (_type, _, address) = self.cheats.pop(code)
diff --git a/pyboy/api/memory_scanner.pxd b/pyboy/api/memory_scanner.pxd
index 551cba12f..6880c7e36 100644
--- a/pyboy/api/memory_scanner.pxd
+++ b/pyboy/api/memory_scanner.pxd
@@ -7,5 +7,5 @@ cdef class MemoryScanner:
     cdef int _memory_cache_byte_width
 
     cpdef list rescan_memory(self, object new_value=*, dynamic_comparison_type=*, byteorder=*)
-    cpdef list scan_memory(self, object target_value=*, int start_addr=*, int end_addr=*, standard_comparison_type=*, value_type=*, int byte_width=*, byteorder=*) noexcept
+    cpdef list scan_memory(self, object target_value=*, int start_addr=*, int end_addr=*, standard_comparison_type=*, value_type=*, int byte_width=*, byteorder=*)
     cpdef bint _check_value(self, uint64_t, uint64_t, int)noexcept
diff --git a/pyboy/api/memory_scanner.py b/pyboy/api/memory_scanner.py
index 14eca6de6..aceb5bce9 100644
--- a/pyboy/api/memory_scanner.py
+++ b/pyboy/api/memory_scanner.py
@@ -142,7 +142,7 @@ def rescan_memory(
                 else:
                     self._memory_cache[addr] = current_value
             elif dynamic_comparison_type == DynamicComparisonType.MATCH:
-                if new_value == None:
+                if new_value is None:
                     raise ValueError("new_value must be specified when using DynamicComparisonType.MATCH")
                 if current_value != new_value:
                     self._memory_cache.pop(addr)
diff --git a/pyboy/api/screen.pxd b/pyboy/api/screen.pxd
index 5e95ad9d9..d23777597 100644
--- a/pyboy/api/screen.pxd
+++ b/pyboy/api/screen.pxd
@@ -11,13 +11,12 @@ from pyboy.core.mb cimport Motherboard
 
 cdef class Screen:
     cdef Motherboard mb
-    cpdef ((int, int), (int, int)) get_tilemap_position(self)
+    cpdef ((int, int), (int, int)) get_tilemap_position(self) noexcept
     # cdef readonly list tilemap_position_list
     # cdef readonly uint8_t[:,:] tilemap_position_list
     cdef readonly uint32_t[:,:] raw_buffer
     cdef readonly (int, int) raw_buffer_dims
     cdef readonly str raw_buffer_format
-    # cdef readonly uint8_t[144][160][4] memoryview
-    # cpdef np.ndarray[np.uint8_t, ndim=3] get_ndarray(self)
+
     cdef readonly object ndarray
     cdef readonly object image
diff --git a/pyboy/api/screen.py b/pyboy/api/screen.py
index 8e3013195..d6ac55fc5 100644
--- a/pyboy/api/screen.py
+++ b/pyboy/api/screen.py
@@ -54,8 +54,8 @@ def __init__(self, mb):
 
         Returns
         -------
-        bytes:
-            92160 bytes of screen data in a `bytes` object.
+        memoryview:
+            92160 bytes memoryview of screen data.
         """
         self.raw_buffer_dims = self.mb.lcd.renderer.buffer_dims
         """
@@ -121,6 +121,7 @@ def __init__(self, mb):
         """
         if not Image:
             logger.warning('Cannot generate screen image. Missing dependency "Pillow".')
+            self.image = utils.PillowImportError()
         else:
             self._set_image()
 
@@ -173,7 +174,7 @@ def _set_image(self):
     @property
     def tilemap_position_list(self):
         """
-        This function provides the screen (SCX, SCY) and window (WX. WY) position for each horizontal line in the
+        This function provides the screen (SCX, SCY) and window (WX, WY) position for each horizontal line in the
         screen buffer. These parameters are often used for visual effects, and some games will reset the registers at
         the end of each call to `pyboy.PyBoy.tick()`.
 
@@ -206,7 +207,7 @@ def tilemap_position_list(self):
         """
 
         if self.mb.lcd._LCDC.lcd_enable:
-            return [[line[0], line[1], line[2], line[3]] for line in self.mb.lcd._scanlineparameters]
+            return [[line[0], line[1], line[2] - 7, line[3]] for line in self.mb.lcd._scanlineparameters]
         else:
             return [[0, 0, 0, 0] for line in range(144)]
 
diff --git a/pyboy/api/sprite.py b/pyboy/api/sprite.py
index fbb96bdd9..e811517e6 100644
--- a/pyboy/api/sprite.py
+++ b/pyboy/api/sprite.py
@@ -7,6 +7,7 @@
 """
 
 from pyboy.core.lcd import LCDCRegister
+from pyboy.utils import PyBoyOutOfBoundsException
 
 from .constants import LCDC_OFFSET, OAM_OFFSET, SPRITES
 from .tile import Tile
@@ -30,7 +31,8 @@ def __init__(self, mb, sprite_index):
         By knowing the tile identifiers of players, enemies, power-ups and so on, you'll be able to search for them
         using `pyboy.sprite_by_tile_identifier` and feed it to your bot or AI.
         """
-        assert 0 <= sprite_index < SPRITES, f"Sprite index of {sprite_index} is out of range (0-{SPRITES})"
+        if not (0 <= sprite_index < SPRITES):
+            raise PyBoyOutOfBoundsException(f"Sprite index of {sprite_index} is out of range (0-{SPRITES})")
         self.mb = mb
         self._offset = sprite_index * 4
 
diff --git a/pyboy/api/tile.pxd b/pyboy/api/tile.pxd
index 9da325e75..84fff776b 100644
--- a/pyboy/api/tile.pxd
+++ b/pyboy/api/tile.pxd
@@ -21,8 +21,8 @@ cdef class Tile:
     cdef readonly int tile_identifier
     cdef readonly int data_address
     cdef readonly tuple shape
-    cpdef object image(self) noexcept
-    cpdef object ndarray(self) noexcept
+    cpdef object image(self)
+    cpdef object ndarray(self)
 
     cdef uint32_t[:,:] data # TODO: Add to locals instead
     @cython.locals(byte1=uint8_t, byte2=uint8_t, colorcode=uint64_t)
diff --git a/pyboy/api/tile.py b/pyboy/api/tile.py
index 0796d15b9..3e2d2e193 100644
--- a/pyboy/api/tile.py
+++ b/pyboy/api/tile.py
@@ -11,6 +11,7 @@
 
 import pyboy
 from pyboy import utils
+from pyboy.utils import PyBoyOutOfBoundsException
 
 from .constants import LOW_TILEDATA, TILES, TILES_CGB, VRAM_OFFSET
 
@@ -21,13 +22,6 @@
 except ImportError:
     Image = None
 
-try:
-    from cython import compiled
-
-    cythonmode = compiled
-except ImportError:
-    cythonmode = False
-
 
 class Tile:
     def __init__(self, mb, identifier):
@@ -45,9 +39,11 @@ def __init__(self, mb, identifier):
         self.mb = mb
 
         if self.mb.cgb:
-            assert 0 <= identifier < TILES_CGB, "Identifier out of range"
+            if not (0 <= identifier < TILES_CGB):
+                raise PyBoyOutOfBoundsException("Identifier out of range")
         else:
-            assert 0 <= identifier < TILES, "Identifier out of range"
+            if not (0 <= identifier < TILES):
+                raise PyBoyOutOfBoundsException("Identifier out of range")
 
         self.data_address = LOW_TILEDATA + (16 * (identifier % TILES))
         """
@@ -121,9 +117,9 @@ def image(self):
         """
         if Image is None:
             logger.error(f'{__name__}: Missing dependency "Pillow".')
-            return None
+            utils.PillowImportError()._raise_import_error()
 
-        if cythonmode:
+        if utils.cython_compiled:
             return Image.fromarray(self._image_data().base, mode=self.raw_buffer_format)
         else:
             return Image.frombytes(self.raw_buffer_format, (8, 8), self._image_data())
diff --git a/pyboy/conftest.py b/pyboy/conftest.py
index 348e5c273..2e99cf951 100644
--- a/pyboy/conftest.py
+++ b/pyboy/conftest.py
@@ -18,6 +18,8 @@
 from cryptography.fernet import Fernet
 from filelock import FileLock
 
+from pyboy.utils import cython_compiled
+
 from . import PyBoy
 
 np.set_printoptions(threshold=2**32)
@@ -77,7 +79,7 @@ def locate_sha256(digest):
 @pytest.fixture(scope="session")
 def secrets():
     path = extra_test_rom_dir / Path("secrets")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isdir(path):
             if not os.environ.get("PYTEST_SECRETS_KEY"):
                 pytest.skip("Cannot access secrets")
@@ -148,6 +150,9 @@ def mock_PyBoy(filename, *args, **kwargs):
         kwargs.pop("window", None)
         return PyBoy(filename, *args, window="null", **kwargs)
 
+    if cython_compiled:
+        pytest.skip("Cannot mock components if compiled with Cython")
+
     # We mock get_sprite_by_tile_identifier as default_rom doesn't use sprites
     # fmt: off
     with mock.patch("pyboy.PyBoy.get_sprite_by_tile_identifier", return_value=[[0, 2, 4], []]), \
@@ -160,7 +165,7 @@ def mock_PyBoy(filename, *args, **kwargs):
         # fmt: on
 
         pyboy.set_emulation_speed(0)
-        pyboy.tick(10) # Just a few to get the logo up
+        pyboy.tick(10)  # Just a few to get the logo up
         doctest_namespace["pyboy"] = pyboy
         doctest_namespace["pyboy_cgb"] = pyboy_cgb
         doctest_namespace["PyBoy"] = mock_PyBoy
@@ -298,7 +303,6 @@ def collect(self):
 
 # NOTE: Taken from Pytest
 def pytest_collect_file(file_path, parent):
-    config = parent.config
     if file_path.suffix == ".py":
         txt = DoctestTextfile.from_parent(parent, path=file_path)
         return txt
diff --git a/pyboy/core/__init__.py b/pyboy/core/__init__.py
index 073f501b6..4d26c72e5 100644
--- a/pyboy/core/__init__.py
+++ b/pyboy/core/__init__.py
@@ -2,5 +2,3 @@
 # License: See LICENSE.md file
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
-
-from . import mb
diff --git a/pyboy/core/cartridge/__init__.py b/pyboy/core/cartridge/__init__.py
index 42ba1a244..218505ef3 100644
--- a/pyboy/core/cartridge/__init__.py
+++ b/pyboy/core/cartridge/__init__.py
@@ -3,10 +3,8 @@
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
 
-# from .base_mbc import BaseMBC, ROMOnly
 from .cartridge import load_cartridge
 
-# from .mbc1 import MBC1
-# from .mbc2 import MBC2
-# from .mbc3 import MBC3
-# from .mbc5 import MBC5
+__all__ = [
+    load_cartridge,
+]
diff --git a/pyboy/core/cartridge/base_mbc.pxd b/pyboy/core/cartridge/base_mbc.pxd
index 5b8842795..9fa89a292 100644
--- a/pyboy/core/cartridge/base_mbc.pxd
+++ b/pyboy/core/cartridge/base_mbc.pxd
@@ -32,11 +32,11 @@ cdef class BaseMBC:
     cdef bint cgb
 
     cdef void save_state(self, IntIOInterface) noexcept
-    cdef void load_state(self, IntIOInterface, int) noexcept
+    cdef int load_state(self, IntIOInterface, int) except -1
     cdef void save_ram(self, IntIOInterface) noexcept
     cdef void load_ram(self, IntIOInterface) noexcept
     cdef void init_rambanks(self, uint8_t) noexcept
-    cdef str getgamename(self, uint8_t[:,:]) noexcept
+    cdef str getgamename(self, uint8_t[:,:])
 
     cdef uint8_t getitem(self, uint16_t) noexcept nogil
     cdef void setitem(self, uint16_t, uint8_t) noexcept nogil
diff --git a/pyboy/core/cartridge/base_mbc.py b/pyboy/core/cartridge/base_mbc.py
index ffd29922f..90382f652 100644
--- a/pyboy/core/cartridge/base_mbc.py
+++ b/pyboy/core/cartridge/base_mbc.py
@@ -7,8 +7,7 @@
 import os
 
 import pyboy
-from pyboy import utils
-from pyboy.utils import IntIOWrapper
+from pyboy.utils import IntIOWrapper, PyBoyException
 
 from .rtc import RTC
 
@@ -106,7 +105,7 @@ def getgamename(self, rombanks):
         return "".join([chr(rombanks[0, x]) for x in range(0x0134, 0x0142)]).split("\0")[0]
 
     def setitem(self, address, value):
-        raise Exception("Cannot set item in MBC")
+        raise PyBoyException("Cannot set item in MBC")
 
     def overrideitem(self, rom_bank, address, value):
         if 0x0000 <= address < 0x4000:
diff --git a/pyboy/core/cartridge/cartridge.pxd b/pyboy/core/cartridge/cartridge.pxd
index ad113bacd..04b92f01a 100644
--- a/pyboy/core/cartridge/cartridge.pxd
+++ b/pyboy/core/cartridge/cartridge.pxd
@@ -16,7 +16,7 @@ from .base_mbc cimport BaseMBC
 cdef Logger logger
 
 @cython.locals(carttype=uint8_t, cart_name=basestring, cart_line=basestring)
-cpdef BaseMBC load_cartridge(str) noexcept
+cpdef BaseMBC load_cartridge(str)
 cdef bint validate_checksum(uint8_t[:,:]) noexcept
 
 @cython.locals(romdata=array, banksize=int)
diff --git a/pyboy/core/cartridge/cartridge.py b/pyboy/core/cartridge/cartridge.py
index 29b188199..39e823dfc 100644
--- a/pyboy/core/cartridge/cartridge.py
+++ b/pyboy/core/cartridge/cartridge.py
@@ -6,7 +6,7 @@
 from array import array
 
 import pyboy
-from pyboy import utils
+from pyboy.utils import PyBoyException
 
 from .base_mbc import ROMOnly
 from .mbc1 import MBC1
@@ -20,7 +20,7 @@
 def load_cartridge(filename):
     rombanks = load_romfile(filename)
     if not validate_checksum(rombanks):
-        raise Exception("Cartridge header checksum mismatch!")
+        raise PyBoyException("Cartridge header checksum mismatch!")
 
     # WARN: The following table doesn't work for MBC2! See Pan Docs
     external_ram_count = int(EXTERNAL_RAM_TABLE[rombanks[0, 0x0149]])
@@ -28,7 +28,7 @@ def load_cartridge(filename):
     carttype = rombanks[0, 0x0147]
     cartinfo = CARTRIDGE_TABLE.get(carttype, None)
     if cartinfo is None:
-        raise Exception("Catridge type invalid: %s" % carttype)
+        raise PyBoyException("Catridge type invalid: %s" % carttype)
 
     cart_line = ", ".join([x for x, y in zip(["SRAM", "Battery", "RTC"], cartinfo[1:]) if y])
     cart_name = cartinfo[0].__name__
@@ -54,12 +54,13 @@ def load_romfile(filename):
     logger.debug("Loading ROM file: %d bytes", len(romdata))
     if len(romdata) == 0:
         logger.error("ROM file is empty!")
-        raise Exception("Empty ROM file")
+        raise PyBoyException("Empty ROM file")
 
     banksize = 16 * 1024
     if len(romdata) % banksize != 0:
-        logger.error("Unexpected ROM file length")
-        raise Exception("Bad ROM file size")
+        raise PyBoyException(
+            f"Unexpected ROM file length! ROM data of {len(romdata)} doesn't divide evenly into bank size {banksize}"
+        )
 
     return memoryview(romdata).cast("B", shape=(len(romdata) // banksize, banksize))
 
diff --git a/pyboy/core/cartridge/mbc1.py b/pyboy/core/cartridge/mbc1.py
index bb384041e..30e7591eb 100644
--- a/pyboy/core/cartridge/mbc1.py
+++ b/pyboy/core/cartridge/mbc1.py
@@ -4,7 +4,6 @@
 #
 
 import pyboy
-from pyboy import utils
 
 from .base_mbc import BaseMBC
 
diff --git a/pyboy/core/cartridge/mbc2.py b/pyboy/core/cartridge/mbc2.py
index 6714e4396..9acd11ca2 100644
--- a/pyboy/core/cartridge/mbc2.py
+++ b/pyboy/core/cartridge/mbc2.py
@@ -4,7 +4,6 @@
 #
 
 import pyboy
-from pyboy import utils
 
 from .base_mbc import BaseMBC
 
diff --git a/pyboy/core/cartridge/mbc3.py b/pyboy/core/cartridge/mbc3.py
index 62ccd8ca5..3fcdcd011 100644
--- a/pyboy/core/cartridge/mbc3.py
+++ b/pyboy/core/cartridge/mbc3.py
@@ -4,7 +4,6 @@
 #
 
 import pyboy
-from pyboy import utils
 
 from .base_mbc import BaseMBC
 
diff --git a/pyboy/core/cartridge/mbc5.py b/pyboy/core/cartridge/mbc5.py
index 18e259247..fd8d6d093 100644
--- a/pyboy/core/cartridge/mbc5.py
+++ b/pyboy/core/cartridge/mbc5.py
@@ -4,7 +4,6 @@
 #
 
 import pyboy
-from pyboy import utils
 
 from .base_mbc import BaseMBC
 
diff --git a/pyboy/core/cartridge/rtc.pxd b/pyboy/core/cartridge/rtc.pxd
index db7dcd6ea..684695a01 100644
--- a/pyboy/core/cartridge/rtc.pxd
+++ b/pyboy/core/cartridge/rtc.pxd
@@ -30,7 +30,7 @@ cdef class RTC:
 
     cdef void stop(self) noexcept
     cdef void save_state(self, IntIOInterface) noexcept
-    cdef void load_state(self, IntIOInterface, int) noexcept
+    cdef int load_state(self, IntIOInterface, int) except -1
     @cython.locals(days=uint64_t)
     cdef void latch_rtc(self) noexcept nogil
     cdef void writecommand(self, uint8_t) noexcept nogil
diff --git a/pyboy/core/cartridge/rtc.py b/pyboy/core/cartridge/rtc.py
index b3050f8c4..967681847 100644
--- a/pyboy/core/cartridge/rtc.py
+++ b/pyboy/core/cartridge/rtc.py
@@ -7,7 +7,6 @@
 import time
 
 import pyboy
-from pyboy import utils
 from pyboy.utils import STATE_VERSION, IntIOWrapper
 
 logger = pyboy.logging.get_logger(__name__)
@@ -40,13 +39,16 @@ def stop(self):
             self.save_state(IntIOWrapper(f))
 
     def save_state(self, f):
-        for b in struct.pack("f", self.timezero):
+        for b in struct.pack("d", self.timezero):
             f.write(b)
         f.write(self.halt)
         f.write(self.day_carry)
 
     def load_state(self, f, state_version):
-        self.timezero = int(struct.unpack("f", bytes([f.read() for _ in range(4)]))[0])
+        if state_version <= 13:
+            self.timezero = int(struct.unpack("f", bytes([f.read() for _ in range(4)]))[0])
+        else:
+            self.timezero = struct.unpack("d", bytes([f.read() for _ in range(8)]))[0]
         self.halt = f.read()
         self.day_carry = f.read()
 
diff --git a/pyboy/core/cpu.pxd b/pyboy/core/cpu.pxd
index c53e51f16..5c41e4c2a 100644
--- a/pyboy/core/cpu.pxd
+++ b/pyboy/core/cpu.pxd
@@ -4,7 +4,7 @@
 #
 
 
-from libc.stdint cimport int16_t, int64_t, uint8_t, uint16_t, int64_t
+from libc.stdint cimport int16_t, int64_t, uint8_t, uint16_t
 
 cimport pyboy.core.mb
 from pyboy.utils cimport IntIOInterface
@@ -41,7 +41,7 @@ cdef class CPU:
     @cython.locals(_cycles0=int64_t)
     cdef int tick(self, int64_t) noexcept nogil
     cdef void save_state(self, IntIOInterface) noexcept
-    cdef void load_state(self, IntIOInterface, int) noexcept
+    cdef int load_state(self, IntIOInterface, int) except -1
 
     # Only char (8-bit) needed, but I'm not sure all intermittent
     # results do not overflow
@@ -53,4 +53,4 @@ cdef class CPU:
 
     cdef pyboy.core.mb.Motherboard mb
 
-    cdef dump_state(self, str) noexcept with gil
+    cdef str dump_state(self, str) with gil
diff --git a/pyboy/core/cpu.py b/pyboy/core/cpu.py
index c794d20f3..902b2d91c 100644
--- a/pyboy/core/cpu.py
+++ b/pyboy/core/cpu.py
@@ -2,17 +2,13 @@
 # License: See LICENSE.md file
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
-
-import array
-
-from pyboy import utils
+import pyboy
 
 from . import opcodes
 
 FLAGC, FLAGH, FLAGN, FLAGZ = range(4, 8)
 INTR_VBLANK, INTR_LCDC, INTR_TIMER, INTR_SERIAL, INTR_HIGHTOLOW = [1 << x for x in range(5)]
 
-import pyboy
 
 logger = pyboy.logging.get_logger(__name__)
 
diff --git a/pyboy/core/interaction.pxd b/pyboy/core/interaction.pxd
index f9ee33978..9e2d83316 100644
--- a/pyboy/core/interaction.pxd
+++ b/pyboy/core/interaction.pxd
@@ -21,4 +21,4 @@ cdef class Interaction:
     cdef bint key_event(self, WindowEvent) noexcept
     cdef uint8_t pull(self, uint8_t) noexcept nogil
     cdef void save_state(self, IntIOInterface) noexcept
-    cdef void load_state(self, IntIOInterface, int) noexcept
+    cdef int load_state(self, IntIOInterface, int) except -1
diff --git a/pyboy/core/lcd.pxd b/pyboy/core/lcd.pxd
index 08c769fdc..e257b1d91 100644
--- a/pyboy/core/lcd.pxd
+++ b/pyboy/core/lcd.pxd
@@ -62,7 +62,7 @@ cdef class LCD:
     cdef int64_t cycles_to_mode0(self) noexcept nogil
 
     cdef void save_state(self, IntIOInterface) noexcept
-    cdef void load_state(self, IntIOInterface, int) noexcept
+    cdef int load_state(self, IntIOInterface, int) except -1
 
     cdef inline (int, int) getwindowpos(self) noexcept nogil
     cdef inline (int, int) getviewport(self) noexcept nogil
@@ -94,6 +94,8 @@ cdef class STATRegister:
     cdef uint8_t set_mode(self, uint8_t) noexcept nogil
     cdef uint8_t update_LYC(self, uint8_t, uint8_t) noexcept nogil
     cdef void set(self, uint64_t) noexcept nogil
+    cdef void save_state(self, IntIOInterface) noexcept
+    cdef int load_state(self, IntIOInterface, int) except -1
 
 cdef class LCDCRegister:
     cdef uint8_t value
@@ -113,7 +115,7 @@ cdef class LCDCRegister:
     cdef uint16_t backgroundmap_offset
     cdef uint16_t windowmap_offset
 
-    cpdef int _get_sprite_height(self)
+    cpdef int _get_sprite_height(self) noexcept
 
 cdef class Renderer:
     cdef uint8_t[:] _tilecache0_state, _tilecache1_state, _spritecache0_state, _spritecache1_state
@@ -164,13 +166,10 @@ cdef class Renderer:
 
     @cython.locals(tile_addr=uint64_t, tile=int)
     cdef inline (int, int, uint16_t) _get_tile(self, uint8_t, uint8_t, uint16_t, LCD) noexcept nogil
-    cdef inline (int, int, uint8_t, bint, uint32_t, bint) _get_tile_cgb(self, uint8_t, uint8_t, uint16_t, LCD) noexcept nogil
     @cython.locals(col0=uint8_t)
     cdef inline void _pixel(self, uint8_t[:,:], uint32_t, int, int, int, int, uint32_t) noexcept nogil
     cdef int scanline_background(self, int, int, int, int, int, LCD) noexcept nogil
     cdef int scanline_window(self, int, int, int, int, int, LCD) noexcept nogil
-    cdef int scanline_background_cgb(self, int, int, int, int, int, LCD) noexcept nogil
-    cdef int scanline_window_cgb(self, int, int, int, int, int, LCD) noexcept nogil
     cdef int scanline_blank(self, int, int, int, LCD) noexcept nogil
 
     @cython.locals(
@@ -252,17 +251,8 @@ cdef class Renderer:
     cdef inline uint64_t colorcode(self, uint64_t, uint64_t) noexcept nogil
 
     cdef void save_state(self, IntIOInterface) noexcept
-    cdef void load_state(self, IntIOInterface, int) noexcept
+    cdef int load_state(self, IntIOInterface, int) except -1
 
-    @cython.locals(
-        tile_num = uint8_t,
-        palette = uint8_t,
-        vbank = uint8_t,
-        horiflip = uint8_t,
-        vertflip = uint8_t,
-        bg_priority = uint8_t,
-    )
-    cdef inline (int, int, int, int, int) _cgb_get_background_map_attributes(self, LCD, int) noexcept nogil
 
 cdef class CGBLCD(LCD):
     pass
@@ -274,7 +264,17 @@ cdef class CGBLCD(LCD):
     # cdef PaletteColorRegister ocpd
 
 cdef class CGBRenderer(Renderer):
-    pass
+
+    @cython.locals(
+        tile_num = uint8_t,
+        palette = uint8_t,
+        vbank = uint8_t,
+        horiflip = uint8_t,
+        vertflip = uint8_t,
+        bg_priority = uint8_t,
+    )
+    cdef inline (int, int, int, int, int) _cgb_get_background_map_attributes(self, LCD, int) noexcept nogil
+    cdef inline (int, int, uint8_t, bint, uint32_t, bint) _get_tile_cgb(self, uint8_t, uint8_t, uint16_t, LCD) noexcept nogil
 
 cdef class VBKregister:
     cdef uint8_t active_bank
@@ -294,7 +294,7 @@ cdef class PaletteIndexRegister:
     cdef void shouldincrement(self) noexcept nogil
 
     cdef void save_state(self, IntIOInterface) noexcept
-    cdef void load_state(self, IntIOInterface, int) noexcept
+    cdef int load_state(self, IntIOInterface, int) except -1
 
 cdef class PaletteColorRegister:
     cdef uint16_t[8 * 4] palette_mem
@@ -307,4 +307,4 @@ cdef class PaletteColorRegister:
     cdef inline uint32_t getcolor(self, uint8_t, uint8_t) noexcept nogil
 
     cdef void save_state(self, IntIOInterface) noexcept
-    cdef void load_state(self, IntIOInterface, int) noexcept
+    cdef int load_state(self, IntIOInterface, int) except -1
diff --git a/pyboy/core/lcd.py b/pyboy/core/lcd.py
index f0f0cac9c..aaf21f179 100644
--- a/pyboy/core/lcd.py
+++ b/pyboy/core/lcd.py
@@ -4,12 +4,11 @@
 #
 
 from array import array
-from copy import deepcopy
 from ctypes import c_void_p
 from random import getrandbits
 
 import pyboy
-from pyboy import utils
+from pyboy.utils import PyBoyException
 
 logger = pyboy.logging.get_logger(__name__)
 
@@ -175,7 +174,7 @@ def tick(self, _cycles):
                     wx, wy = self.getwindowpos()
                     self._scanlineparameters[self.LY][0] = bx
                     self._scanlineparameters[self.LY][1] = by
-                    self._scanlineparameters[self.LY][2] = wx
+                    self._scanlineparameters[self.LY][2] = wx + 7
                     self._scanlineparameters[self.LY][3] = wy
                     self._scanlineparameters[self.LY][4] = self._LCDC.tiledata_select
 
@@ -211,7 +210,7 @@ def tick(self, _cycles):
                 self.renderer.blank_screen(self)
 
         self._cycles_to_interrupt = self.clock_target - self.clock
-        self._cycles_to_frame = self.clock - FRAME_CYCLES
+        self._cycles_to_frame = FRAME_CYCLES - self.clock
         return interrupt_flag
 
     def save_state(self, f):
@@ -226,7 +225,7 @@ def save_state(self, f):
         f.write(self.OBP0.value)
         f.write(self.OBP1.value)
 
-        f.write(self._STAT.value)
+        self._STAT.save_state(f)
         f.write(self.LY)
         f.write(self.LYC)
 
@@ -238,14 +237,15 @@ def save_state(self, f):
         for y in range(ROWS):
             f.write(self._scanlineparameters[y][0])
             f.write(self._scanlineparameters[y][1])
-            # We store (WX - 7). We add 7 and mask 8 bits to make it easier to serialize
-            f.write((self._scanlineparameters[y][2] + 7) & 0xFF)
+            # We store (WX + 7). We added 7 earlier to make it easier to serialize
+            f.write(self._scanlineparameters[y][2])
             f.write(self._scanlineparameters[y][3])
             f.write(self._scanlineparameters[y][4])
 
         # CGB
         f.write(self.cgb)
         f.write(self.double_speed)
+        f.write(self.frame_done)
         f.write_64bit(self.last_cycles)
         f.write_64bit(self.clock)
         f.write_64bit(self.clock_target)
@@ -273,7 +273,7 @@ def load_state(self, f, state_version):
         self.OBP1.set(f.read())
 
         if state_version >= 5:
-            self.set_stat(f.read())
+            self._STAT.load_state(f, state_version)
             self.LY = f.read()
             self.LYC = f.read()
 
@@ -287,7 +287,7 @@ def load_state(self, f, state_version):
                 self._scanlineparameters[y][0] = f.read()
                 self._scanlineparameters[y][1] = f.read()
                 # Restore (WX - 7) as described above
-                self._scanlineparameters[y][2] = (f.read() - 7) & 0xFF
+                self._scanlineparameters[y][2] = f.read()
                 self._scanlineparameters[y][3] = f.read()
                 if state_version > 3:
                     self._scanlineparameters[y][4] = f.read()
@@ -295,17 +295,21 @@ def load_state(self, f, state_version):
         # CGB
         if state_version >= 8:
             _cgb = f.read()
-            if self.cgb != _cgb:
-                logger.critical("Loading state which is not CGB, but PyBoy is loaded in CGB mode!")
-                return
+            if self.cgb and not _cgb:
+                raise PyBoyException("Loading state which *is not* CGB-mode, but PyBoy *is* in CGB mode!")
+            if not self.cgb and _cgb:
+                raise PyBoyException("Loading state which *is* CGB-mode, but PyBoy *is not* in CGB mode!")
             self.cgb = _cgb
             self.double_speed = f.read()
+            if state_version >= 13:
+                self.frame_done = f.read()
 
             if state_version >= 12:
                 self.last_cycles = f.read_64bit()
             self.clock = f.read_64bit()
             self.clock_target = f.read_64bit()
-            self._cycles_to_frame = self.clock - FRAME_CYCLES
+            self._cycles_to_interrupt = self.clock_target - self.clock
+            self._cycles_to_frame = FRAME_CYCLES - self.clock
             self.next_stat_mode = f.read()
 
             if self.cgb:
@@ -383,6 +387,14 @@ def set_mode(self, mode):
             return INTR_LCDC
         return 0
 
+    def save_state(self, f):
+        f.write(self.value)
+
+    def load_state(self, f, state_version):
+        value = f.read()
+        self.value = value
+        self._mode = value & 0b11
+
 
 class LCDCRegister:
     def __init__(self, value):
@@ -478,16 +490,6 @@ def __init__(self, cgb):
 
         self.ly_window = 0
 
-    def _cgb_get_background_map_attributes(self, lcd, i):
-        tile_num = lcd.VRAM1[i]
-        palette = tile_num & 0b111
-        vbank = (tile_num >> 3) & 1
-        horiflip = (tile_num >> 5) & 1
-        vertflip = (tile_num >> 6) & 1
-        bg_priority = (tile_num >> 7) & 1
-
-        return palette, vbank, horiflip, vertflip, bg_priority
-
     def scanline(self, lcd, y):
         if lcd.disable_renderer:
             return
@@ -496,36 +498,21 @@ def scanline(self, lcd, y):
         wx, wy = lcd.getwindowpos()
 
         x = 0
-        if not self.cgb:
-            if lcd._LCDC.window_enable and wy <= y and wx < COLS:
-                # Window has it's own internal line counter. It's only incremented whenever the window is drawing something on the screen.
-                self.ly_window += 1
-
-                # Before window
-                if wx > x:
-                    x += self.scanline_background(y, x, bx, by, wx, lcd)
-
-                # Window hit
-                self.scanline_window(y, x, wx, wy, COLS - x, lcd)
-            elif lcd._LCDC.background_enable:
-                # No window
-                self.scanline_background(y, x, bx, by, COLS, lcd)
-            else:
-                self.scanline_blank(y, x, COLS, lcd)
+        if lcd._LCDC.window_enable and wy <= y and wx < COLS:
+            # Window has it's own internal line counter. It's only incremented whenever the window is drawing something on the screen.
+            self.ly_window += 1
+
+            # Before window
+            if wx > x:
+                x += self.scanline_background(y, x, bx, by, wx, lcd)
+
+            # Window hit
+            self.scanline_window(y, x, wx, wy, COLS - x, lcd)
+        elif lcd._LCDC.background_enable:
+            # No window
+            self.scanline_background(y, x, bx, by, COLS, lcd)
         else:
-            if lcd._LCDC.window_enable and wy <= y and wx < COLS:
-                # Window has it's own internal line counter. It's only incremented whenever the window is drawing something on the screen.
-                self.ly_window += 1
-
-                # Before window
-                if wx > x:
-                    x += self.scanline_background_cgb(y, x, bx, by, wx, lcd)
-
-                # Window hit
-                self.scanline_window_cgb(y, x, wx, wy, COLS - x, lcd)
-            else:  # background_enable doesn't exist for CGB. It works as master priority instead
-                # No window
-                self.scanline_background_cgb(y, x, bx, by, COLS, lcd)
+            self.scanline_blank(y, x, COLS, lcd)
 
         if y == 143:
             # Reset at the end of a frame. We set it to -1, so it will be 0 after the first increment
@@ -544,21 +531,6 @@ def _get_tile(self, y, x, offset, lcd):
         yy = 8 * tile + y % 8
         return tile, yy, tile_addr
 
-    def _get_tile_cgb(self, y, x, offset, lcd):
-        tile, yy, tile_addr = self._get_tile(y, x, offset, lcd)
-
-        palette, vbank, horiflip, vertflip, bg_priority = self._cgb_get_background_map_attributes(lcd, tile_addr)
-
-        bg_priority_apply = 0
-        if bg_priority:
-            # We hide extra rendering information in the lower 8 bits (A) of the 32-bit RGBA format
-            bg_priority_apply = BG_PRIORITY_FLAG
-
-        if vertflip:
-            yy = 8 * tile + (7 - (y) % 8)
-
-        return tile, yy, palette, horiflip, bg_priority_apply, vbank
-
     def _pixel(self, tilecache, pixel, x, y, xx, yy, bg_priority_apply):
         col0 = (tilecache[yy, xx] == 0) & 1
         self._screenbuffer[y, x] = pixel
@@ -576,29 +548,6 @@ def scanline_window(self, y, _x, wx, wy, cols, lcd):
             self._pixel(self._tilecache0, pixel, x, y, xx, yy, 0)
         return cols
 
-    def scanline_window_cgb(self, y, _x, wx, wy, cols, lcd):
-        bg_priority_apply = 0
-        for x in range(_x, _x + cols):
-            xx = (x - wx) % 8
-            if xx == 0 or x == _x:
-                wt, yy, w_palette, w_horiflip, bg_priority_apply, vbank = self._get_tile_cgb(
-                    self.ly_window, x - wx, lcd._LCDC.windowmap_offset, lcd
-                )
-                # NOTE: Not allowed to return memoryview in Cython tuple
-                if vbank:
-                    self.update_tilecache1(lcd, wt, vbank)
-                    tilecache = self._tilecache1
-                else:
-                    self.update_tilecache0(lcd, wt, vbank)
-                    tilecache = self._tilecache0
-
-            if w_horiflip:
-                xx = 7 - xx
-
-            pixel = lcd.bcpd.getcolor(w_palette, tilecache[yy, xx])
-            self._pixel(tilecache, pixel, x, y, xx, yy, bg_priority_apply)
-        return cols
-
     def scanline_background(self, y, _x, bx, by, cols, lcd):
         for x in range(_x, _x + cols):
             # bx mask used for the half tile at the left side when scrolling
@@ -614,29 +563,6 @@ def scanline_background(self, y, _x, bx, by, cols, lcd):
             self._pixel(self._tilecache0, pixel, x, y, xx, yy, 0)
         return cols
 
-    def scanline_background_cgb(self, y, _x, bx, by, cols, lcd):
-        for x in range(_x, _x + cols):
-            # bx mask used for the half tile at the left side when scrolling
-            xx = (x + (bx & 0b111)) % 8
-            if xx == 0 or x == 0:
-                bt, yy, b_palette, b_horiflip, bg_priority_apply, vbank = self._get_tile_cgb(
-                    y + by, x + bx, lcd._LCDC.backgroundmap_offset, lcd
-                )
-                # NOTE: Not allowed to return memoryview in Cython tuple
-                if vbank:
-                    self.update_tilecache1(lcd, bt, vbank)
-                    tilecache = self._tilecache1
-                else:
-                    self.update_tilecache0(lcd, bt, vbank)
-                    tilecache = self._tilecache0
-
-            if b_horiflip:
-                xx = 7 - xx
-
-            pixel = lcd.bcpd.getcolor(b_palette, tilecache[yy, xx])
-            self._pixel(tilecache, pixel, x, y, xx, yy, bg_priority_apply)
-        return cols
-
     def scanline_blank(self, y, _x, cols, lcd):
         # If background is disabled, it becomes white
         for x in range(_x, _x + cols):
@@ -919,6 +845,104 @@ def __init__(self):
         self._tilecache1_state = array("B", [0] * TILES)
         self.clear_cache()
 
+    def _cgb_get_background_map_attributes(self, lcd, i):
+        tile_num = lcd.VRAM1[i]
+        palette = tile_num & 0b111
+        vbank = (tile_num >> 3) & 1
+        horiflip = (tile_num >> 5) & 1
+        vertflip = (tile_num >> 6) & 1
+        bg_priority = (tile_num >> 7) & 1
+
+        return palette, vbank, horiflip, vertflip, bg_priority
+
+    def _get_tile_cgb(self, y, x, offset, lcd):
+        tile, yy, tile_addr = self._get_tile(y, x, offset, lcd)
+
+        palette, vbank, horiflip, vertflip, bg_priority = self._cgb_get_background_map_attributes(lcd, tile_addr)
+
+        bg_priority_apply = 0
+        if bg_priority:
+            # We hide extra rendering information in the lower 8 bits (A) of the 32-bit RGBA format
+            bg_priority_apply = BG_PRIORITY_FLAG
+
+        if vertflip:
+            yy = 8 * tile + (7 - (y) % 8)
+
+        return tile, yy, palette, horiflip, bg_priority_apply, vbank
+
+    def scanline_window(self, y, _x, wx, wy, cols, lcd):
+        bg_priority_apply = 0
+        for x in range(_x, _x + cols):
+            xx = (x - wx) % 8
+            if xx == 0 or x == _x:
+                wt, yy, w_palette, w_horiflip, bg_priority_apply, vbank = self._get_tile_cgb(
+                    self.ly_window, x - wx, lcd._LCDC.windowmap_offset, lcd
+                )
+                # NOTE: Not allowed to return memoryview in Cython tuple
+                if vbank:
+                    self.update_tilecache1(lcd, wt, vbank)
+                    tilecache = self._tilecache1
+                else:
+                    self.update_tilecache0(lcd, wt, vbank)
+                    tilecache = self._tilecache0
+
+            if w_horiflip:
+                xx = 7 - xx
+
+            pixel = lcd.bcpd.getcolor(w_palette, tilecache[yy, xx])
+            self._pixel(tilecache, pixel, x, y, xx, yy, bg_priority_apply)
+        return cols
+
+    def scanline_background(self, y, _x, bx, by, cols, lcd):
+        for x in range(_x, _x + cols):
+            # bx mask used for the half tile at the left side when scrolling
+            xx = (x + (bx & 0b111)) % 8
+            if xx == 0 or x == 0:
+                bt, yy, b_palette, b_horiflip, bg_priority_apply, vbank = self._get_tile_cgb(
+                    y + by, x + bx, lcd._LCDC.backgroundmap_offset, lcd
+                )
+                # NOTE: Not allowed to return memoryview in Cython tuple
+                if vbank:
+                    self.update_tilecache1(lcd, bt, vbank)
+                    tilecache = self._tilecache1
+                else:
+                    self.update_tilecache0(lcd, bt, vbank)
+                    tilecache = self._tilecache0
+
+            if b_horiflip:
+                xx = 7 - xx
+
+            pixel = lcd.bcpd.getcolor(b_palette, tilecache[yy, xx])
+            self._pixel(tilecache, pixel, x, y, xx, yy, bg_priority_apply)
+        return cols
+
+    def scanline(self, lcd, y):
+        if lcd.disable_renderer:
+            return
+
+        bx, by = lcd.getviewport()
+        wx, wy = lcd.getwindowpos()
+
+        x = 0
+
+        if lcd._LCDC.window_enable and wy <= y and wx < COLS:
+            # Window has it's own internal line counter. It's only incremented whenever the window is drawing something on the screen.
+            self.ly_window += 1
+
+            # Before window
+            if wx > x:
+                x += self.scanline_background(y, x, bx, by, wx, lcd)
+
+            # Window hit
+            self.scanline_window(y, x, wx, wy, COLS - x, lcd)
+        else:  # background_enable doesn't exist for CGB. It works as master priority instead
+            # No window
+            self.scanline_background(y, x, bx, by, COLS, lcd)
+
+        if y == 143:
+            # Reset at the end of a frame. We set it to -1, so it will be 0 after the first increment
+            self.ly_window = -1
+
     def clear_cache(self):
         self.clear_tilecache0()
         self.clear_tilecache1()
diff --git a/pyboy/core/mb.pxd b/pyboy/core/mb.pxd
index 065c12b6d..bf6f0da0c 100644
--- a/pyboy/core/mb.pxd
+++ b/pyboy/core/mb.pxd
@@ -89,4 +89,4 @@ cdef class HDMA:
     cdef int tick(self, Motherboard) noexcept nogil
 
     cdef void save_state(self, IntIOInterface) noexcept
-    cdef void load_state(self, IntIOInterface, int) noexcept
+    cdef int load_state(self, IntIOInterface, int) except -1
diff --git a/pyboy/core/mb.py b/pyboy/core/mb.py
index e43db0c1a..cb3db4f53 100644
--- a/pyboy/core/mb.py
+++ b/pyboy/core/mb.py
@@ -3,15 +3,14 @@
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
 
-from pyboy import utils
-from pyboy.utils import STATE_VERSION
+import pyboy
+from pyboy.utils import STATE_VERSION, PyBoyException, PyBoyOutOfBoundsException
 
 from . import bootrom, cartridge, cpu, interaction, lcd, ram, sound, timer
 
 INTR_VBLANK, INTR_LCDC, INTR_TIMER, INTR_SERIAL, INTR_HIGHTOLOW = [1 << x for x in range(5)]
 OPCODE_BRK = 0xDB
 
-import pyboy
 
 logger = pyboy.logging.get_logger(__name__)
 
@@ -73,6 +72,8 @@ def __init__(
 
         if self.cgb:
             self.hdma = HDMA()
+        else:
+            self.hdma = None
 
         self.bootrom_enabled = True
         self.serialbuffer = [0] * 1024
@@ -88,6 +89,7 @@ def switch_speed(self):
         if bit0 == 1:
             self.double_speed = not self.double_speed
             self.lcd.double_speed = self.double_speed
+            logger.debug("CGB double speed is now: %d", self.double_speed)
             self.key1 ^= 0b10000001
 
     def breakpoint_add(self, bank, addr):
@@ -98,12 +100,16 @@ def breakpoint_add(self, bank, addr):
             self.bootrom.bootrom[addr] = OPCODE_BRK
         elif addr < 0x4000:
             if self.cartridge.external_rom_count < bank:
-                raise Exception(f"ROM bank out of bounds. Asked for {bank}, max is {self.cartridge.external_rom_count}")
+                raise PyBoyOutOfBoundsException(
+                    f"ROM bank out of bounds. Asked for {bank}, max is {self.cartridge.external_rom_count}"
+                )
             opcode = self.cartridge.rombanks[bank, addr]
             self.cartridge.rombanks[bank, addr] = OPCODE_BRK
         elif 0x4000 <= addr < 0x8000:
             if self.cartridge.external_rom_count < bank:
-                raise Exception(f"ROM bank out of bounds. Asked for {bank}, max is {self.cartridge.external_rom_count}")
+                raise PyBoyOutOfBoundsException(
+                    f"ROM bank out of bounds. Asked for {bank}, max is {self.cartridge.external_rom_count}"
+                )
             opcode = self.cartridge.rombanks[bank, addr - 0x4000]
             self.cartridge.rombanks[bank, addr - 0x4000] = OPCODE_BRK
         elif 0x8000 <= addr < 0xA000:
@@ -115,14 +121,18 @@ def breakpoint_add(self, bank, addr):
                 self.lcd.VRAM1[addr - 0x8000] = OPCODE_BRK
         elif 0xA000 <= addr < 0xC000:
             if self.cartridge.external_ram_count < bank:
-                raise Exception(f"RAM bank out of bounds. Asked for {bank}, max is {self.cartridge.external_ram_count}")
+                raise PyBoyOutOfBoundsException(
+                    f"RAM bank out of bounds. Asked for {bank}, max is {self.cartridge.external_ram_count}"
+                )
             opcode = self.cartridge.rambanks[bank, addr - 0xA000]
             self.cartridge.rambanks[bank, addr - 0xA000] = OPCODE_BRK
         elif 0xC000 <= addr <= 0xE000:
             opcode = self.ram.internal_ram0[addr - 0xC000]
             self.ram.internal_ram0[addr - 0xC000] = OPCODE_BRK
         else:
-            raise Exception("Unsupported breakpoint address. If this a mistake, reach out to the developers")
+            raise PyBoyOutOfBoundsException(
+                "Unsupported breakpoint address. If this a mistake, reach out to the developers"
+            )
 
         self.breakpoints[(bank, addr)] = opcode
 
@@ -240,13 +250,21 @@ def load_state(self, f):
             logger.debug("State version: 0-1")
             # HACK: The byte wasn't a state version, but the bootrom flag
             self.bootrom_enabled = state_version
+
+        if state_version < STATE_VERSION:
+            logger.warning("Loading state from an older version of PyBoy. This might cause compatibility issues.")
+        elif state_version > STATE_VERSION:
+            raise PyBoyException("Cannot load state from a newer version of PyBoy")
+
         if state_version >= 8:
             self.key1 = f.read()
             self.double_speed = f.read()
             _cgb = f.read()
-            if self.cgb != _cgb:
-                raise Exception("Loading state which is not CGB, but PyBoy is loaded in CGB mode!")
-            self.cgb = _cgb
+            if self.cgb and not _cgb:
+                raise PyBoyException("Loading state which *is not* CGB-mode, but PyBoy *is* in CGB mode!")
+            if not self.cgb and _cgb:
+                raise PyBoyException("Loading state which *is* CGB-mode, but PyBoy *is not* in CGB mode!")
+
             if self.cgb:
                 self.hdma.load_state(f, state_version)
         self.cpu.load_state(f, state_version)
@@ -302,6 +320,8 @@ def tick(self):
                         mode0_cycles,
                     ),
                 )
+                if self.breakpoint_singlestep:
+                    cycles_target = 4
                 self.cpu.tick(cycles_target)
 
             # TODO: Support General Purpose DMA
diff --git a/pyboy/core/ram.pxd b/pyboy/core/ram.pxd
index e1b15a243..dfbd79470 100644
--- a/pyboy/core/ram.pxd
+++ b/pyboy/core/ram.pxd
@@ -16,7 +16,7 @@ cdef class RAM:
     @cython.locals(n=int)
     cdef void save_state(self, IntIOInterface) noexcept
     @cython.locals(n=int)
-    cdef void load_state(self, IntIOInterface, int) noexcept
+    cdef int load_state(self, IntIOInterface, int) except -1
 
     cdef uint8_t[:] internal_ram0 # Dynamic size for DMG/CGB
     cdef uint8_t[0x60] non_io_internal_ram0
diff --git a/pyboy/core/sound.py b/pyboy/core/sound.py
index f8b187de0..6a7404280 100644
--- a/pyboy/core/sound.py
+++ b/pyboy/core/sound.py
@@ -10,7 +10,6 @@
 from array import array
 from ctypes import c_void_p
 
-from pyboy import utils
 
 try:
     import sdl2
diff --git a/pyboy/core/timer.pxd b/pyboy/core/timer.pxd
index b444294e8..4dad6242f 100644
--- a/pyboy/core/timer.pxd
+++ b/pyboy/core/timer.pxd
@@ -26,4 +26,4 @@ cdef class Timer:
     cdef bint tick(self, uint64_t) noexcept nogil
 
     cdef void save_state(self, IntIOInterface) noexcept
-    cdef void load_state(self, IntIOInterface, int) noexcept
+    cdef int load_state(self, IntIOInterface, int) except -1
diff --git a/pyboy/core/timer.py b/pyboy/core/timer.py
index 182931127..932a6f068 100644
--- a/pyboy/core/timer.py
+++ b/pyboy/core/timer.py
@@ -73,6 +73,7 @@ def save_state(self, f):
         f.write(self.TMA)
         f.write(self.TAC)
         f.write_64bit(self.last_cycles)
+        f.write_64bit(self._cycles_to_interrupt)
 
     def load_state(self, f, state_version):
         self.DIV = f.read()
@@ -83,3 +84,5 @@ def load_state(self, f, state_version):
         self.TAC = f.read()
         if state_version >= 12:
             self.last_cycles = f.read_64bit()
+        if state_version >= 13:
+            self._cycles_to_interrupt = f.read_64bit()
diff --git a/pyboy/logging/_logging.py b/pyboy/logging/_logging.py
index 1456ad7bc..d3bf39170 100644
--- a/pyboy/logging/_logging.py
+++ b/pyboy/logging/_logging.py
@@ -1,4 +1,4 @@
-from . import CRITICAL, DEBUG, ERROR, INFO, WARNING, _log, get_log_level
+from . import CRITICAL, DEBUG, ERROR, INFO, WARNING, _log
 
 
 class Logger:
diff --git a/pyboy/plugins/__init__.py b/pyboy/plugins/__init__.py
index bc4e61598..4ab8e27cf 100644
--- a/pyboy/plugins/__init__.py
+++ b/pyboy/plugins/__init__.py
@@ -8,18 +8,17 @@
 
 __pdoc__ = {
     # docs exclude
-    "disable_input": False,
-    "rewind": False,
-    "window_sdl2": False,
-    "screenshot_recorder": False,
+    "auto_pause": False,
+    "debug": False,
     "debug_prompt": False,
+    "record_replay": False,
+    "rewind": False,
     "screen_recorder": False,
-    "debug": False,
+    "screenshot_recorder": False,
+    "window_null": False,
+    "window_open_gl": False,
+    "window_sdl2": False,
     "manager": False,
-    "record_replay": False,
     "manager_gen": False,
-    "window_open_gl": False,
-    "auto_pause": False,
-    "window_null": False,
     # docs exclude end
 }
diff --git a/pyboy/plugins/auto_pause.py b/pyboy/plugins/auto_pause.py
index 656ef73f3..f6a70a598 100644
--- a/pyboy/plugins/auto_pause.py
+++ b/pyboy/plugins/auto_pause.py
@@ -12,9 +12,9 @@ class AutoPause(PyBoyPlugin):
     def handle_events(self, events):
         for event in events:
             if event == WindowEvent.WINDOW_UNFOCUS:
-                events.append(WindowEvent.PAUSE)
+                events.append(WindowEvent(WindowEvent.PAUSE))
             elif event == WindowEvent.WINDOW_FOCUS:
-                events.append(WindowEvent.UNPAUSE)
+                events.append(WindowEvent(WindowEvent.UNPAUSE))
         return events
 
     def enabled(self):
diff --git a/pyboy/plugins/base_plugin.pxd b/pyboy/plugins/base_plugin.pxd
index cc65f0ca3..1d804da47 100644
--- a/pyboy/plugins/base_plugin.pxd
+++ b/pyboy/plugins/base_plugin.pxd
@@ -6,7 +6,7 @@
 cimport cython
 cimport numpy as cnp
 from cpython.array cimport array
-from libc.stdint cimport uint8_t, uint16_t, uint32_t, int64_t
+from libc.stdint cimport int64_t, uint8_t, uint16_t, uint32_t
 
 from pyboy.core.lcd cimport Renderer
 from pyboy.core.mb cimport Motherboard
@@ -24,9 +24,9 @@ cdef class PyBoyPlugin:
     cdef bint cgb
     cdef dict pyboy_argv
     @cython.locals(event=WindowEvent)
-    cdef list handle_events(self, list) noexcept
+    cdef list handle_events(self, list)
     cdef void post_tick(self) noexcept
-    cdef str window_title(self) noexcept
+    cdef str window_title(self)
     cdef void stop(self) noexcept
     cpdef bint enabled(self) noexcept
 
@@ -56,16 +56,16 @@ cdef class PyBoyGameWrapper(PyBoyPlugin):
     cdef array _cached_game_area_tiles_raw
     cdef object _cached_game_area_tiles
     @cython.locals(xx=int, yy=int, width=int, height=int, SCX=int, SCY=int, _x=int, _y=int)
-    cdef cnp.ndarray[cnp.uint32_t, ndim=2] _game_area_tiles(self) noexcept
+    cdef cnp.ndarray[cnp.uint32_t, ndim=2] _game_area_tiles(self)
 
     cdef bint game_area_follow_scxy
     cdef tuple game_area_section
     @cython.locals(tiles_matrix=cnp.ndarray, sprites=list, xx=int, yy=int, width=int, height=int, _x=int, _y=int)
-    cpdef cnp.ndarray[cnp.uint32_t, ndim=2] game_area(self) noexcept
+    cpdef cnp.ndarray[cnp.uint32_t, ndim=2] game_area(self)
 
     cdef bint _sprite_cache_invalid
     cdef list _cached_sprites_on_screen
-    cpdef list _sprites_on_screen(self) noexcept
+    cpdef list _sprites_on_screen(self)
 
     cdef object saved_state
 
diff --git a/pyboy/plugins/base_plugin.py b/pyboy/plugins/base_plugin.py
index aa5ea583e..d1369a401 100644
--- a/pyboy/plugins/base_plugin.py
+++ b/pyboy/plugins/base_plugin.py
@@ -20,16 +20,10 @@
 
 import pyboy
 from pyboy.api.constants import SPRITES, TILES_CGB
+from pyboy import utils
 
 logger = pyboy.logging.get_logger(__name__)
 
-try:
-    from cython import compiled
-
-    cythonmode = compiled
-except ImportError:
-    cythonmode = False
-
 ROWS, COLS = 144, 160
 
 
@@ -37,10 +31,11 @@ class PyBoyPlugin:
     argv = []
 
     def __init__(self, pyboy, mb, pyboy_argv):
-        if not cythonmode:
+        if not utils.cython_compiled:
             self.pyboy = pyboy
             self.mb = mb
             self.pyboy_argv = pyboy_argv
+        self.cgb = mb.cgb
 
     def __cinit__(self, pyboy, mb, pyboy_argv, *args, **kwargs):
         self.pyboy = pyboy
@@ -80,7 +75,7 @@ def __init__(self, pyboy, mb, pyboy_argv, *args, **kwargs):
         logger.debug("Scale: x%d (%d, %d)", self.scale, self._scaledresolution[0], self._scaledresolution[1])
 
         self.enable_title = True
-        if not cythonmode:
+        if not utils.cython_compiled:
             self.renderer = mb.lcd.renderer
 
     def __cinit__(self, *args, **kwargs):
@@ -89,7 +84,7 @@ def __cinit__(self, *args, **kwargs):
     def frame_limiter(self, speed):
         self._ftime += int((1.0 / (60.0 * speed)) * 1_000_000_000)
         now = time.perf_counter_ns()
-        if self._ftime > now:
+        if speed > 0 and self._ftime > now:
             delay = (self._ftime - now) // 1_000_000
             time.sleep(delay / 1000)
         else:
@@ -115,7 +110,7 @@ class PyBoyGameWrapper(PyBoyPlugin):
 
     def __init__(self, *args, game_area_section=(0, 0, 32, 32), game_area_follow_scxy=False, **kwargs):
         super().__init__(*args, **kwargs)
-        if not cythonmode:
+        if not utils.cython_compiled:
             self.tilemap_background = self.pyboy.tilemap_background
             self.tilemap_window = self.pyboy.tilemap_window
         self.tilemap_use_background = True
@@ -258,6 +253,7 @@ def game_area(self):
             _x = (s.x // 8) - xx
             _y = (s.y // 8) - yy
             if 0 <= _x < width:
+                # Adding offset to try to seperate sprites from tiles
                 if 0 <= _y < height:
                     tiles_matrix[_y][_x] = self.mapping[s.tile_identifier] + self.sprite_offset
                 if len(s.tiles) == 2 and 0 <= _y + 1 < height:  # Sprite has two tiles
diff --git a/pyboy/plugins/debug.pxd b/pyboy/plugins/debug.pxd
index f876d0603..e1d6abd60 100644
--- a/pyboy/plugins/debug.pxd
+++ b/pyboy/plugins/debug.pxd
@@ -66,7 +66,7 @@ cdef class BaseDebugWindow(PyBoyWindowPlugin):
     cdef void mark_tile(self, int, int, uint32_t, int, int, bint) noexcept
 
     @cython.locals(event=WindowEvent)
-    cdef list handle_events(self, list) noexcept
+    cdef list handle_events(self, list)
 
 
 cdef class TileViewWindow(BaseDebugWindow):
@@ -85,7 +85,7 @@ cdef class TileViewWindow(BaseDebugWindow):
     cdef void draw_overlay(self) noexcept
 
     @cython.locals(tile_x=int, tile_y=int, tile_identifier=int)
-    cdef list handle_events(self, list) noexcept
+    cdef list handle_events(self, list)
 
 
 cdef class TileDataWindow(BaseDebugWindow):
@@ -97,7 +97,7 @@ cdef class TileDataWindow(BaseDebugWindow):
     cdef void post_tick(self) noexcept
 
     @cython.locals(tile_x=int, tile_y=int, tile_identifier=int)
-    cdef list handle_events(self, list) noexcept
+    cdef list handle_events(self, list)
 
     @cython.locals(t=MarkedTile, column=int, row=int)
     cdef void draw_overlay(self) noexcept
@@ -105,7 +105,7 @@ cdef class TileDataWindow(BaseDebugWindow):
 
 cdef class SpriteWindow(BaseDebugWindow):
     @cython.locals(tile_x=int, tile_y=int, sprite_identifier=int, sprite=object)
-    cdef list handle_events(self, list) noexcept
+    cdef list handle_events(self, list)
 
     @cython.locals(t=MarkedTile, xx=int, yy=int, sprite=object, i=int)
     cdef void draw_overlay(self) noexcept
diff --git a/pyboy/plugins/debug.py b/pyboy/plugins/debug.py
index 8eff10370..92ca4d8da 100644
--- a/pyboy/plugins/debug.py
+++ b/pyboy/plugins/debug.py
@@ -4,7 +4,7 @@
 #
 
 import os
-import re
+import time
 import zlib
 from array import array
 from base64 import b64decode
@@ -16,15 +16,9 @@
 from pyboy.plugins.window_sdl2 import sdl2_event_pump
 from pyboy.utils import WindowEvent
 
-try:
-    from cython import compiled
-
-    cythonmode = compiled
-except ImportError:
-    cythonmode = False
-
 try:
     import sdl2
+    from sdl2.ext import get_events
 except ImportError:
     sdl2 = None
 
@@ -83,8 +77,6 @@ def __init__(self, pyboy, mb, pyboy_argv):
         if not self.enabled():
             return
 
-        self.cgb = mb.cartridge_cgb
-
         self.sdl2_event_pump = self.pyboy_argv.get("window") != "SDL2"
         if self.sdl2_event_pump:
             sdl2.SDL_Init(sdl2.SDL_INIT_VIDEO)
@@ -214,6 +206,11 @@ def stop(self):
         self.sprite.stop()
         self.spriteview.stop()
         self.memory.stop()
+        if self.sdl2_event_pump:
+            for _ in range(3):  # At least 2 to close
+                get_events()
+                time.sleep(0.1)
+            sdl2.SDL_Quit()
 
     def enabled(self):
         if self.pyboy_argv.get("debug"):
@@ -239,7 +236,6 @@ def make_buffer(w, h, depth=4):
 class BaseDebugWindow(PyBoyWindowPlugin):
     def __init__(self, pyboy, mb, pyboy_argv, *, scale, title, width, height, pos_x, pos_y):
         super().__init__(pyboy, mb, pyboy_argv)
-        self.cgb = mb.cgb
         self.scale = scale
         self.width, self.height = width, height
         self.base_title = title
@@ -352,7 +348,6 @@ def post_tick(self):
                 self.palette_rgb = self.mb.lcd.ocpd.palette_mem_rgb  # TODO: Select palette by adding offset
             else:
                 # Fake palette index
-                palette = 0
                 self.renderer.update_tilecache0(self.mb.lcd, tile_index, 0)
                 self.tilecache = self.renderer._tilecache0
                 horiflip, vertflip = False, False
@@ -382,7 +377,7 @@ def handle_events(self, events):
                 if event.mouse_button == 0:
                     tile_x, tile_y = event.mouse_x // 8, event.mouse_y // 8
                     tile_identifier = self.tilemap.tile_identifier(tile_x, tile_y)
-                    logger.info(f"Tile clicked on %d, %d", tile_x, tile_y)
+                    logger.info("Tile clicked on %d, %d", tile_x, tile_y)
                     marked_tiles.add(
                         MarkedTile(tile_identifier=tile_identifier, mark_id="TILE", mark_color=MARK[mark_counter])
                     )
@@ -541,7 +536,6 @@ def post_tick(self):
             yy = (((n // 4) * 8) // self.width) * sprite_height
 
             if self.cgb:
-                palette = attributes & 0b111
                 if attributes & 0b1000:
                     self.renderer.update_spritecache1(self.mb.lcd, t, 1)
                     if self.mb.lcd._LCDC.sprite_height:
@@ -555,7 +549,6 @@ def post_tick(self):
                 self.palette_rgb = self.mb.lcd.ocpd.palette_mem_rgb  # TODO: Select palette by adding offset
             else:
                 # Fake palette index
-                palette = 0
                 if attributes & 0b10000:
                     self.renderer.update_spritecache1(self.mb.lcd, t, 0)
                     if self.mb.lcd._LCDC.sprite_height:
diff --git a/pyboy/plugins/debug_prompt.pxd b/pyboy/plugins/debug_prompt.pxd
index e45736348..5be27409e 100644
--- a/pyboy/plugins/debug_prompt.pxd
+++ b/pyboy/plugins/debug_prompt.pxd
@@ -11,4 +11,4 @@ cdef Logger logger
 
 cdef class DebugPrompt(PyBoyPlugin):
     cdef dict rom_symbols
-    cdef void handle_breakpoint(self)
+    cdef void handle_breakpoint(self) noexcept
diff --git a/pyboy/plugins/debug_prompt.py b/pyboy/plugins/debug_prompt.py
index 5da1cc9e9..42a2d2be6 100644
--- a/pyboy/plugins/debug_prompt.py
+++ b/pyboy/plugins/debug_prompt.py
@@ -3,12 +3,9 @@
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
 
-import os
-import re
 
 import pyboy
 from pyboy.plugins.base_plugin import PyBoyPlugin
-from pyboy.utils import WindowEvent
 
 logger = pyboy.logging.get_logger(__name__)
 
@@ -48,7 +45,7 @@ def parse_bank_addr_sym_label(self, command):
             return bank, addr
         else:
             try:
-                self.pyboy._lookup_symbol(command)
+                return self.pyboy._lookup_symbol(command)
             except ValueError:
                 pass
         return None, None
@@ -106,7 +103,7 @@ def handle_breakpoint(self):
                     self.mb.breakpoint_add(bank, addr)
 
             elif cmd == "d":
-                print(f"Removing breakpoint at current PC")
+                print("Removing breakpoint at current PC")
                 self.mb.breakpoint_reached()  # NOTE: This removes the breakpoint we are currently at
             elif cmd == "pdb":
                 # Start pdb
diff --git a/pyboy/plugins/disable_input.pxd b/pyboy/plugins/disable_input.pxd
deleted file mode 100644
index 2b6d89a47..000000000
--- a/pyboy/plugins/disable_input.pxd
+++ /dev/null
@@ -1,15 +0,0 @@
-#
-# License: See LICENSE.md file
-# GitHub: https://github.com/Baekalfen/PyBoy
-#
-
-from pyboy.logging.logging cimport Logger
-from pyboy.plugins.base_plugin cimport PyBoyPlugin
-
-
-cdef Logger logger
-
-cdef class DisableInput(PyBoyPlugin):
-    pass
-
-
diff --git a/pyboy/plugins/disable_input.py b/pyboy/plugins/disable_input.py
deleted file mode 100644
index 1e59cce58..000000000
--- a/pyboy/plugins/disable_input.py
+++ /dev/null
@@ -1,15 +0,0 @@
-#
-# License: See LICENSE.md file
-# GitHub: https://github.com/Baekalfen/PyBoy
-#
-from pyboy.plugins.base_plugin import PyBoyPlugin
-
-
-class DisableInput(PyBoyPlugin):
-    argv = [("--no-input", {"action": "store_true", "help": "Disable all user-input (mostly for autonomous testing)"})]
-
-    def handle_events(self, events):
-        return []
-
-    def enabled(self):
-        return self.pyboy_argv.get("no_input")
diff --git a/pyboy/plugins/game_wrapper_kirby_dream_land.py b/pyboy/plugins/game_wrapper_kirby_dream_land.py
index 0035030b0..8d6290a9e 100644
--- a/pyboy/plugins/game_wrapper_kirby_dream_land.py
+++ b/pyboy/plugins/game_wrapper_kirby_dream_land.py
@@ -8,8 +8,6 @@
 }
 
 import pyboy
-from pyboy import utils
-from pyboy.utils import WindowEvent
 
 from .base_plugin import PyBoyGameWrapper
 
@@ -136,7 +134,7 @@ def game_over(self):
 
     def __repr__(self):
         return (
-            f"Kirby Dream Land:\n"
+            "Kirby Dream Land:\n"
             + f"Score: {self.score}\n"
             + f"Health: {self.health}\n"
             + f"Lives left: {self.lives_left}\n"
diff --git a/pyboy/plugins/game_wrapper_metroid_ii.pxd b/pyboy/plugins/game_wrapper_metroid_ii.pxd
new file mode 100644
index 000000000..c71bd37bc
--- /dev/null
+++ b/pyboy/plugins/game_wrapper_metroid_ii.pxd
@@ -0,0 +1,39 @@
+#
+# License: See LICENSE.md file
+# GitHub: https://github.com/Baekalfen/PyBoy
+#
+cimport cython
+from libc.stdint cimport uint8_t
+
+from pyboy.logging.logging cimport Logger
+from pyboy.plugins.base_plugin cimport PyBoyGameWrapper
+
+
+cdef Logger logger
+
+cdef int ROWS, COLS
+
+
+cdef class GameWrapperMetroidII(PyBoyGameWrapper):
+    cdef int _game_over
+    cdef readonly int x_pos_pixels
+    cdef readonly int y_pos_pixels
+    cdef readonly int x_pos_area
+    cdef readonly int y_pos_area
+    cdef readonly int pose
+
+    cdef readonly int samus_facing
+    cdef readonly int major_upgrades
+    cdef readonly int beam
+    cdef readonly int e_tanks
+    cdef readonly int hp
+    cdef readonly int full_e_tanks
+    cdef readonly int missiles
+    cdef readonly int missile_capacity
+    cdef readonly int displayed_hp
+    cdef readonly int displayed_missiles
+    cdef readonly int global_metroid_count
+    cdef readonly int local_metroid_count
+
+
+    
diff --git a/pyboy/plugins/game_wrapper_metroid_ii.py b/pyboy/plugins/game_wrapper_metroid_ii.py
new file mode 100644
index 000000000..9c72eb9b5
--- /dev/null
+++ b/pyboy/plugins/game_wrapper_metroid_ii.py
@@ -0,0 +1,201 @@
+#
+# License: See LICENSE.md file
+# GitHub: https://github.com/Baekalfen/PyBoy
+#
+__pdoc__ = {
+    "GameWrapperMetroidII.cartridge_title": False,
+    "GameWrapperMetroidII.post_tick": False,
+}
+
+import pyboy
+from pyboy import utils
+from pyboy.utils import WindowEvent
+# for memory
+from pyboy.utils import bcd_to_dec
+
+from .base_plugin import PyBoyGameWrapper
+
+logger = pyboy.logging.get_logger(__name__)
+
+
+class GameWrapperMetroidII(PyBoyGameWrapper):
+    """
+    This class wraps Metroid II, and provides easy access for AIs.
+    If you call `print` on an instance of this object,
+    it will show an overview of everything this object provides.
+    """
+    cartridge_title = "METROID2"
+
+    def __init__(self, *args, **kwargs):
+
+        self.x_pos_pixels = 0
+        self.y_pos_pixels = 0
+        self.x_pos_area = 0
+        self.y_pos_area = 0
+        self.pose = 0
+        self.samus_facing = 0
+        self.major_upgrades = 0
+        self.beam = 0
+        self.e_tanks = 0
+        self.hp = 99
+        self.full_e_tanks = 0
+        self.missiles = 30
+        self.missile_capacity = 30
+        self.displayed_hp = 99
+        self.displayed_missiles = 30
+        self.global_metroid_count = 39
+        self.local_metroid_count = 39
+
+        self._game_over = False        
+        # Screen shows 20x17 tiles
+        super().__init__(*args, game_area_section=(0, 0, 20, 17), game_area_follow_scxy=True, **kwargs)
+
+    def post_tick(self):
+        self._tile_cache_invalid = True
+        self._sprite_cache_invalid = True
+        
+        # All RAM addresses and constants sourced from:
+        # https://datacrystal.tcrf.net/wiki/Metroid_II:_Return_of_Samus/RAM_map
+        # https://github.com/alex-west/M2RoS/blob/main/SRC/constants.asm
+
+        # TODO BEN change this at some point
+        # Check screen for the word "GAME" (as in GAME OVER)
+        # this could be done much faster by checking health
+        # There's a death animation so the extra few seconds over thousands of
+        # runs *could* add up. Proper timing analysis could confirm this
+        if self.tilemap_background[6:10, 8] == [342, 336, 348, 340]:
+            self._game_over = True
+            # No need to update the rest of the values, we're dead!
+            return
+
+        # X position within area (pixels/screen)
+        # In Metroid
+        self.x_pos_pixels = self.pyboy.memory[0xD027]
+        self.y_pos_pixels = self.pyboy.memory[0xD029]
+        self.x_pos_area = self.pyboy.memory[0xD028]
+        self.y_pos_area = self.pyboy.memory[0xD02A]
+
+        self.pose = self.pyboy.memory[0xD020]
+        self.samus_facing = self.pyboy.memory[0xD02B]
+        self.major_upgrades = self.pyboy.memory[0xD045]
+
+        # 8 bit (0b0000 1000) is missles mode, see constants in disassembly
+        self.beam = bcd_to_dec(self.pyboy.memory[0xD04D])
+
+        self.e_tanks = bcd_to_dec(self.pyboy.memory[0xD050])
+        self.hp = bcd_to_dec(self.pyboy.memory[0xD051])
+        self.full_e_tanks = self.pyboy.memory[0xD052]
+
+        self.missiles = bcd_to_dec(self.pyboy.memory[0xD053])
+        self.missile_capacity = bcd_to_dec(self.pyboy.memory[0xD081])
+
+        # TODO figure out if there is a difference between these and the other
+        # values
+        self.displayed_hp = self.pyboy.memory[0xD084]
+        self.displayed_missiles = bcd_to_dec(self.pyboy.memory[0xD086])
+
+        self.global_metroid_count = bcd_to_dec(self.pyboy.memory[0xD09A])
+        self.local_metroid_count = bcd_to_dec(self.pyboy.memory[0xD0A7])
+
+        # TODO Verify these equations
+        # self.real_health = self.full_e_tanks * 99) + self.hp
+        # self.health_percent = self.real_health / ((self.e_tanks+1)*99)
+
+
+
+    def start_game(self, timer_div=None):
+        """
+        Call this function right after initializing PyBoy. This will navigate through menus to start the game at the
+        first playable state.
+
+        The state of the emulator is saved, and using `reset_game`, you can get back to this point of the game
+        instantly.
+
+        Kwargs:
+            * timer_div (int): Replace timer's DIV register with this value. Use `None` to randomize.
+        """
+
+        # TODO Figure out the minimum possible values for these
+        # instead of 300 and 500
+        self.pyboy.tick(False)
+        self.pyboy.button("start")
+        self.pyboy.tick(300, False)
+
+        # start the game
+        self.pyboy.button("start")
+        # wait for samus's "blinking" to stop
+        self.pyboy.tick(500, False)
+        
+        PyBoyGameWrapper.start_game(self, timer_div=timer_div)
+
+
+    def reset_game(self, timer_div=None):
+        """
+        After calling `start_game`, you can call this method at any time to reset the game.
+
+        Kwargs:
+            * timer_div (int): Replace timer's DIV register with this value. Use `None` to randomize.
+        """
+        self._game_over = False
+
+        PyBoyGameWrapper.reset_game(self, timer_div=timer_div)
+
+    def game_area(self):
+        """
+        Use this method to get a matrix of the "game area" of the screen.
+
+        ```text
+              0   1   2   3   4   5   6   7   8   9
+          ____________________________________________________________________________________
+          0  | 383 383 383 301 383 383 383 297 383 383 383 301 383 383 383 297 383 383 383 293
+          1  | 383 383 383 383 300 294 295 296 383 383 383 383 300 294 295 296 383 383 299 383
+          2  | 311 318 319 320 383 383 383 383 383 383 383 383 383 383 383 383 383 301 383 383
+          3  | 383 383 383 321 322 383 383 383 383 383 383 383 383 383 383 383 383 383 300 294
+          4  | 383 383 383 383 323 290 291 383 383 383 313 312 311 318 319 320 383 290 291 383
+          5  | 383 383 383 383 324 383 383 383 383 315 314 383 383 383 383 321 322 383 383 383
+          6  | 383 383 383 383 324 293 292 383 383 316 383 383 383 383 383 383 323 383 383 383
+          7  | 383 383 383 383 324 383 383 298 383 317 383 383 383 383 383 383 324 383 383 383
+          8  | 319 320 383 383 324 383 383 297 383 317 383 383 383 152 140 383 324 383 383 307
+          9  | 383 321 322 383 324 294 295 296 383 325 383 383 383 383 383 383 326 272 274 309
+          10 | 383 383 323 383 326 383 383 383 2   18  383 330 331 331 331 331 331 331 331 331
+          11 | 274 383 324 272 274 272 274 272 274 272 274 334 328 328 328 328 328 328 328 328
+          12 | 331 331 331 331 331 331 331 331 331 331 331 328 328 328 328 328 328 328 328 328
+          13 | 328 328 328 277 278 328 328 328 328 328 328 328 328 277 278 328 328 277 278 277
+          14 | 328 277 278 279 281 277 278 328 328 277 278 277 278 279 281 277 278 279 281 279
+          15 | 278 279 281 280 282 279 281 277 278 279 281 279 281 280 282 279 281 280 282 280
+        ```
+
+        Returns
+        -------
+        memoryview:
+            Simplified 2-dimensional memoryview of the screen
+        """
+        return PyBoyGameWrapper.game_area(self)
+
+    def game_over(self):
+        return self._game_over
+
+    def __repr__(self):
+        # yapf: disable
+        return (
+            f"Metroid II:\n" +
+            f"x_pos_pixels: {self.x_pos_pixels}\n" +
+            f"y_pos_pixels: {self.y_pos_pixels}\n" +
+            f"x_pos_area: {self.x_pos_area}\n" +
+            f"y_pos_area: {self.y_pos_area}\n" +
+            f"pose: {self.pose}\n" +
+            f"samus_facing: {self.samus_facing}\n" +
+            f"major_upgrades: {self.major_upgrades}\n" +
+            f"beam: {self.beam}\n" +
+            f"e_tanks: {self.e_tanks}\n" +
+            f"hp: {self.hp}\n" +
+            f"full_e_tanks: {self.full_e_tanks}\n" +
+            f"missiles: {self.missiles}\n" +
+            f"missile_capacity: {self.missile_capacity}\n" +
+            f"displayed_hp: {self.displayed_hp}\n" +
+            f"displayed_missiles: {self.displayed_missiles}\n" +
+            f"global_metroid_count: {self.global_metroid_count}\n" +
+            f"local_metroid_count: {self.local_metroid_count}\n" +
+            super().__repr__()
+        )
+        # yapf: enable
diff --git a/pyboy/plugins/game_wrapper_pokemon_gen1.py b/pyboy/plugins/game_wrapper_pokemon_gen1.py
index b8a203384..0c31be9cd 100644
--- a/pyboy/plugins/game_wrapper_pokemon_gen1.py
+++ b/pyboy/plugins/game_wrapper_pokemon_gen1.py
@@ -10,8 +10,6 @@
 import numpy as np
 
 import pyboy
-from pyboy import utils
-from pyboy.utils import WindowEvent
 
 from .base_plugin import PyBoyGameWrapper
 
@@ -39,7 +37,7 @@ def post_tick(self):
         self._sprite_cache_invalid = True
 
         scanline_parameters = self.pyboy.screen.tilemap_position_list
-        WX = scanline_parameters[0][2]
+        # WX = scanline_parameters[0][2]
         WY = scanline_parameters[0][3]
         self.use_background(WY != 0)
 
diff --git a/pyboy/plugins/game_wrapper_super_mario_land.pxd b/pyboy/plugins/game_wrapper_super_mario_land.pxd
index 07b243d3f..3d6122cf8 100644
--- a/pyboy/plugins/game_wrapper_super_mario_land.pxd
+++ b/pyboy/plugins/game_wrapper_super_mario_land.pxd
@@ -24,4 +24,4 @@ cdef class GameWrapperSuperMarioLand(PyBoyGameWrapper):
 
     cpdef void start_game(self, timer_div=*, world_level=*, unlock_level_select=*) noexcept
     cpdef void reset_game(self, timer_div=*) noexcept
-    cpdef set_lives_left(self, int) noexcept
\ No newline at end of file
+    cpdef void set_lives_left(self, int) noexcept
\ No newline at end of file
diff --git a/pyboy/plugins/game_wrapper_super_mario_land.py b/pyboy/plugins/game_wrapper_super_mario_land.py
index 0429d9b77..8276b45b4 100644
--- a/pyboy/plugins/game_wrapper_super_mario_land.py
+++ b/pyboy/plugins/game_wrapper_super_mario_land.py
@@ -10,7 +10,7 @@
 import numpy as np
 
 import pyboy
-from pyboy.utils import WindowEvent
+from pyboy.utils import PyBoyInvalidInputException
 
 from .base_plugin import PyBoyGameWrapper
 
@@ -148,6 +148,7 @@
 
 # Apparantly that address is for lives left
 # https://datacrystal.romhacking.net/wiki/Super_Mario_Land:RAM_map
+ADDR_TIME_LEFT = 0xDA01
 ADDR_LIVES_LEFT = 0xDA15
 ADDR_LIVES_LEFT_DISPLAY = 0x9806
 ADDR_WORLD_LEVEL = 0xFFB4
@@ -269,7 +270,7 @@ def __init__(self, *args, **kwargs):
         """
         Provides the current "world" Mario is in, as a tuple of as two integers (world, level).
 
-        You can force a level change with `set_world_level`.
+        You can force a level change with `GameWrapperSuperMarioLand.set_world_level`.
 
         Example:
         ```python
@@ -294,7 +295,9 @@ def __init__(self, *args, **kwargs):
         """
         self.lives_left = 0
         """
-        The number of lives Mario has left
+        The number of lives Mario has left.
+
+        You can change this with `GameWrapperSuperMarioLand.set_lives_left`.
 
         Example:
         ```python
@@ -318,7 +321,9 @@ def __init__(self, *args, **kwargs):
         """
         self.time_left = 0
         """
-        The number of seconds left to finish the level
+        The number of seconds left to finish the level.
+
+        You can change this with `GameWrapperSuperMarioLand.set_time_left`.
 
         Example:
         ```python
@@ -354,12 +359,49 @@ def post_tick(self):
         self.lives_left = _bcm_to_dec(self.pyboy.memory[ADDR_LIVES_LEFT])
         self.score = self._sum_number_on_screen(0, 1, 6, blank, -256)
         self.time_left = self._sum_number_on_screen(17, 1, 3, blank, -256)
+        tens_one = self.pyboy.memory[ADDR_TIME_LEFT]
+        hundreds = self.pyboy.memory[ADDR_TIME_LEFT + 1]
+        self.time_left = hundreds * 100 + (tens_one >> 4) * 10 + (tens_one & 0xF)
 
         level_block = self.pyboy.memory[0xC0AB]
         mario_x = self.pyboy.memory[0xC202]
         scx = self.pyboy.screen.tilemap_position_list[16][0]
         self.level_progress = level_block * 16 + (scx - 7) % 16 + mario_x
 
+    def set_time_left(self, time):
+        """
+        Set the amount of time left to any number between 0 and 999.
+
+        This should only be called when the game has started.
+
+        Example:
+        ```python
+        >>> pyboy = PyBoy(supermarioland_rom)
+        >>> pyboy.game_wrapper.start_game()
+        >>> pyboy.game_wrapper.time_left
+        400
+        >>> pyboy.game_wrapper.set_time_left(123)
+        >>> pyboy.tick(1, False)
+        True
+        >>> pyboy.game_wrapper.time_left
+        123
+        ```
+
+        Args:
+            time (int): The wanted time left
+        """
+        if not self.game_has_started:
+            logger.warning("Please call set_lives_left after starting the game")
+
+        if 0 <= time <= 999:
+            hundreds = time // 100
+            tens = (time - hundreds * 100) // 10
+            ones = time % 10
+            self.pyboy.memory[ADDR_TIME_LEFT] = (tens << 4) | ones
+            self.pyboy.memory[ADDR_TIME_LEFT + 1] = hundreds
+        else:
+            raise PyBoyInvalidInputException(f"{time} is out of bounds. Only values between 0 and 999 allowed.")
+
     def set_lives_left(self, amount):
         """
         Set the amount lives to any number between 0 and 99.
@@ -392,7 +434,7 @@ def set_lives_left(self, amount):
             self.pyboy.memory[ADDR_LIVES_LEFT_DISPLAY] = tens
             self.pyboy.memory[ADDR_LIVES_LEFT_DISPLAY + 1] = ones
         else:
-            logger.error("%d is out of bounds. Only values between 0 and 99 allowed.", amount)
+            raise PyBoyInvalidInputException(f"{amount} is out of bounds. Only values between 0 and 99 allowed.")
 
     def set_world_level(self, world, level):
         """
@@ -506,7 +548,7 @@ def game_area(self):
         In Super Mario Land, this is almost the entire screen, expect for the top part showing the score, lives left
         and so on. These values can be found in the variables of this class.
 
-        In this example using `mapping_minimal`, Mario is `1`. He is standing on the ground which is `3`:
+        In this example using `GameWrapperSuperMarioLand.mapping_minimal`, Mario is `1`. He is standing on the ground which is `3`:
         ```python
         >>> pyboy = PyBoy(supermarioland_rom)
         >>> pyboy.game_wrapper.start_game()
diff --git a/pyboy/plugins/game_wrapper_tetris.pxd b/pyboy/plugins/game_wrapper_tetris.pxd
index 30316efd7..4ae4c30f3 100644
--- a/pyboy/plugins/game_wrapper_tetris.pxd
+++ b/pyboy/plugins/game_wrapper_tetris.pxd
@@ -20,7 +20,7 @@ cdef class GameWrapperTetris(PyBoyGameWrapper):
     cdef readonly int lines
 
     cpdef void set_tetromino(self, str) noexcept
-    cpdef str next_tetromino(self) noexcept
+    cpdef str next_tetromino(self)
 
     cpdef void start_game(self, timer_div=*) noexcept
     cpdef void reset_game(self, timer_div=*) noexcept
diff --git a/pyboy/plugins/game_wrapper_tetris.py b/pyboy/plugins/game_wrapper_tetris.py
index 7cb123cec..2d0ce5e5b 100644
--- a/pyboy/plugins/game_wrapper_tetris.py
+++ b/pyboy/plugins/game_wrapper_tetris.py
@@ -7,12 +7,10 @@
     "GameWrapperTetris.post_tick": False,
 }
 
-from array import array
 
 import numpy as np
 
 import pyboy
-from pyboy.utils import WindowEvent
 
 from .base_plugin import PyBoyGameWrapper
 
@@ -253,7 +251,7 @@ def game_over(self):
 
     def __repr__(self):
         return (
-            f"Tetris:\n"
+            "Tetris:\n"
             + f"Score: {self.score}\n"
             + f"Level: {self.level}\n"
             + f"Lines: {self.lines}\n"
diff --git a/pyboy/plugins/manager.pxd b/pyboy/plugins/manager.pxd
index a770eedf7..68c7c234f 100644
--- a/pyboy/plugins/manager.pxd
+++ b/pyboy/plugins/manager.pxd
@@ -11,7 +11,6 @@ from pyboy.plugins.window_sdl2 cimport WindowSDL2
 from pyboy.plugins.window_open_gl cimport WindowOpenGL
 from pyboy.plugins.window_null cimport WindowNull
 from pyboy.plugins.debug cimport Debug
-from pyboy.plugins.disable_input cimport DisableInput
 from pyboy.plugins.auto_pause cimport AutoPause
 from pyboy.plugins.record_replay cimport RecordReplay
 from pyboy.plugins.rewind cimport Rewind
@@ -23,6 +22,7 @@ from pyboy.plugins.game_wrapper_tetris cimport GameWrapperTetris
 from pyboy.plugins.game_wrapper_kirby_dream_land cimport GameWrapperKirbyDreamLand
 from pyboy.plugins.game_wrapper_pokemon_gen1 cimport GameWrapperPokemonGen1
 from pyboy.plugins.game_wrapper_pokemon_pinball cimport GameWrapperPokemonPinball
+from pyboy.plugins.game_wrapper_metroid_ii cimport GameWrapperMetroidII
 # imports end
 
 
@@ -36,7 +36,6 @@ cdef class PluginManager:
     cdef public WindowOpenGL window_open_gl
     cdef public WindowNull window_null
     cdef public Debug debug
-    cdef public DisableInput disable_input
     cdef public AutoPause auto_pause
     cdef public RecordReplay record_replay
     cdef public Rewind rewind
@@ -48,11 +47,11 @@ cdef class PluginManager:
     cdef public GameWrapperKirbyDreamLand game_wrapper_kirby_dream_land
     cdef public GameWrapperPokemonGen1 game_wrapper_pokemon_gen1
     cdef public GameWrapperPokemonPinball game_wrapper_pokemon_pinball
+    cdef public GameWrapperMetroidII game_wrapper_metroid_ii
     cdef bint window_sdl2_enabled
     cdef bint window_open_gl_enabled
     cdef bint window_null_enabled
     cdef bint debug_enabled
-    cdef bint disable_input_enabled
     cdef bint auto_pause_enabled
     cdef bint record_replay_enabled
     cdef bint rewind_enabled
@@ -64,13 +63,14 @@ cdef class PluginManager:
     cdef bint game_wrapper_kirby_dream_land_enabled
     cdef bint game_wrapper_pokemon_gen1_enabled
     cdef bint game_wrapper_pokemon_pinball_enabled
+    cdef bint game_wrapper_metroid_ii_enabled
     # plugin_cdef end
 
-    cdef list handle_events(self, list) noexcept
+    cdef list handle_events(self, list)
     cpdef void post_tick(self) noexcept
     cdef void _post_tick_windows(self) noexcept
     cdef void frame_limiter(self, int) noexcept
-    cdef str window_title(self) noexcept
+    cdef str window_title(self)
     cdef void stop(self) noexcept
     cdef void _set_title(self) noexcept
     cdef void handle_breakpoint(self) noexcept
diff --git a/pyboy/plugins/manager.py b/pyboy/plugins/manager.py
index df279c8da..e2cb41cad 100644
--- a/pyboy/plugins/manager.py
+++ b/pyboy/plugins/manager.py
@@ -6,22 +6,22 @@
 from pyboy.plugins.base_plugin import PyBoyGameWrapper
 
 # imports
-from pyboy.plugins.window_sdl2 import WindowSDL2 # isort:skip
-from pyboy.plugins.window_open_gl import WindowOpenGL # isort:skip
-from pyboy.plugins.window_null import WindowNull # isort:skip
-from pyboy.plugins.debug import Debug # isort:skip
-from pyboy.plugins.disable_input import DisableInput # isort:skip
-from pyboy.plugins.auto_pause import AutoPause # isort:skip
-from pyboy.plugins.record_replay import RecordReplay # isort:skip
-from pyboy.plugins.rewind import Rewind # isort:skip
-from pyboy.plugins.screen_recorder import ScreenRecorder # isort:skip
-from pyboy.plugins.screenshot_recorder import ScreenshotRecorder # isort:skip
-from pyboy.plugins.debug_prompt import DebugPrompt # isort:skip
-from pyboy.plugins.game_wrapper_super_mario_land import GameWrapperSuperMarioLand # isort:skip
-from pyboy.plugins.game_wrapper_tetris import GameWrapperTetris # isort:skip
-from pyboy.plugins.game_wrapper_kirby_dream_land import GameWrapperKirbyDreamLand # isort:skip
-from pyboy.plugins.game_wrapper_pokemon_gen1 import GameWrapperPokemonGen1 # isort:skip
-from pyboy.plugins.game_wrapper_pokemon_pinball import GameWrapperPokemonPinball # isort:skip
+from pyboy.plugins.window_sdl2 import WindowSDL2 # noqa
+from pyboy.plugins.window_open_gl import WindowOpenGL # noqa
+from pyboy.plugins.window_null import WindowNull # noqa
+from pyboy.plugins.debug import Debug # noqa
+from pyboy.plugins.auto_pause import AutoPause # noqa
+from pyboy.plugins.record_replay import RecordReplay # noqa
+from pyboy.plugins.rewind import Rewind # noqa
+from pyboy.plugins.screen_recorder import ScreenRecorder # noqa
+from pyboy.plugins.screenshot_recorder import ScreenshotRecorder # noqa
+from pyboy.plugins.debug_prompt import DebugPrompt # noqa
+from pyboy.plugins.game_wrapper_super_mario_land import GameWrapperSuperMarioLand # noqa
+from pyboy.plugins.game_wrapper_tetris import GameWrapperTetris # noqa
+from pyboy.plugins.game_wrapper_kirby_dream_land import GameWrapperKirbyDreamLand # noqa
+from pyboy.plugins.game_wrapper_pokemon_gen1 import GameWrapperPokemonGen1 # noqa
+from pyboy.plugins.game_wrapper_pokemon_pinball import GameWrapperPokemonPinball # noqa
+from pyboy.plugins.game_wrapper_metroid_ii import GameWrapperMetroidII # noqa
 # imports end
 
 
@@ -31,7 +31,6 @@ def parser_arguments():
     yield WindowOpenGL.argv
     yield WindowNull.argv
     yield Debug.argv
-    yield DisableInput.argv
     yield AutoPause.argv
     yield RecordReplay.argv
     yield Rewind.argv
@@ -43,6 +42,7 @@ def parser_arguments():
     yield GameWrapperKirbyDreamLand.argv
     yield GameWrapperPokemonGen1.argv
     yield GameWrapperPokemonPinball.argv
+    yield GameWrapperMetroidII.argv
     # yield_plugins end
     pass
 
@@ -62,8 +62,6 @@ def __init__(self, pyboy, mb, pyboy_argv):
         self.window_null_enabled = self.window_null.enabled()
         self.debug = Debug(pyboy, mb, pyboy_argv)
         self.debug_enabled = self.debug.enabled()
-        self.disable_input = DisableInput(pyboy, mb, pyboy_argv)
-        self.disable_input_enabled = self.disable_input.enabled()
         self.auto_pause = AutoPause(pyboy, mb, pyboy_argv)
         self.auto_pause_enabled = self.auto_pause.enabled()
         self.record_replay = RecordReplay(pyboy, mb, pyboy_argv)
@@ -86,6 +84,8 @@ def __init__(self, pyboy, mb, pyboy_argv):
         self.game_wrapper_pokemon_gen1_enabled = self.game_wrapper_pokemon_gen1.enabled()
         self.game_wrapper_pokemon_pinball = GameWrapperPokemonPinball(pyboy, mb, pyboy_argv)
         self.game_wrapper_pokemon_pinball_enabled = self.game_wrapper_pokemon_pinball.enabled()
+        self.game_wrapper_metroid_ii = GameWrapperMetroidII(pyboy, mb, pyboy_argv)
+        self.game_wrapper_metroid_ii_enabled = self.game_wrapper_metroid_ii.enabled()
         # plugins_enabled end
 
     def gamewrapper(self):
@@ -95,6 +95,7 @@ def gamewrapper(self):
         if self.game_wrapper_kirby_dream_land_enabled: return self.game_wrapper_kirby_dream_land
         if self.game_wrapper_pokemon_gen1_enabled: return self.game_wrapper_pokemon_gen1
         if self.game_wrapper_pokemon_pinball_enabled: return self.game_wrapper_pokemon_pinball
+        if self.game_wrapper_metroid_ii_enabled: return self.game_wrapper_metroid_ii
         # gamewrapper end
         self.generic_game_wrapper_enabled = True
         return self.generic_game_wrapper
@@ -111,8 +112,6 @@ def handle_events(self, events):
             events = self.debug.handle_events(events)
         # foreach end
         # foreach plugins events = [].handle_events(events)
-        if self.disable_input_enabled:
-            events = self.disable_input.handle_events(events)
         if self.auto_pause_enabled:
             events = self.auto_pause.handle_events(events)
         if self.record_replay_enabled:
@@ -135,6 +134,8 @@ def handle_events(self, events):
             events = self.game_wrapper_pokemon_gen1.handle_events(events)
         if self.game_wrapper_pokemon_pinball_enabled:
             events = self.game_wrapper_pokemon_pinball.handle_events(events)
+        if self.game_wrapper_metroid_ii_enabled:
+            events = self.game_wrapper_metroid_ii.handle_events(events)
         # foreach end
         if self.generic_game_wrapper_enabled:
             events = self.generic_game_wrapper.handle_events(events)
@@ -142,8 +143,6 @@ def handle_events(self, events):
 
     def post_tick(self):
         # foreach plugins [].post_tick()
-        if self.disable_input_enabled:
-            self.disable_input.post_tick()
         if self.auto_pause_enabled:
             self.auto_pause.post_tick()
         if self.record_replay_enabled:
@@ -166,6 +165,8 @@ def post_tick(self):
             self.game_wrapper_pokemon_gen1.post_tick()
         if self.game_wrapper_pokemon_pinball_enabled:
             self.game_wrapper_pokemon_pinball.post_tick()
+        if self.game_wrapper_metroid_ii_enabled:
+            self.game_wrapper_metroid_ii.post_tick()
         # foreach end
         if self.generic_game_wrapper_enabled:
             self.generic_game_wrapper.post_tick()
@@ -229,8 +230,6 @@ def window_title(self):
             title += self.debug.window_title()
         # foreach end
         # foreach plugins title += [].window_title()
-        if self.disable_input_enabled:
-            title += self.disable_input.window_title()
         if self.auto_pause_enabled:
             title += self.auto_pause.window_title()
         if self.record_replay_enabled:
@@ -253,6 +252,8 @@ def window_title(self):
             title += self.game_wrapper_pokemon_gen1.window_title()
         if self.game_wrapper_pokemon_pinball_enabled:
             title += self.game_wrapper_pokemon_pinball.window_title()
+        if self.game_wrapper_metroid_ii_enabled:
+            title += self.game_wrapper_metroid_ii.window_title()
         # foreach end
         return title
 
@@ -268,8 +269,6 @@ def stop(self):
             self.debug.stop()
         # foreach end
         # foreach plugins [].stop()
-        if self.disable_input_enabled:
-            self.disable_input.stop()
         if self.auto_pause_enabled:
             self.auto_pause.stop()
         if self.record_replay_enabled:
@@ -292,6 +291,8 @@ def stop(self):
             self.game_wrapper_pokemon_gen1.stop()
         if self.game_wrapper_pokemon_pinball_enabled:
             self.game_wrapper_pokemon_pinball.stop()
+        if self.game_wrapper_metroid_ii_enabled:
+            self.game_wrapper_metroid_ii.stop()
         # foreach end
         if self.generic_game_wrapper_enabled:
             self.generic_game_wrapper.stop()
diff --git a/pyboy/plugins/manager_gen.py b/pyboy/plugins/manager_gen.py
index ad50404d7..b3d0f55be 100644
--- a/pyboy/plugins/manager_gen.py
+++ b/pyboy/plugins/manager_gen.py
@@ -2,7 +2,16 @@
 # License: See LICENSE.md file
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
+
+import importlib
+import importlib.util
+import os
 import re
+import sys
+
+# Makes us able to import PyBoy from the directory below
+file_path = os.path.dirname(os.path.realpath(__file__))
+sys.path.insert(0, file_path + "/../..")
 
 # Plugins and priority!
 # E.g. DisableInput first
@@ -13,9 +22,9 @@
     "GameWrapperKirbyDreamLand",
     "GameWrapperPokemonGen1",
     "GameWrapperPokemonPinball",
+    "GameWrapperMetroidII",
 ]
 plugins = [
-    "DisableInput",
     "AutoPause",
     "RecordReplay",
     "Rewind",
@@ -98,7 +107,7 @@ def skip_lines(iterator, stop):
 
                 for p in all_plugins:
                     p_name = to_snake_case(p)
-                    lines.append(f"from pyboy.plugins.{p_name} import {p} # isort:skip\n")
+                    lines.append(f"from pyboy.plugins.{p_name} import {p} # noqa\n")
 
                 lines.append("# imports end\n")
                 out_lines.extend([indentation + l for l in lines])
@@ -178,7 +187,7 @@ def skip_lines(iterator, stop):
 
                 skip_lines(line_iter, "# docs exclude end")
 
-                for p in (set(all_plugins) - set(game_wrappers)) | set(["manager", "manager_gen"]):
+                for p in sorted(list((set(all_plugins) - set(game_wrappers)) | set(["manager", "manager_gen"]))):
                     p_name = to_snake_case(p)
                     lines.append(f'"{p_name}": False,\n')
 
@@ -189,3 +198,55 @@ def skip_lines(iterator, stop):
 
     with open("__init__.py", "w") as f:
         f.writelines(out_lines)
+
+    out_lines = []
+    with open("../pyboy.py", "r") as f:
+        line_iter = iter(f.readlines())
+        while True:
+            line = next(line_iter, None)
+            if line is None:
+                break
+
+            # Find place to inject
+            if line.strip().startswith("## Plugin kwargs:"):
+                lines = [line.strip() + "\n"]
+                indentation = " " * line.index("## Plugin kwargs:")
+
+                skip_lines(line_iter, "Other keyword arguments may exist")
+
+                for p in sorted(list(set(plugins) - set(game_wrappers))):
+                    p_name = to_snake_case(p)
+                    spec = importlib.util.spec_from_file_location(
+                        p_name, os.path.dirname(os.path.abspath(__file__)) + "/" + p_name + ".py"
+                    )
+                    module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(module)
+
+                    for attr in dir(module):
+                        if attr.startswith("_") or attr == "PyBoyPlugin":
+                            continue
+                        _plugin = getattr(module, attr)
+                        if getattr(_plugin, "__bases__", None) and _plugin.__bases__[0].__name__ == "PyBoyPlugin":
+                            for argv in _plugin.argv:
+                                name, argv_desc = argv
+                                name = name.strip("-").replace("-", "_")
+                                _type = argv_desc.get("type", str).__name__
+                                if argv_desc.get("action") == "store_true":
+                                    _type = "bool"
+                                _help = argv_desc.get("help")
+                                if not _help:
+                                    print("Missing documentation", p_name, argv)
+                                    continue
+                                lines.append(f"* {name} ({_type}): {_help} [plugin: {p}]\n")
+                    del spec, module
+
+                lines.append(
+                    "Other keyword arguments may exist for plugins that are not listed here. They can be viewed by running `pyboy --help` in the terminal.\n"
+                )
+                out_lines.extend([indentation + l for l in lines])
+                out_lines.insert(-1, "\n")  # Avoids whitespace
+            else:
+                out_lines.append(line)
+
+    with open("../pyboy.py", "w") as f:
+        f.writelines(out_lines)
diff --git a/pyboy/plugins/rewind.py b/pyboy/plugins/rewind.py
index a512ec748..a65b6d9b2 100644
--- a/pyboy/plugins/rewind.py
+++ b/pyboy/plugins/rewind.py
@@ -6,19 +6,11 @@
 import array
 
 import pyboy
-from pyboy import utils
 from pyboy.plugins.base_plugin import PyBoyPlugin
-from pyboy.utils import IntIOInterface, WindowEvent
+from pyboy.utils import IntIOInterface, PyBoyException, WindowEvent
 
 logger = pyboy.logging.get_logger(__name__)
 
-try:
-    from cython import compiled
-
-    cythonmode = compiled
-except ImportError:
-    cythonmode = False
-
 FIXED_BUFFER_SIZE = 256 * 1024 * 1024
 FIXED_BUFFER_MIN_ALLOC = 256 * 1024
 FILL_VALUE = 123
@@ -58,7 +50,7 @@ def handle_events(self, events):
                 self.pyboy._pause()
                 if self.rewind_buffer.seek_frame(1):
                     self.mb.load_state(self.rewind_buffer)
-                    events.append(WindowEvent._INTERNAL_RENDERER_FLUSH)
+                    events.append(WindowEvent(WindowEvent._INTERNAL_RENDERER_FLUSH))
                     self.rewind_speed = min(self.rewind_speed * 1.1, 5)
                 else:
                     logger.info("Rewind limit reached")
@@ -68,7 +60,7 @@ def handle_events(self, events):
                 self.pyboy._pause()
                 if self.rewind_buffer.seek_frame(-1):
                     self.mb.load_state(self.rewind_buffer)
-                    events.append(WindowEvent._INTERNAL_RENDERER_FLUSH)
+                    events.append(WindowEvent(WindowEvent._INTERNAL_RENDERER_FLUSH))
                     self.rewind_speed = min(self.rewind_speed * 1.1, 5)
                 else:
                     logger.info("Rewind limit reached")
@@ -131,14 +123,14 @@ def write(self, val):
 
     def read(self):
         if self.section_pointer == self.section_head:
-            raise Exception("Read beyond section")
+            raise PyBoyException("Read beyond section")
         data = self.buffer[self.section_pointer]
         self.section_pointer = (self.section_pointer + 1) % FIXED_BUFFER_SIZE
         return data
 
     def commit(self):
         if not self.section_head == self.section_pointer:
-            raise Exception("Section wasn't read to finish. This would likely be unintentional")
+            raise PyBoyException("Section wasn't read to finish. This would likely be unintentional")
         self.sections = self.sections[: self.current_section + 1]
 
     def seek_frame(self, frames):
diff --git a/pyboy/plugins/screen_recorder.py b/pyboy/plugins/screen_recorder.py
index cd7b7e0b2..708742bea 100644
--- a/pyboy/plugins/screen_recorder.py
+++ b/pyboy/plugins/screen_recorder.py
@@ -7,7 +7,6 @@
 import time
 
 import pyboy
-from pyboy import utils
 from pyboy.plugins.base_plugin import PyBoyPlugin
 from pyboy.utils import WindowEvent
 
diff --git a/pyboy/plugins/screenshot_recorder.py b/pyboy/plugins/screenshot_recorder.py
index a9d92bfb9..e26da3d27 100644
--- a/pyboy/plugins/screenshot_recorder.py
+++ b/pyboy/plugins/screenshot_recorder.py
@@ -7,7 +7,6 @@
 import time
 
 import pyboy
-from pyboy import utils
 from pyboy.plugins.base_plugin import PyBoyPlugin
 from pyboy.utils import WindowEvent
 
diff --git a/pyboy/plugins/window_null.pxd b/pyboy/plugins/window_null.pxd
index a12cb4a85..32332e8f2 100644
--- a/pyboy/plugins/window_null.pxd
+++ b/pyboy/plugins/window_null.pxd
@@ -6,5 +6,6 @@
 from pyboy.logging.logging cimport Logger
 from pyboy.plugins.base_plugin cimport PyBoyWindowPlugin
 
+
 cdef class WindowNull(PyBoyWindowPlugin):
     pass
diff --git a/pyboy/plugins/window_null.py b/pyboy/plugins/window_null.py
index 783dd20d8..934428cee 100644
--- a/pyboy/plugins/window_null.py
+++ b/pyboy/plugins/window_null.py
@@ -4,7 +4,6 @@
 #
 
 import pyboy
-from pyboy import utils
 from pyboy.plugins.base_plugin import PyBoyWindowPlugin
 
 logger = pyboy.logging.get_logger(__name__)
diff --git a/pyboy/plugins/window_open_gl.pxd b/pyboy/plugins/window_open_gl.pxd
index e13dd9101..a246d707e 100644
--- a/pyboy/plugins/window_open_gl.pxd
+++ b/pyboy/plugins/window_open_gl.pxd
@@ -4,17 +4,14 @@
 #
 
 import cython
-cimport cython
-from libc.stdint cimport uint8_t, uint16_t, uint32_t
-
-from pyboy.logging.logging cimport Logger
-from pyboy.plugins.base_plugin cimport PyBoyWindowPlugin
 
 cimport cython
 from libc.stdint cimport int64_t, uint8_t, uint16_t, uint32_t
 
+from pyboy.logging.logging cimport Logger
 from pyboy.plugins.base_plugin cimport PyBoyWindowPlugin
 
+
 cdef Logger logger
 
 cdef int ROWS, COLS
diff --git a/pyboy/plugins/window_open_gl.py b/pyboy/plugins/window_open_gl.py
index 7f336b9e2..838109acd 100644
--- a/pyboy/plugins/window_open_gl.py
+++ b/pyboy/plugins/window_open_gl.py
@@ -3,17 +3,15 @@
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
 
-import time
-
 import numpy as np
 
 import pyboy
-from pyboy import utils
 from pyboy.plugins.base_plugin import PyBoyWindowPlugin
-from pyboy.utils import WindowEvent
+from pyboy.utils import WindowEvent, PyBoyException
 
 logger = pyboy.logging.get_logger(__name__)
 
+# isort: skip_file
 try:
     import OpenGL.GLUT.freeglut
     from OpenGL.GL import (
@@ -63,7 +61,7 @@ def __init__(self, pyboy, mb, pyboy_argv):
             return
 
         if not glutInit():
-            raise Exception("OpenGL couldn't initialize!")
+            raise PyBoyException("OpenGL couldn't initialize!")
         glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA)
         glutInitWindowSize(*self._scaledresolution)
         glutCreateWindow("PyBoy")
diff --git a/pyboy/plugins/window_sdl2.pxd b/pyboy/plugins/window_sdl2.pxd
index 4d6cb843b..ed3a22cb4 100644
--- a/pyboy/plugins/window_sdl2.pxd
+++ b/pyboy/plugins/window_sdl2.pxd
@@ -20,7 +20,7 @@ cdef int ROWS, COLS
 
 cdef object _sdlcontroller
 
-cpdef list sdl2_event_pump(list) noexcept
+cpdef list sdl2_event_pump(list)
 
 
 cdef class WindowSDL2(PyBoyWindowPlugin):
diff --git a/pyboy/plugins/window_sdl2.py b/pyboy/plugins/window_sdl2.py
index 677e9a811..21191576d 100644
--- a/pyboy/plugins/window_sdl2.py
+++ b/pyboy/plugins/window_sdl2.py
@@ -3,9 +3,7 @@
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
 
-import time
 
-from pyboy import utils
 from pyboy.plugins.base_plugin import PyBoyWindowPlugin
 from pyboy.utils import WindowEvent, WindowEventMouse
 
diff --git a/pyboy/pyboy.pxd b/pyboy/pyboy.pxd
index f28edd4f3..c3e809099 100644
--- a/pyboy/pyboy.pxd
+++ b/pyboy/pyboy.pxd
@@ -30,7 +30,7 @@ cdef class PyBoyMemoryView:
     cdef Motherboard mb
 
     @cython.locals(start=int,stop=int,step=int)
-    cpdef (int,int,int) _fix_slice(self, slice)
+    cpdef (int,int,int) _fix_slice(self, slice) noexcept
     @cython.locals(start=int,stop=int,step=int)
     cdef object __getitem(self, int, int, int, int, bint, bint)
     @cython.locals(start=int,stop=int,step=int,x=int, bank=int)
@@ -51,6 +51,7 @@ cdef class PyBoy:
     cdef bint quitting
     cdef bint stopped
     cdef bint initialized
+    cdef bint no_input
     cdef readonly str window_title
     cdef readonly PyBoyMemoryView memory
     cdef readonly PyBoyRegisterFile register_file
@@ -70,32 +71,32 @@ cdef class PyBoy:
     cdef list external_input
 
     @cython.locals(t_start=int64_t, t_pre=int64_t, t_tick=int64_t, t_post=int64_t, nsecs=int64_t)
-    cpdef bint _tick(self, bint) noexcept
-    @cython.locals(running=bint, factor=double)
-    cpdef bint tick(self, count=*, render=*) noexcept
+    cdef bint _tick(self, bint) noexcept nogil
+    @cython.locals(running=bint, _render=bint)
+    cpdef bint tick(self, int count=*, bint render=*) noexcept
     cpdef void stop(self, save=*) noexcept
     cpdef int save_state(self, object) except -1
     cpdef int load_state(self, object) except -1
 
     @cython.locals(state_path=str)
-    cdef void _handle_events(self, list) noexcept
+    cdef void _handle_events(self, list) noexcept with gil
     cpdef void _pause(self) noexcept
     cpdef void _unpause(self) noexcept
     cdef void _update_window_title(self) noexcept
     cdef void _post_tick(self) noexcept
-    cdef void _post_handle_events(self) noexcept
+    cdef void _post_handle_events(self) noexcept with gil
 
     cdef dict _hooks
     cdef object symbols_file
     cdef public dict rom_symbols
     cdef public dict rom_symbols_inverse
-    cpdef bint _handle_hooks(self)
+    cpdef bint _handle_hooks(self) noexcept
     cpdef int hook_register(self, uint16_t, uint16_t, object, object) except -1
     cpdef int hook_deregister(self, uint16_t, uint16_t) except -1
 
-    cpdef bint _is_cpu_stuck(self)
-    cdef void __rendering(self, int) noexcept
+    cpdef bint _is_cpu_stuck(self) noexcept
+    cdef void __rendering(self, int) noexcept nogil
 
-    cpdef object get_sprite(self, int) noexcept
-    cpdef list get_sprite_by_tile_identifier(self, list, on_screen=*) noexcept
-    cpdef object get_tile(self, int) noexcept
+    cpdef object get_sprite(self, int)
+    cpdef list get_sprite_by_tile_identifier(self, list, on_screen=*)
+    cpdef object get_tile(self, int)
diff --git a/pyboy/pyboy.py b/pyboy/pyboy.py
index e65239ee1..7df27c588 100644
--- a/pyboy/pyboy.py
+++ b/pyboy/pyboy.py
@@ -20,7 +20,29 @@
 from pyboy.logging import get_logger
 from pyboy.logging import log_level as _log_level
 from pyboy.plugins.manager import PluginManager, parser_arguments
-from pyboy.utils import IntIOWrapper, WindowEvent
+from pyboy.utils import (
+    IntIOWrapper,
+    PyBoyException,
+    PyBoyInvalidInputException,
+    PyBoyOutOfBoundsException,
+    WindowEvent,
+    cython_compiled,
+)
+
+try:
+    import cython
+except ImportError:
+    class _mock:
+        def __enter__(self):
+            pass
+
+        def __exit__(self, *args):
+            pass
+    exec("""
+class cython:
+    gil = _mock()
+    nogil = _mock()
+""", globals(), locals())
 
 from .api import Sprite, Tile, constants
 from .core.mb import Motherboard
@@ -55,7 +77,10 @@ def __init__(
         sound_emulated=False,
         cgb=None,
         gameshark=None,
+        no_input=False,
         log_level=defaults["log_level"],
+        color_palette=defaults["color_palette"],
+        cgb_color_palette=defaults["cgb_color_palette"],
         **kwargs,
     ):
         """
@@ -90,14 +115,27 @@ def __init__(
             * sound (bool): Enable sound emulation and output.
             * sound_emulated (bool): Enable sound emulation without any output. Used for compatibility.
             * cgb (bool): Forcing Game Boy Color mode.
+            * gameshark (str): GameShark codes to apply.
+            * no_input (bool): Disable all user-input (mostly for autonomous testing)
             * log_level (str): "CRITICAL", "ERROR", "WARNING", "INFO" or "DEBUG"
             * color_palette (tuple): Specify the color palette to use for rendering.
             * cgb_color_palette (list of tuple): Specify the color palette to use for rendering in CGB-mode for non-color games.
 
+        ## Plugin kwargs:
+        * autopause (bool): Enable auto-pausing when window looses focus [plugin: AutoPause]
+        * breakpoints (str): Add breakpoints on start-up (internal use) [plugin: DebugPrompt]
+        * record_input (bool): Record user input and save to a file (internal use) [plugin: RecordReplay]
+        * rewind (bool): Enable rewind function [plugin: Rewind]
+
         Other keyword arguments may exist for plugins that are not listed here. They can be viewed by running `pyboy --help` in the terminal.
         """
 
         self.initialized = False
+        self.no_input = no_input
+
+        _log_level(log_level)
+
+        logger.debug("Cython compilation status: %s", cython_compiled)
 
         if "bootrom_file" in kwargs:
             logger.error(
@@ -122,10 +160,8 @@ def __init__(
             if k not in kwargs:
                 kwargs[k] = v
 
-        _log_level(log_level)
-
         if gamerom is None:
-            raise FileNotFoundError(f"None is not a ROM file!")
+            raise FileNotFoundError("None is not a ROM file!")
 
         if not os.path.isfile(gamerom):
             raise FileNotFoundError(f"ROM file {gamerom} was not found!")
@@ -142,8 +178,8 @@ def __init__(
         self.mb = Motherboard(
             gamerom,
             bootrom,
-            kwargs["color_palette"],
-            kwargs["cgb_color_palette"],
+            color_palette,
+            cgb_color_palette,
             sound,
             sound_emulated,
             cgb,
@@ -390,24 +426,25 @@ def _tick(self, render):
                 # NOTE: Potentially reinject breakpoint that we have now stepped passed
                 self.mb.breakpoint_reinject()
 
-                # NOTE: PC has not been incremented when hitting breakpoint!
-                breakpoint_meta = self.mb.breakpoint_reached()
-                if breakpoint_meta != (-1, -1, -1):
-                    bank, addr, _ = breakpoint_meta
-                    self.mb.breakpoint_remove(bank, addr)
-                    self.mb.breakpoint_singlestep_latch = 0
+                with cython.gil:
+                    # NOTE: PC has not been incremented when hitting breakpoint!
+                    breakpoint_meta = self.mb.breakpoint_reached()
+                    if breakpoint_meta != (-1, -1, -1):
+                        bank, addr, _ = breakpoint_meta
+                        self.mb.breakpoint_remove(bank, addr)
+                        self.mb.breakpoint_singlestep_latch = 0
 
-                    if not self._handle_hooks():
-                        self._plugin_manager.handle_breakpoint()
-                else:
-                    if self.mb.breakpoint_singlestep_latch:
                         if not self._handle_hooks():
                             self._plugin_manager.handle_breakpoint()
-                    # Keep singlestepping on, if that's what we're doing
-                    self.mb.breakpoint_singlestep = self.mb.breakpoint_singlestep_latch
+                    else:
+                        if self.mb.breakpoint_singlestep_latch:
+                            if not self._handle_hooks():
+                                self._plugin_manager.handle_breakpoint()
+                        # Keep singlestepping on, if that's what we're doing
+                        self.mb.breakpoint_singlestep = self.mb.breakpoint_singlestep_latch
 
             self.frame_count += 1
-            self._post_handle_events()
+        self._post_handle_events()
 
         return not self.quitting
 
@@ -459,10 +496,11 @@ def tick(self, count=1, render=True):
         _count = count
         running = False
         t_start = time.perf_counter_ns()
-        while count != 0:
-            _render = render and count == 1  # Only render on last tick to improve performance
-            running = self._tick(_render)
-            count -= 1
+        with cython.nogil:
+            while count != 0:
+                _render = render and count == 1  # Only render on last tick to improve performance
+                running = self._tick(_render)
+                count -= 1
         t_tick = time.perf_counter_ns()
         self._post_tick()
         t_post = time.perf_counter_ns()
@@ -475,8 +513,9 @@ def tick(self, count=1, render=True):
         return running
 
     def _handle_events(self, events):
-        # This feeds events into the tick-loop from the window. There might already be events in the list from the API.
-        events = self._plugin_manager.handle_events(events)
+        if not self.no_input:
+            # This feeds events into the tick-loop from the window. There might already be events in the list from the API.
+            events = self._plugin_manager.handle_events(events)
         for event in events:
             if event == WindowEvent.QUIT:
                 self.quitting = True
@@ -643,7 +682,7 @@ def button(self, input, delay=1):
             self.send_input(WindowEvent.PRESS_BUTTON_SELECT)
             self.send_input(WindowEvent.RELEASE_BUTTON_SELECT, delay)
         else:
-            raise Exception("Unrecognized input:", input)
+            raise PyBoyInvalidInputException("Unrecognized input:", input)
 
     def button_press(self, input):
         """
@@ -686,7 +725,7 @@ def button_press(self, input):
         elif input == "select":
             self.send_input(WindowEvent.PRESS_BUTTON_SELECT)
         else:
-            raise Exception("Unrecognized input")
+            raise PyBoyInvalidInputException("Unrecognized input")
 
     def button_release(self, input):
         """
@@ -728,7 +767,7 @@ def button_release(self, input):
         elif input == "select":
             self.send_input(WindowEvent.RELEASE_BUTTON_SELECT)
         else:
-            raise Exception("Unrecognized input")
+            raise PyBoyInvalidInputException("Unrecognized input")
 
     def send_input(self, event, delay=0):
         """
@@ -769,7 +808,8 @@ def send_input(self, event, delay=0):
         """
 
         if delay:
-            assert delay > 0, "Only positive integers allowed"
+            if not (delay > 0):
+                raise PyBoyInvalidInputException("Only positive integers allowed")
             heapq.heappush(self.queued_input, (self.frame_count + delay, event))
         else:
             self.events.append(WindowEvent(event))
@@ -801,10 +841,12 @@ def save_state(self, file_like_object):
         """
 
         if isinstance(file_like_object, str):
-            raise Exception("String not allowed. Did you specify a filepath instead of a file-like object?")
+            raise PyBoyInvalidInputException(
+                "String not allowed. Did you specify a filepath instead of a file-like object?"
+            )
 
         if file_like_object.__class__.__name__ == "TextIOWrapper":
-            raise Exception("Text file not allowed. Did you specify open(..., 'wb')?")
+            raise PyBoyInvalidInputException("Text file not allowed. Did you specify open(..., 'wb')?")
 
         self.mb.save_state(IntIOWrapper(file_like_object))
 
@@ -829,10 +871,12 @@ def load_state(self, file_like_object):
         """
 
         if isinstance(file_like_object, str):
-            raise Exception("String not allowed. Did you specify a filepath instead of a file-like object?")
+            raise PyBoyInvalidInputException(
+                "String not allowed. Did you specify a filepath instead of a file-like object?"
+            )
 
         if file_like_object.__class__.__name__ == "TextIOWrapper":
-            raise Exception("Text file not allowed. Did you specify open(..., 'rb')?")
+            raise PyBoyInvalidInputException("Text file not allowed. Did you specify open(..., 'rb')?")
 
         self.mb.load_state(IntIOWrapper(file_like_object))
 
@@ -1038,15 +1082,15 @@ def _load_symbols(self):
                             bank, addr, sym_label = re.split(":| ", line.strip())
                             bank = int(bank, 16)
                             addr = int(addr, 16)
-                            if not bank in self.rom_symbols:
+                            if bank not in self.rom_symbols:
                                 self.rom_symbols[bank] = {}
 
-                            if not addr in self.rom_symbols[bank]:
+                            if addr not in self.rom_symbols[bank]:
                                 self.rom_symbols[bank][addr] = []
 
                             self.rom_symbols[bank][addr].append(sym_label)
                             self.rom_symbols_inverse[sym_label] = (bank, addr)
-                        except ValueError as ex:
+                        except ValueError:
                             logger.warning("Skipping .sym line: %s", line.strip())
         return self.rom_symbols
 
@@ -1304,7 +1348,7 @@ def rtc_lock_experimental(self, enable):
         if self.mb.cartridge.rtc_enabled:
             self.mb.cartridge.rtc.timelock = enable
         else:
-            raise Exception("There's no RTC for this cartridge type")
+            raise PyBoyException("There's no RTC for this cartridge type")
 
 
 class PyBoyRegisterFile:
@@ -1534,13 +1578,17 @@ def __getitem__(self, addr):
         bank = 0
         if is_bank:
             bank, addr = addr
-            assert isinstance(bank, int), "Bank has to be integer. Slicing is not supported."
+            if not (isinstance(bank, int)):
+                raise PyBoyInvalidInputException("Bank has to be integer. Slicing is not supported.")
         is_single = isinstance(addr, int)
         if not is_single:
             start, stop, step = self._fix_slice(addr)
-            assert start >= 0 or stop >= 0, "Start address has to come before end address"
-            assert start >= 0, "Start address required"
-            assert stop >= 0, "End address required"
+            if not (start >= 0 or stop >= 0):
+                raise PyBoyInvalidInputException("Start address has to come before end address")
+            if not (start >= 0):
+                raise PyBoyInvalidInputException("Start address required")
+            if not (stop >= 0):
+                raise PyBoyInvalidInputException("End address required")
             return self.__getitem(start, stop, step, bank, is_single, is_bank)
         else:
             return self.__getitem(addr, 0, 1, bank, is_single, is_bank)
@@ -1554,10 +1602,13 @@ def __getitem(self, start, stop, step, bank, is_single, is_bank):
                     start -= 0x4000
                     stop -= 0x4000
                 # Cartridge ROM Banks
-                assert stop < 0x4000, "Out of bounds for reading ROM bank"
+                if not (stop < 0x4000):
+                    raise PyBoyOutOfBoundsException("Out of bounds for reading ROM bank")
                 if bank == -1:
-                    assert start <= 0xFF, "Start address out of range for bootrom"
-                    assert stop <= 0xFF, "Start address out of range for bootrom"
+                    if not (start <= 0xFF):
+                        raise PyBoyOutOfBoundsException("Start address out of range for bootrom")
+                    if not (stop <= 0xFF):
+                        raise PyBoyOutOfBoundsException("Start address out of range for bootrom")
                     if not is_single:
                         mem_slice = [0] * slice_length
                         for x in range(start, stop, step):
@@ -1566,7 +1617,8 @@ def __getitem(self, start, stop, step, bank, is_single, is_bank):
                     else:
                         return self.mb.bootrom.bootrom[start]
                 else:
-                    assert bank <= self.mb.cartridge.external_rom_count, "ROM Bank out of range"
+                    if not (bank <= self.mb.cartridge.external_rom_count):
+                        raise PyBoyOutOfBoundsException("ROM Bank out of range")
                     if not is_single:
                         mem_slice = [0] * slice_length
                         for x in range(start, stop, step):
@@ -1578,9 +1630,12 @@ def __getitem(self, start, stop, step, bank, is_single, is_bank):
                 start -= 0x8000
                 stop -= 0x8000
                 # CGB VRAM Banks
-                assert self.mb.cgb or (bank == 0), "Selecting bank of VRAM is only supported for CGB mode"
-                assert stop < 0x2000, "Out of bounds for reading VRAM bank"
-                assert bank <= 1, "VRAM Bank out of range"
+                if not (self.mb.cgb or (bank == 0)):
+                    raise PyBoyInvalidInputException("Selecting bank of VRAM is only supported for CGB mode")
+                if not (stop < 0x2000):
+                    raise PyBoyOutOfBoundsException("Out of bounds for reading VRAM bank")
+                if not (bank <= 1):
+                    raise PyBoyOutOfBoundsException("VRAM Bank out of range")
 
                 if bank == 0:
                     if not is_single:
@@ -1602,8 +1657,10 @@ def __getitem(self, start, stop, step, bank, is_single, is_bank):
                 start -= 0xA000
                 stop -= 0xA000
                 # Cartridge RAM banks
-                assert stop < 0x2000, "Out of bounds for reading cartridge RAM bank"
-                assert bank <= self.mb.cartridge.external_ram_count, "ROM Bank out of range"
+                if not (stop < 0x2000):
+                    raise PyBoyOutOfBoundsException("Out of bounds for reading cartridge RAM bank")
+                if not (bank <= self.mb.cartridge.external_ram_count):
+                    raise PyBoyOutOfBoundsException("ROM Bank out of range")
                 if not is_single:
                     mem_slice = [0] * slice_length
                     for x in range(start, stop, step):
@@ -1618,9 +1675,12 @@ def __getitem(self, start, stop, step, bank, is_single, is_bank):
                     start -= 0x1000
                     stop -= 0x1000
                 # CGB VRAM banks
-                assert self.mb.cgb or (bank == 0), "Selecting bank of WRAM is only supported for CGB mode"
-                assert stop < 0x1000, "Out of bounds for reading VRAM bank"
-                assert bank <= 7, "WRAM Bank out of range"
+                if not (self.mb.cgb or (bank == 0)):
+                    raise PyBoyInvalidInputException("Selecting bank of WRAM is only supported for CGB mode")
+                if not (stop < 0x1000):
+                    raise PyBoyOutOfBoundsException("Out of bounds for reading VRAM bank")
+                if not (bank <= 7):
+                    raise PyBoyOutOfBoundsException("WRAM Bank out of range")
                 if not is_single:
                     mem_slice = [0] * slice_length
                     for x in range(start, stop, step):
@@ -1629,7 +1689,7 @@ def __getitem(self, start, stop, step, bank, is_single, is_bank):
                 else:
                     return self.mb.ram.internal_ram0[start + bank * 0x1000]
             else:
-                assert None, "Invalid memory address for bank"
+                raise PyBoyInvalidInputException("Invalid memory address for bank")
         elif not is_single:
             # Reading slice of memory space
             mem_slice = [0] * slice_length
@@ -1645,12 +1705,15 @@ def __setitem__(self, addr, v):
         bank = 0
         if is_bank:
             bank, addr = addr
-            assert isinstance(bank, int), "Bank has to be integer. Slicing is not supported."
+            if not (isinstance(bank, int)):
+                raise PyBoyInvalidInputException("Bank has to be integer. Slicing is not supported.")
         is_single = isinstance(addr, int)
         if not is_single:
             start, stop, step = self._fix_slice(addr)
-            assert start >= 0, "Start address required"
-            assert stop >= 0, "End address required"
+            if not (start >= 0):
+                raise PyBoyInvalidInputException("Start address required")
+            if not (stop >= 0):
+                raise PyBoyInvalidInputException("End address required")
             self.__setitem(start, stop, step, v, bank, is_single, is_bank)
         else:
             self.__setitem(addr, 0, 0, v, bank, is_single, is_bank)
@@ -1678,16 +1741,21 @@ def __setitem(self, start, stop, step, v, bank, is_single, is_bank):
                     start -= 0x4000
                     stop -= 0x4000
                 # Cartridge ROM Banks
-                assert stop <= 0x4000, "Out of bounds for reading ROM bank"
-                assert bank <= self.mb.cartridge.external_rom_count, "ROM Bank out of range"
+                if not (stop <= 0x4000):
+                    raise PyBoyOutOfBoundsException("Out of bounds for reading ROM bank")
+                if not (bank <= self.mb.cartridge.external_rom_count):
+                    raise PyBoyOutOfBoundsException("ROM Bank out of range")
 
                 if bank == -1:
-                    assert start <= 0xFF, "Start address out of range for bootrom"
-                    assert stop <= 0x100, "Start address out of range for bootrom"
+                    if not (start <= 0xFF):
+                        raise PyBoyOutOfBoundsException("Start address out of range for bootrom")
+                    if not (stop <= 0x100):
+                        raise PyBoyOutOfBoundsException("Start address out of range for bootrom")
                     if not is_single:
                         # Writing slice of memory space
                         if hasattr(v, "__iter__"):
-                            assert (stop - start) // step == len(v), "slice does not match length of data"
+                            if not ((stop - start) // step == len(v)):
+                                raise PyBoyInvalidInputException("slice does not match length of data")
                             _v = iter(v)
                             for x in range(start, stop, step):
                                 self.mb.bootrom.bootrom[x] = next(_v)
@@ -1700,7 +1768,8 @@ def __setitem(self, start, stop, step, v, bank, is_single, is_bank):
                     if not is_single:
                         # Writing slice of memory space
                         if hasattr(v, "__iter__"):
-                            assert (stop - start) // step == len(v), "slice does not match length of data"
+                            if not ((stop - start) // step == len(v)):
+                                raise PyBoyInvalidInputException("slice does not match length of data")
                             _v = iter(v)
                             for x in range(start, stop, step):
                                 self.mb.cartridge.overrideitem(bank, x, next(_v))
@@ -1714,15 +1783,19 @@ def __setitem(self, start, stop, step, v, bank, is_single, is_bank):
                 start -= 0x8000
                 stop -= 0x8000
                 # CGB VRAM Banks
-                assert self.mb.cgb or (bank == 0), "Selecting bank of VRAM is only supported for CGB mode"
-                assert stop <= 0x2000, "Out of bounds for reading VRAM bank"
-                assert bank <= 1, "VRAM Bank out of range"
+                if not (self.mb.cgb or (bank == 0)):
+                    raise PyBoyInvalidInputException("Selecting bank of VRAM is only supported for CGB mode")
+                if not (stop <= 0x2000):
+                    raise PyBoyOutOfBoundsException("Out of bounds for reading VRAM bank")
+                if not (bank <= 1):
+                    raise PyBoyOutOfBoundsException("VRAM Bank out of range")
 
                 if bank == 0:
                     if not is_single:
                         # Writing slice of memory space
                         if hasattr(v, "__iter__"):
-                            assert (stop - start) // step == len(v), "slice does not match length of data"
+                            if not ((stop - start) // step == len(v)):
+                                raise PyBoyInvalidInputException("slice does not match length of data")
                             _v = iter(v)
                             for x in range(start, stop, step):
                                 self.mb.lcd.VRAM0[x] = next(_v)
@@ -1735,7 +1808,8 @@ def __setitem(self, start, stop, step, v, bank, is_single, is_bank):
                     if not is_single:
                         # Writing slice of memory space
                         if hasattr(v, "__iter__"):
-                            assert (stop - start) // step == len(v), "slice does not match length of data"
+                            if not ((stop - start) // step == len(v)):
+                                raise PyBoyInvalidInputException("slice does not match length of data")
                             _v = iter(v)
                             for x in range(start, stop, step):
                                 self.mb.lcd.VRAM1[x] = next(_v)
@@ -1748,12 +1822,15 @@ def __setitem(self, start, stop, step, v, bank, is_single, is_bank):
                 start -= 0xA000
                 stop -= 0xA000
                 # Cartridge RAM banks
-                assert stop <= 0x2000, "Out of bounds for reading cartridge RAM bank"
-                assert bank <= self.mb.cartridge.external_ram_count, "ROM Bank out of range"
+                if not (stop <= 0x2000):
+                    raise PyBoyOutOfBoundsException("Out of bounds for reading cartridge RAM bank")
+                if not (bank <= self.mb.cartridge.external_ram_count):
+                    raise PyBoyOutOfBoundsException("ROM Bank out of range")
                 if not is_single:
                     # Writing slice of memory space
                     if hasattr(v, "__iter__"):
-                        assert (stop - start) // step == len(v), "slice does not match length of data"
+                        if not ((stop - start) // step == len(v)):
+                            raise PyBoyInvalidInputException("slice does not match length of data")
                         _v = iter(v)
                         for x in range(start, stop, step):
                             self.mb.cartridge.rambanks[bank, x] = next(_v)
@@ -1769,13 +1846,17 @@ def __setitem(self, start, stop, step, v, bank, is_single, is_bank):
                     start -= 0x1000
                     stop -= 0x1000
                 # CGB VRAM banks
-                assert self.mb.cgb or (bank == 0), "Selecting bank of WRAM is only supported for CGB mode"
-                assert stop <= 0x1000, "Out of bounds for reading VRAM bank"
-                assert bank <= 7, "WRAM Bank out of range"
+                if not (self.mb.cgb or (bank == 0)):
+                    raise PyBoyInvalidInputException("Selecting bank of WRAM is only supported for CGB mode")
+                if not (stop <= 0x1000):
+                    raise PyBoyOutOfBoundsException("Out of bounds for reading VRAM bank")
+                if not (bank <= 7):
+                    raise PyBoyOutOfBoundsException("WRAM Bank out of range")
                 if not is_single:
                     # Writing slice of memory space
                     if hasattr(v, "__iter__"):
-                        assert (stop - start) // step == len(v), "slice does not match length of data"
+                        if not ((stop - start) // step == len(v)):
+                            raise PyBoyInvalidInputException("slice does not match length of data")
                         _v = iter(v)
                         for x in range(start, stop, step):
                             self.mb.ram.internal_ram0[x + bank * 0x1000] = next(_v)
@@ -1785,11 +1866,12 @@ def __setitem(self, start, stop, step, v, bank, is_single, is_bank):
                 else:
                     self.mb.ram.internal_ram0[start + bank * 0x1000] = v
             else:
-                assert None, "Invalid memory address for bank"
+                raise PyBoyInvalidInputException("Invalid memory address for bank")
         elif not is_single:
             # Writing slice of memory space
             if hasattr(v, "__iter__"):
-                assert (stop - start) // step == len(v), "slice does not match length of data"
+                if not ((stop - start) // step == len(v)):
+                    raise PyBoyInvalidInputException("slice does not match length of data")
                 _v = iter(v)
                 for x in range(start, stop, step):
                     self.mb.setitem(x, next(_v))
diff --git a/pyboy/utils.py b/pyboy/utils.py
index 53c70c189..7c12fdb7f 100644
--- a/pyboy/utils.py
+++ b/pyboy/utils.py
@@ -5,7 +5,47 @@
 
 __all__ = ["WindowEvent", "dec_to_bcd", "bcd_to_dec"]
 
-STATE_VERSION = 12
+STATE_VERSION = 13
+
+
+class PyBoyException(Exception):
+    pass
+
+
+class PyBoyAssertException(PyBoyException):
+    pass
+
+
+class PyBoyOutOfBoundsException(PyBoyException):
+    pass
+
+
+class PyBoyNotImplementedException(PyBoyException):
+    pass
+
+
+class PyBoyInvalidInputException(PyBoyException):
+    pass
+
+
+class PyBoyDependencyError(PyBoyException):
+    pass
+
+
+class PillowImportError:
+    def __bool__(self):
+        return False
+
+    def __getattribute__(self, name):
+        raise PyBoyDependencyError("Missing depencency Pillow!")
+
+
+try:
+    from cython import compiled
+
+    cython_compiled = compiled
+except ImportError:
+    cython_compiled = False
 
 ##############################################################
 # Buffer classes
@@ -16,7 +56,7 @@ def __init__(self, buf):
         pass
 
     def write(self, byte):
-        raise Exception("Not implemented!")
+        raise PyBoyNotImplementedException("Not implemented!")
 
     def write_64bit(self, value):
         self.write(value & 0xFF)
@@ -62,25 +102,25 @@ def read_16bit(self):
         return int(a | (b << 8))
 
     def read(self):
-        raise Exception("Not implemented!")
+        raise PyBoyNotImplementedException("Not implemented!")
 
     def seek(self, pos):
-        raise Exception("Not implemented!")
+        raise PyBoyNotImplementedException("Not implemented!")
 
     def flush(self):
-        raise Exception("Not implemented!")
+        raise PyBoyNotImplementedException("Not implemented!")
 
     def new(self):
-        raise Exception("Not implemented!")
+        raise PyBoyNotImplementedException("Not implemented!")
 
     def commit(self):
-        raise Exception("Not implemented!")
+        raise PyBoyNotImplementedException("Not implemented!")
 
     def seek_frame(self, _):
-        raise Exception("Not implemented!")
+        raise PyBoyNotImplementedException("Not implemented!")
 
     def tell(self):
-        raise Exception("Not implemented!")
+        raise PyBoyNotImplementedException("Not implemented!")
 
 
 class IntIOWrapper(IntIOInterface):
@@ -93,14 +133,16 @@ def __init__(self, buf):
         self.buffer = buf
 
     def write(self, byte):
-        assert isinstance(byte, int)
-        assert 0 <= byte <= 0xFF
+        if not isinstance(byte, int):
+            raise PyBoyAssertException("Input has to be of type 'int'")
+        if not (0 <= byte <= 0xFF):
+            raise PyBoyOutOfBoundsException("Input has to be positive and less than or equal to 255")
         return self.buffer.write(byte.to_bytes(1, "little"))
 
     def read(self):
-        # assert count == 1, "Only a count of 1 is supported"
         data = self.buffer.read(1)
-        assert len(data) == 1, "No data"
+        if not (len(data) == 1):
+            raise PyBoyAssertException("No data")
         return ord(data)
 
     def seek(self, pos):
diff --git a/pyproject.toml b/pyproject.toml
index 913631bd2..ce1b6d82d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -16,7 +16,7 @@ classifiers = [
     "Programming Language :: Python :: Implementation :: PyPy",
     "Topic :: System :: Emulators",
 ]
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 
 dependencies = [
     "numpy",
@@ -63,6 +63,18 @@ packages = ["pyboy", "pyboy.api", "pyboy.core", "pyboy.core.cartridge", "pyboy.l
     "**/font.txt"
 ]
 
+[tool.pytest.ini_options]
+addopts = "--benchmark-disable"
+testpaths = [
+    "tests",
+    "pyboy",
+]
+filterwarnings = [
+    "error",
+    "ignore:Using SDL2 binaries from pysdl2-dll.*",
+    "ignore:pysdl2-dll is installed as source-only.*"
+]
+
 [tool.ruff]
 line-length = 120
 
diff --git a/requirements_tests.txt b/requirements_tests.txt
index 227b84625..945c479ac 100644
--- a/requirements_tests.txt
+++ b/requirements_tests.txt
@@ -1,6 +1,7 @@
 -r requirements.txt
 pillow>=9.1.0
 pytest>=6.0.0
+pytest-benchmark
 pytest-xdist
 pytest-lazy-fixtures
 pyopengl
diff --git a/setup.py b/setup.py
index 51c253e87..91a12c912 100644
--- a/setup.py
+++ b/setup.py
@@ -3,20 +3,21 @@
 import platform
 import sys
 from multiprocessing import cpu_count
+import numpy as np
 
 from setuptools import Extension, setup
 
 CYTHON = platform.python_implementation() == "CPython"
 ROOT_DIR = "pyboy"
+DEBUG = False
 
 if not CYTHON:
     setup()
     exit(0)
 
-import numpy as np
-from Cython.Build import cythonize
-from Cython.Compiler import DebugFlags, Errors
-from Cython.Distutils import build_ext as _build_ext
+from Cython.Build import cythonize  # noqa
+from Cython.Compiler import DebugFlags, Errors  # noqa
+from Cython.Distutils import build_ext as _build_ext  # noqa
 
 
 def patched_error(position, message):
@@ -56,6 +57,8 @@ def initialize_options(self):
             multiprocessing.set_start_method("fork", force=True)
 
         cflags = ["-O3"]
+        if not DEBUG:
+            cflags.append("-DCYTHON_WITHOUT_ASSERTIONS")
         # NOTE: For performance. Check if other platforms need an equivalent change.
         if sys.platform == "darwin":
             cflags.append("-DCYTHON_INLINE=inline __attribute__ ((__unused__)) __attribute__((always_inline))")
@@ -66,7 +69,7 @@ def initialize_options(self):
                 src.split(".")[0].replace(os.sep, "."),
                 [src],
                 extra_compile_args=cflags,
-                extra_link_args=["-s", "-w"],
+                extra_link_args=[] if DEBUG else ["-s", "-w"],
                 include_dirs=[np.get_include()],
             ),
             list(py_pxd_files),
diff --git a/tests/conftest.py b/tests/conftest.py
index f5f4d789f..94059be4a 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -11,16 +11,16 @@
 import urllib.request
 from pathlib import Path
 from zipfile import ZipFile
+import git
+import pytest
+from cryptography.fernet import Fernet
+from filelock import FileLock
 
 import numpy as np
 
 np.set_printoptions(threshold=2**32)
 np.set_printoptions(linewidth=np.inf)
 
-import git
-import pytest
-from cryptography.fernet import Fernet
-from filelock import FileLock
 
 BOOTROM_FRAMES_UNTIL_LOGO = 6
 BOOTROM_FRAMES_UNTIL_END = 60 + BOOTROM_FRAMES_UNTIL_LOGO
@@ -145,7 +145,7 @@ def any_rom_cgb(secrets, pokemon_crystal_rom):
 @pytest.fixture(scope="session")
 def samesuite_dir():
     path = extra_test_rom_dir / Path("SameSuite")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isdir(path):
             print(url_open("https://pyboy.dk/mirror/LICENSE.SameSuite.txt"))
             samesuite_data = io.BytesIO(url_open("https://pyboy.dk/mirror/SameSuite.zip"))
@@ -157,7 +157,7 @@ def samesuite_dir():
 @pytest.fixture(scope="session")
 def mooneye_dir():
     path = extra_test_rom_dir / Path("mooneye")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isdir(path):
             print(url_open("https://pyboy.dk/mirror/LICENSE.mooneye.txt"))
             mooneye_data = io.BytesIO(url_open("https://pyboy.dk/mirror/mooneye.zip"))
@@ -169,7 +169,7 @@ def mooneye_dir():
 @pytest.fixture(scope="session")
 def magen_test_file():
     path = extra_test_rom_dir / Path("magen_test2.gb")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isfile(path):
             print(url_open("https://pyboy.dk/mirror/LICENSE.magen_test.txt"))
             magen_test_data = url_open("https://pyboy.dk/mirror/magen_test_bg_oam_priority.gbc")
@@ -181,7 +181,7 @@ def magen_test_file():
 @pytest.fixture(scope="session")
 def blargg_dir():
     path = Path(extra_test_rom_dir) / Path("blargg")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isdir(path):
             print(url_open("https://pyboy.dk/mirror/LICENSE.blargg.txt"))
 
@@ -205,7 +205,7 @@ def blargg_dir():
 @pytest.fixture(scope="session")
 def dmg_acid_file():
     path = extra_test_rom_dir / Path("dmg_acid2.gb")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isfile(path):
             print(url_open("https://pyboy.dk/mirror/LICENSE.dmg-acid2.txt"))
             dmg_acid_data = url_open("https://pyboy.dk/mirror/dmg-acid2.gb")
@@ -217,7 +217,7 @@ def dmg_acid_file():
 @pytest.fixture(scope="session")
 def cgb_acid_file():
     path = extra_test_rom_dir / Path("cgb_acid2.gbc")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isfile(path):
             print(url_open("https://pyboy.dk/mirror/LICENSE.cgb-acid2.txt"))
             cgb_acid_data = url_open("https://pyboy.dk/mirror/cgb-acid2.gbc")
@@ -229,7 +229,7 @@ def cgb_acid_file():
 @pytest.fixture(scope="session")
 def shonumi_dir():
     path = extra_test_rom_dir / Path("GB Tests")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isdir(path):
             print(url_open("https://pyboy.dk/mirror/SOURCE.GBTests.txt"))
             shonumi_data = io.BytesIO(url_open("https://pyboy.dk/mirror/GB%20Tests.zip"))
@@ -238,10 +238,23 @@ def shonumi_dir():
     return str(path) + "/"
 
 
+# https://github.com/Powerlated/TurtleTests
+@pytest.fixture(scope="session")
+def turtletests_dir():
+    path = extra_test_rom_dir / Path("TurtleTests")
+    with FileLock(path.with_suffix(".lock")):
+        if not os.path.isdir(path):
+            print(url_open("https://pyboy.dk/mirror/LICENSE.TurtleTests.txt"))
+            turtle_data = io.BytesIO(url_open("https://pyboy.dk/mirror/TurtleTests.zip"))
+            with ZipFile(turtle_data) as _zip:
+                _zip.extractall(path)
+    return str(path) + "/"
+
+
 @pytest.fixture(scope="session")
 def rtc3test_file():
     path = extra_test_rom_dir / Path("rtc3test.gb")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isfile(path):
             print(url_open("https://pyboy.dk/mirror/LICENSE.rtc3test.txt"))
             rtc3test_data = url_open("https://pyboy.dk/mirror/rtc3test.gb")
@@ -254,7 +267,7 @@ def rtc3test_file():
 @pytest.fixture(scope="session")
 def which_file():
     path = extra_test_rom_dir / Path("which.gb")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isfile(path):
             print(url_open("https://pyboy.dk/mirror/LICENSE.which.txt"))
             which_data = url_open("https://pyboy.dk/mirror/which.gb")
@@ -267,7 +280,7 @@ def which_file():
 @pytest.fixture(scope="session")
 def whichboot_file():
     path = extra_test_rom_dir / Path("whichboot.gb")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isfile(path):
             print(url_open("https://pyboy.dk/mirror/LICENSE.whichboot.txt"))
             whichboot_data = url_open("https://pyboy.dk/mirror/whichboot.gb")
@@ -276,6 +289,19 @@ def whichboot_file():
     return str(path)
 
 
+# https://gitlab.com/BonsaiDen/vectroid.gb
+@pytest.fixture(scope="session")
+def vectroid_file():
+    path = extra_test_rom_dir / Path("vectroid.gb")
+    with FileLock(path.with_suffix(".lock")):
+        if not os.path.isfile(path):
+            print(url_open("https://pyboy.dk/mirror/LICENSE.vectroid.txt"))
+            vectroid_data = url_open("https://pyboy.dk/mirror/vectroid.gbc")
+            with open(path, "wb") as rom_file:
+                rom_file.write(vectroid_data)
+    return str(path)
+
+
 @pytest.fixture(scope="session")
 def git_tetris_ai():
     if os.path.isfile("extras/README/7.gif") or platform.system() == "Windows":
@@ -284,7 +310,7 @@ def git_tetris_ai():
     import venv
 
     path = Path("tetris")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isdir(path):
             # NOTE: No affiliation
             repo = git.Repo.clone_from("https://github.com/uiucanh/tetris.git", path)
@@ -312,7 +338,7 @@ def git_pyboy_rl():
     import venv
 
     path = Path("PyBoy-RL")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isdir(path):
             # NOTE: No affiliation
             repo = git.Repo.clone_from("https://github.com/lixado/PyBoy-RL.git", path)
@@ -335,7 +361,7 @@ def git_pokemon_red_experiments():
     import venv
 
     path = Path("PokemonRedExperiments")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isdir(path):
             # NOTE: No affiliation
             repo = git.Repo.clone_from("https://github.com/PWhiddy/PokemonRedExperiments.git", path)
@@ -356,7 +382,7 @@ def git_pokemon_red_experiments():
 @pytest.fixture(scope="session")
 def secrets():
     path = extra_test_rom_dir / Path("secrets")
-    with FileLock(path.with_suffix(".lock")) as lock:
+    with FileLock(path.with_suffix(".lock")):
         if not os.path.isdir(path):
             if not os.environ.get("PYTEST_SECRETS_KEY"):
                 pytest.skip("Cannot access secrets")
diff --git a/tests/test_basics.py b/tests/test_basics.py
index edf44256b..01ff52eeb 100644
--- a/tests/test_basics.py
+++ b/tests/test_basics.py
@@ -6,10 +6,10 @@
 import hashlib
 import os
 import os.path
-import platform
 import sys
 from io import BytesIO
 from pathlib import Path
+from unittest import mock
 
 import PIL
 import pytest
@@ -18,31 +18,29 @@
 from pyboy import PyBoy
 from pyboy import __main__ as main
 from pyboy.api.tile import Tile
-from pyboy.utils import WindowEvent
-
-is_pypy = platform.python_implementation() == "PyPy"
+from pyboy.utils import WindowEvent, cython_compiled
 
 
 def test_log_level_none(default_rom, capsys):
-    pyboy = PyBoy(default_rom, window="null")
+    PyBoy(default_rom, window="null")
     captured = capsys.readouterr()
     assert captured.out == ""
 
 
 def test_log_level_default(default_rom, capsys):
-    pyboy = PyBoy(default_rom, window="dummy")
+    PyBoy(default_rom, window="dummy")
     captured = capsys.readouterr()
     assert "pyboy.plugins.window_null      ERROR" in captured.out
 
 
-def test_log_level_default(default_rom, capsys):
-    pyboy = PyBoy(default_rom, window="dummy", log_level="ERROR")
+def test_log_level_error(default_rom, capsys):
+    PyBoy(default_rom, window="dummy", log_level="ERROR")
     captured = capsys.readouterr()
     assert "pyboy.plugins.window_null      ERROR" in captured.out
 
 
 def test_log_level_critical(default_rom, capsys):
-    pyboy = PyBoy(default_rom, window="dummy", log_level="CRITICAL")
+    PyBoy(default_rom, window="dummy", log_level="CRITICAL")
     captured = capsys.readouterr()
     assert captured.out == ""
 
@@ -89,6 +87,35 @@ def dump_registers(p):
     assert registers == [0x1, 208, 0, 0, 0, 143, 135, 0xFF00, 0x100]
 
 
+def test_button(default_rom):
+    pyboy = PyBoy(default_rom, window="null")
+    pyboy.set_emulation_speed(0)
+
+    pyboy.tick(1, False)
+    pyboy.memory[0xFF00] = 0b0010_0000  # Select d-pad (bit-4 low)
+    assert pyboy.memory[0xFF00] == 0b0000_1111  # High means released
+
+    pyboy.button("down")
+    pyboy.tick(1, False)
+    pyboy.memory[0xFF00] = 0b0010_0000
+    assert pyboy.memory[0xFF00] == 0b0000_0111  # down pressed
+    pyboy.tick(1, False)
+    pyboy.memory[0xFF00] = 0b0010_0000
+    assert pyboy.memory[0xFF00] == 0b0000_1111  # auto-reset
+
+    pyboy.button("down")
+    pyboy.tick(1, False)
+    pyboy.memory[0xFF00] = 0b0010_0000
+    assert pyboy.memory[0xFF00] == 0b0000_0111  # down pressed
+    pyboy.button("down")
+    pyboy.tick(1, False)
+    pyboy.memory[0xFF00] = 0b0010_0000
+    assert pyboy.memory[0xFF00] == 0b0000_0111  # down is kept pressed
+    pyboy.tick(1, False)
+    pyboy.memory[0xFF00] = 0b0010_0000
+    assert pyboy.memory[0xFF00] == 0b0000_1111  # auto-reset
+
+
 def test_record_replay(boot_rom, default_rom):
     pyboy = PyBoy(default_rom, window="null", bootrom=boot_rom, record_input=True)
     pyboy.set_emulation_speed(0)
@@ -163,6 +190,62 @@ def test_argv_parser(*args):
         assert flags[k] == v
 
 
+def test_pause_toggle(default_rom):
+    pyboy = PyBoy(default_rom, window="null")
+
+    pyboy.send_input(WindowEvent.PAUSE_TOGGLE)
+    pyboy.tick()
+    assert pyboy.paused
+
+    # Just verify pause sticks
+    for _ in range(10):
+        pyboy.tick()
+        assert pyboy.paused
+
+    pyboy.send_input(WindowEvent.PAUSE_TOGGLE)
+    pyboy.tick()
+    assert not pyboy.paused
+
+    # Just verify unpause sticks
+    for _ in range(10):
+        pyboy.tick()
+        assert not pyboy.paused
+
+
+@pytest.mark.skipif(cython_compiled, reason="This test requires access to internal functions not available in Cython")
+def test_no_input_enabled(default_rom):
+    pyboy = PyBoy(default_rom, no_input=True)
+    pyboy.set_emulation_speed(0)
+    with mock.patch("pyboy.plugins.window_sdl2.sdl2_event_pump", return_value=[WindowEvent(WindowEvent.PAUSE)]):
+        pyboy.tick()
+        assert not pyboy.paused
+
+    pyboy.send_input(WindowEvent.PAUSE)
+    pyboy.tick()
+    assert pyboy.paused
+
+    pyboy.send_input(WindowEvent.UNPAUSE)
+    pyboy.tick()
+    assert not pyboy.paused
+
+
+@pytest.mark.skipif(cython_compiled, reason="This test requires access to internal functions not available in Cython")
+def test_no_input_disabled(default_rom):
+    pyboy = PyBoy(default_rom, no_input=False)
+    pyboy.set_emulation_speed(0)
+    with mock.patch("pyboy.plugins.window_sdl2.sdl2_event_pump", return_value=[WindowEvent(WindowEvent.PAUSE)]):
+        pyboy.tick()
+        assert pyboy.paused
+
+    pyboy.send_input(WindowEvent.PAUSE)
+    pyboy.tick()
+    assert pyboy.paused
+
+    pyboy.send_input(WindowEvent.UNPAUSE)
+    pyboy.tick()
+    assert not pyboy.paused
+
+
 def test_tilemaps(kirby_rom):
     pyboy = PyBoy(kirby_rom, window="null")
     pyboy.set_emulation_speed(0)
@@ -280,7 +363,7 @@ def test_all_modes(cgb, _bootrom, frames, rom, any_rom_cgb, boot_cgb_rom):
     if cgb == False and _bootrom == boot_cgb_rom:
         pytest.skip("Invalid combination")
 
-    if cgb == None and _bootrom == boot_cgb_rom and rom != any_rom_cgb:
+    if cgb is None and _bootrom == boot_cgb_rom and rom != any_rom_cgb:
         pytest.skip("Invalid combination")
 
     pyboy = PyBoy(rom, window="null", bootrom=_bootrom, cgb=cgb)
diff --git a/tests/test_benchmark.py b/tests/test_benchmark.py
new file mode 100644
index 000000000..ba1862b9f
--- /dev/null
+++ b/tests/test_benchmark.py
@@ -0,0 +1,39 @@
+#
+# License: See LICENSE.md file
+# GitHub: https://github.com/Baekalfen/PyBoy
+#
+
+from threading import Thread
+
+import pytest
+
+from pyboy import PyBoy
+from pyboy.utils import cython_compiled
+
+
+@pytest.mark.benchmark(group="nogil")
+def test_threads_baseline(benchmark, default_rom):
+    pyboy = PyBoy(default_rom, window="null")
+    pyboy.set_emulation_speed(0)
+    benchmark(pyboy.tick, 2000, False)
+
+
+@pytest.mark.skipif(not cython_compiled, reason="No-GIL is only relevant for Cython")
+@pytest.mark.benchmark(group="nogil")
+@pytest.mark.parametrize("count", [1, 2, 4])
+def test_threads_nogil(benchmark, count, default_rom):
+    # Threaded run with no GIL. Should result in roughly same time.
+    def thread_run():
+        pyboy = PyBoy(default_rom, window="null")
+        pyboy.set_emulation_speed(0)
+        pyboy.tick(2000, False)
+
+    def bench():
+        threads = [Thread(target=thread_run) for _ in range(count)]
+        for t in threads:
+            t.start()
+
+        for t in threads:
+            t.join()
+
+    benchmark(bench)
diff --git a/tests/test_blargg.py b/tests/test_blargg.py
index ada35fa7c..34556b88d 100644
--- a/tests/test_blargg.py
+++ b/tests/test_blargg.py
@@ -3,12 +3,8 @@
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
 
-import io
 import json
 import os.path
-import platform
-import sys
-import time
 from pathlib import Path
 
 import pytest
@@ -23,13 +19,11 @@
 def run_rom(rom, max_frames):
     pyboy = PyBoy(str(rom), window="null", cgb="cgb" in rom, sound_emulated=True)
     pyboy.set_emulation_speed(0)
-    t = time.time()
     result = ""
     while pyboy.tick(1, False):
         b = pyboy._serial()
         if b != "":
             result += b
-            t = time.time()
 
         if pyboy._is_cpu_stuck() or pyboy.frame_count > max_frames:
             break
diff --git a/tests/test_breakpoints.py b/tests/test_breakpoints.py
index 9206ccc1d..874d97774 100644
--- a/tests/test_breakpoints.py
+++ b/tests/test_breakpoints.py
@@ -260,4 +260,4 @@ def test_data_hooking_failure(default_rom):
         diff.show()
 
     # NOTE: Expecting a failure!
-    assert diff.getbbox(), f"Images are not different!"
+    assert diff.getbbox(), "Images are not different!"
diff --git a/tests/test_examples.py b/tests/test_examples.py
index 3de899d22..a112e71e1 100644
--- a/tests/test_examples.py
+++ b/tests/test_examples.py
@@ -3,7 +3,6 @@
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
 import os
-import platform
 import subprocess
 import sys
 from pathlib import Path
diff --git a/tests/test_external_api.py b/tests/test_external_api.py
index 3406b025c..f910a6219 100644
--- a/tests/test_external_api.py
+++ b/tests/test_external_api.py
@@ -14,7 +14,8 @@
 
 from pyboy import PyBoy
 from pyboy.api.tile import Tile
-from pyboy.utils import IntIOWrapper, WindowEvent
+from pyboy.api.constants import TILES_CGB, TILES
+from pyboy.utils import IntIOWrapper, PyBoyAssertException, PyBoyException, PyBoyOutOfBoundsException, WindowEvent
 
 from .conftest import BOOTROM_FRAMES_UNTIL_LOGO
 
@@ -31,7 +32,7 @@ def test_misc(default_rom):
 
 def test_rtc_lock_no_rtc(default_rom):
     pyboy = PyBoy(default_rom, window="null")
-    with pytest.raises(Exception):
+    with pytest.raises(PyBoyException):
         pyboy.rtc_lock_experimental(True)
 
 
@@ -117,19 +118,22 @@ def test_faulty_state(default_rom):
     a = IntIOWrapper(io.BytesIO(b"abcd"))
     a.seek(0)
     a.write(0xFF)
-    # Cython causes OverflowError, PyPy causes AssertionError
-    with pytest.raises((OverflowError, AssertionError)):
+    # Cython causes OverflowError, PyPy causes PyBoyOutOfBoundsException
+    with pytest.raises((OverflowError, PyBoyOutOfBoundsException)):
         a.write(0x100)
     a.seek(0)
     assert a.read() == 0xFF
     assert a.read() == ord("b")
     assert a.read() == ord("c")
     assert a.read() == ord("d")
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyAssertException):
         a.read()
 
-    b = io.BytesIO(b"1234")
-    with pytest.raises(AssertionError):
+    b = io.BytesIO(b"\x001234")
+    with pytest.raises(PyBoyAssertException):
+        pyboy.load_state(b)
+    b = io.BytesIO(b"991234")
+    with pytest.raises(PyBoyException):
         pyboy.load_state(b)
     pyboy.stop(save=False)
 
@@ -142,8 +146,10 @@ def test_tiles(default_rom):
     tile = pyboy.tilemap_window.tile(0, 0)
     assert isinstance(tile, Tile)
 
-    with pytest.raises(AssertionError):
-        pyboy.get_tile(384)  # Not CGB
+    pyboy.get_tile(TILES - 1)  # DMG
+    with pytest.raises(PyBoyOutOfBoundsException):
+        pyboy.get_tile(TILES)  # Not CGB
+
     tile = pyboy.get_tile(1)
     image = tile.image()
     assert isinstance(image, PIL.Image.Image)
@@ -165,13 +171,13 @@ def test_tiles(default_rom):
         [0xFFFFFF, 0x000000, 0x000000, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0xFFFFFF],
     ]
 
-    for identifier in range(384):
+    for identifier in range(TILES):
         t = pyboy.get_tile(identifier)
         assert t.tile_identifier == identifier
-    with pytest.raises(Exception):
+    with pytest.raises(PyBoyException):
         pyboy.get_tile(-1)
-    with pytest.raises(Exception):
-        pyboy.get_tile(385)
+    with pytest.raises(PyBoyException):
+        pyboy.get_tile(TILES_CGB)
 
     pyboy.stop(save=False)
 
@@ -194,7 +200,7 @@ def test_tiles_cgb(any_rom_cgb):
     # data = tile.image_data()
     # assert data.shape == (8, 8)
 
-    assert [[x for x in y] for y in ndarray] == [
+    assert [[x & 0xFFFFFF for x in y] for y in ndarray.view(dtype=np.uint32).reshape(8, 8)] == [
         [0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF],
         [0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF],
         [0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF],
@@ -205,28 +211,20 @@ def test_tiles_cgb(any_rom_cgb):
         [0xFFFFFF, 0x000000, 0x000000, 0xFFFFFF, 0xFFFFFF, 0x000000, 0x000000, 0xFFFFFF],
     ]
 
-    for identifier in range(384):
+    for identifier in range(TILES_CGB):
         t = pyboy.get_tile(identifier)
         assert t.tile_identifier == identifier
-    with pytest.raises(Exception):
+    with pytest.raises(PyBoyException):
         pyboy.get_tile(-1)
-    with pytest.raises(Exception):
-        pyboy.get_tile(385)
+    with pytest.raises(PyBoyException):
+        pyboy.get_tile(TILES_CGB)
 
     pyboy.stop(save=False)
 
 
-def test_tiles_cgb(any_rom_cgb):
-    pyboy = PyBoy(any_rom_cgb, window="null")
-    pyboy.set_emulation_speed(0)
-    pyboy.tick(BOOTROM_FRAMES_UNTIL_LOGO, False)
-
-    pyboy.get_tile(384)  # Allowed on CGB
-
-
 def test_screen_buffer_and_image(tetris_rom, boot_rom):
     cformat = "RGBA"
-    boot_logo_hash_predigested = b"_M\x0e\xd9\xe2\xdb\\o]\x83U\x93\xebZm\x1e\xaaFR/Q\xa52\x1c{8\xe7g\x95\xbcIz"
+    # boot_logo_hash_predigested = b"_M\x0e\xd9\xe2\xdb\\o]\x83U\x93\xebZm\x1e\xaaFR/Q\xa52\x1c{8\xe7g\x95\xbcIz"
 
     pyboy = PyBoy(tetris_rom, window="null", bootrom=boot_rom)
     pyboy.set_emulation_speed(0)
@@ -309,7 +307,7 @@ def test_tetris(tetris_rom):
     tile_map = pyboy.tilemap_background
     state_data = io.BytesIO()
     for frame in range(5282):  # Enough frames to get a "Game Over". Otherwise do: `while pyboy.tick(False):`
-        image = pyboy.tick(1, True)
+        pyboy.tick(1, True)
 
         assert pyboy.screen.get_tilemap_position() == ((0, 0), (-7, 0))
 
@@ -534,8 +532,13 @@ def test_tetris(tetris_rom):
 
 def test_tilemap_position_list(supermarioland_rom):
     pyboy = PyBoy(supermarioland_rom, window="null")
-    pyboy.set_emulation_speed(0)
-    pyboy.tick(100, False)
+    pyboy.tick(1, False)
+    assert len(pyboy.screen.tilemap_position_list) == 144, "Expected 144 scanlines"
+    assert len(pyboy.screen.tilemap_position_list[0]) == 4, "Expected (SCX, SCY, WX, WY)"
+    assert (
+        sum((sum(x) for x in pyboy.screen.tilemap_position_list)) == 0
+    ), "Expected LCD to be disabled, and positions be 0"
+    pyboy.tick(99, False)
 
     # Start the game
     pyboy.button("start")
diff --git a/tests/test_game_wrapper.py b/tests/test_game_wrapper.py
index 231d2aac9..1c04580d6 100644
--- a/tests/test_game_wrapper.py
+++ b/tests/test_game_wrapper.py
@@ -3,19 +3,10 @@
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
 
-import os
-import platform
-import sys
-
 import numpy as np
-import pytest
 
 from pyboy import PyBoy
 from pyboy.api.constants import LCDC_OFFSET, OAM_OFFSET, VRAM_OFFSET
-from pyboy.utils import WindowEvent
-
-py_version = platform.python_version()[:3]
-is_pypy = platform.python_implementation() == "PyPy"
 
 
 def test_game_wrapper_basics(default_rom):
@@ -25,14 +16,14 @@ def test_game_wrapper_basics(default_rom):
     generic_wrapper = pyboy.game_wrapper
     assert generic_wrapper is not None
     pyboy.game_area()
-    pyboy.stop()
 
 
 def test_game_wrapper_sprites_tall(default_rom):
     pyboy = PyBoy(default_rom, window="null")
+    pyboy.set_emulation_speed(0)
     generic_wrapper = pyboy.game_wrapper
     assert generic_wrapper is not None
-    pyboy.tick(120)
+    pyboy.tick(120, False)
 
     pyboy.memory[LCDC_OFFSET] = (
         0b10000000  # LCD On
@@ -119,5 +110,3 @@ def test_game_wrapper_mapping(default_rom):
             dtype=np.uint32,
         )
     )
-
-    pyboy.stop()
diff --git a/tests/test_game_wrapper_mario.py b/tests/test_game_wrapper_mario.py
index 55f9282a1..fbbc32bea 100644
--- a/tests/test_game_wrapper_mario.py
+++ b/tests/test_game_wrapper_mario.py
@@ -3,18 +3,7 @@
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
 
-import os
-import platform
-import sys
-
-import numpy as np
-import pytest
-
 from pyboy import PyBoy
-from pyboy.utils import WindowEvent
-
-py_version = platform.python_version()[:3]
-is_pypy = platform.python_implementation() == "PyPy"
 
 
 def test_mario_basics(supermarioland_rom):
@@ -29,7 +18,6 @@ def test_mario_basics(supermarioland_rom):
     assert mario.lives_left == 2
     assert mario.time_left == 400
     assert mario.world == (1, 1)
-    pyboy.stop()
 
 
 def test_mario_advanced(supermarioland_rom):
@@ -47,7 +35,6 @@ def test_mario_advanced(supermarioland_rom):
     assert mario.lives_left == lives
     assert mario.time_left == 400
     assert mario.world == (3, 2)
-    pyboy.stop()
 
 
 def test_mario_game_over(supermarioland_rom):
@@ -62,4 +49,3 @@ def test_mario_game_over(supermarioland_rom):
         pyboy.tick(1, False)
         if mario.game_over():
             break
-    pyboy.stop()
diff --git a/tests/test_game_wrapper_pokemon_pinball.py b/tests/test_game_wrapper_pokemon_pinball.py
index e05d49c9a..c9efbd547 100644
--- a/tests/test_game_wrapper_pokemon_pinball.py
+++ b/tests/test_game_wrapper_pokemon_pinball.py
@@ -3,16 +3,9 @@
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
 
-import os
-import platform
-import sys
-
-import numpy as np
-import pytest
 
 from pyboy import PyBoy
 from pyboy.plugins.game_wrapper_pokemon_pinball import Pokemon, SpecialMode, Stage
-from pyboy.utils import WindowEvent
 
 
 def test_pokemon_pinball_basics(pokemon_pinball_rom):
diff --git a/tests/test_gameshark.py b/tests/test_gameshark.py
index 8ed196dc9..5fb4229f7 100644
--- a/tests/test_gameshark.py
+++ b/tests/test_gameshark.py
@@ -12,7 +12,6 @@ def test_gameshark(default_rom):
 
     code = "010138CD"
     value = 0x01
-    bank = 0x00
     address = 0xCD38
 
     # Establish truth
@@ -44,7 +43,6 @@ def test_gameshark_clear(default_rom):
     code1 = "010138CD"
     code2 = "010138CE"
     value = 0x01
-    bank = 0x00
     address1 = 0xCD38
     address2 = 0xCE38
 
diff --git a/tests/test_memoryscanner.py b/tests/test_memoryscanner.py
index 45ce84f8d..d7bf8bb73 100644
--- a/tests/test_memoryscanner.py
+++ b/tests/test_memoryscanner.py
@@ -115,12 +115,10 @@ def test_memoryscanner_relative(kirby_rom):
     pyboy.button_press("right")
 
     pyboy.tick(175, True)
-    addresses1 = pyboy.memory_scanner.rescan_memory(None, DynamicComparisonType.INCREASED)
-    values1 = [pyboy.memory[x] for x in addresses1]
+    pyboy.memory_scanner.rescan_memory(None, DynamicComparisonType.INCREASED)
 
     pyboy.tick(175, True)
     addresses2 = pyboy.memory_scanner.rescan_memory(None, DynamicComparisonType.INCREASED)
-    values2 = [pyboy.memory[x] for x in addresses2]
 
     # Actual score address for third digit
     assert SCORE_100 in addresses2
diff --git a/tests/test_memoryview.py b/tests/test_memoryview.py
index ff6bb3364..f9d545102 100644
--- a/tests/test_memoryview.py
+++ b/tests/test_memoryview.py
@@ -6,6 +6,7 @@
 import pytest
 
 from pyboy import PyBoy
+from pyboy.utils import PyBoyInvalidInputException, PyBoyOutOfBoundsException
 
 
 def test_memoryview(default_rom, boot_rom):
@@ -27,23 +28,23 @@ def test_memoryview(default_rom, boot_rom):
     assert p.memory[0xFFFF] == 1
 
     # Requires start and end address
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyInvalidInputException):
         p.memory[:10] == []
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyInvalidInputException):
         p.memory[20:10] == []
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyInvalidInputException):
         p.memory[:10:] == []
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyInvalidInputException):
         p.memory[0xFF00:] == []
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyInvalidInputException):
         p.memory[0xFF00::] == []
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyInvalidInputException):
         p.memory[:10] = 0
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyInvalidInputException):
         p.memory[:10:] = 0
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyInvalidInputException):
         p.memory[0xFF00:] = 0
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyInvalidInputException):
         p.memory[0xFF00::] = 0
 
     # Attempt write to ROM area
@@ -66,17 +67,17 @@ def test_memoryview(default_rom, boot_rom):
     assert p.memory[0xC000:0xC00A] == [1] * 10
 
     # Attempt to write too large memory slice into memory area
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyInvalidInputException):
         p.memory[0xC000:0xC001] = [1] * 10
 
     # Attempt to write too small memory slice into memory area
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyInvalidInputException):
         p.memory[0xC000:0xC00A] = [1] * 2
 
     # Read specific ROM bank
     assert p.memory[0, 0x00:0x10] == rom_bytes[:16]
     assert p.memory[1, 0x00] == 0
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyInvalidInputException):
         # Slicing currently unsupported
         assert p.memory[0:2, 0x00:0x10] == []
 
@@ -90,7 +91,7 @@ def test_memoryview(default_rom, boot_rom):
     assert p.memory[1, 0xA000] == 2
     assert p.memory[1, 0xA001] == 2
 
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyOutOfBoundsException):
         # Out of bounds
         p.memory[0, 0x00:0x9000]
 
@@ -126,14 +127,14 @@ def test_cgb_banks(cgb_acid_file):  # Any CGB file
     assert p.memory[0, 0xD000:0xD010] == [1] * 16
     assert p.memory[7, 0xD000:0xD010] == [2] * 16
 
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyInvalidInputException):
         # Slicing currently unsupported
         p.memory[0:2, 0xD000:0xD010] = 1
 
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyOutOfBoundsException):
         p.memory[8, 0xD000]  # Only bank 0-7
 
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyOutOfBoundsException):
         p.memory[8, 0xD000] = 1  # Only bank 0-7
 
 
@@ -171,7 +172,7 @@ def test_boundaries(default_rom):
     assert pyboy.memory[-1, 0x00] != 0
     assert pyboy.memory[-1, 0xFF] != 0
     pyboy.memory[-1, 0:0x100] = [0] * 0x100  # Clear boot ROM
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyOutOfBoundsException):
         pyboy.memory[-1, 0:0x101] = [0] * 0x101  # Out of bounds
     assert pyboy.memory[-1, 0x00] == 0
     assert pyboy.memory[-1, 0xFF] == 0
@@ -184,7 +185,7 @@ def test_boundaries(default_rom):
 
     # ROM Bank 0 boundary - Expecting 0 to 0x3FFF both including to change
     pyboy.memory[0, 0:0x4000] = [0] * 0x4000
-    with pytest.raises(AssertionError):
+    with pytest.raises(PyBoyOutOfBoundsException):
         pyboy.memory[0, 0:0x4001] = [0] * 0x4001  # Over boundary!
 
     # NOTE: Not specifying bank! Defaulting to 0 up to 0x3FFF and then 1 at 0x4000
diff --git a/tests/test_mooneye.py b/tests/test_mooneye.py
index 5f9e3a8a5..e5ba54e8c 100644
--- a/tests/test_mooneye.py
+++ b/tests/test_mooneye.py
@@ -7,7 +7,6 @@
 import os.path
 import platform
 from pathlib import Path
-from zipfile import ZipFile
 
 import PIL
 import pytest
diff --git a/tests/test_pokemon_rl.py b/tests/test_pokemon_rl.py
index 081d6eebc..69470735a 100644
--- a/tests/test_pokemon_rl.py
+++ b/tests/test_pokemon_rl.py
@@ -124,7 +124,6 @@ def test_pokemon_rl(git_pokemon_red_experiments, pokemon_red_rom):
     with open(Path(git_pokemon_red_experiments) / "baselines" / script_py, "w") as f:
         f.write(record_gif_py)
 
-    root_path = Path("../")
     assert os.system(f'rm -rf {Path(git_pokemon_red_experiments) / "recordings"}') == 0
     assert (
         os.system(
diff --git a/tests/test_pyboy_lcd.py b/tests/test_pyboy_lcd.py
index e9c5d8736..d13c99aba 100644
--- a/tests/test_pyboy_lcd.py
+++ b/tests/test_pyboy_lcd.py
@@ -3,15 +3,11 @@
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
 
-import os
-import platform
 
 import pytest
 
 from pyboy.core.lcd import LCD, Renderer
-from pyboy.utils import color_code
-
-is_pypy = platform.python_implementation() == "PyPy"
+from pyboy.utils import color_code, cython_compiled
 
 INTR_VBLANK, INTR_LCDC, INTR_TIMER, INTR_SERIAL, INTR_HIGHTOLOW = [1 << x for x in range(5)]
 
@@ -83,7 +79,7 @@ def test_check_lyc(self):
         assert lcd.get_stat() & 0b100  # LYC flag set
 
 
-@pytest.mark.skipif(not is_pypy, reason="This test requires access to internal registers not available in Cython")
+@pytest.mark.skipif(cython_compiled, reason="This test requires access to internal registers not available in Cython")
 class TestRenderer:
     def test_colorcode_example(self):
         renderer = Renderer(False)
diff --git a/tests/test_replay.py b/tests/test_replay.py
index 37206ee68..04d0a0e67 100644
--- a/tests/test_replay.py
+++ b/tests/test_replay.py
@@ -11,10 +11,8 @@
 import sys
 import time
 import zlib
-from unittest import mock
 
 import numpy as np
-import pytest
 
 from pyboy import PyBoy
 from pyboy.utils import WindowEvent
@@ -60,7 +58,7 @@ def move_gif(game, dest):
             gif = sorted(filter(lambda x: game in x, os.listdir(record_dir)))[-1]
             os.replace(record_dir + "/" + gif, dest)
             break
-        except:
+        except:  # noqa
             time.sleep(1)
     else:
         raise FileNotFoundError(f"Couldn't find gif to move for game {game}")
diff --git a/tests/test_results/TurtleTest/window_y_trigger.gb.png b/tests/test_results/TurtleTest/window_y_trigger.gb.png
new file mode 100644
index 000000000..e9d3d3692
Binary files /dev/null and b/tests/test_results/TurtleTest/window_y_trigger.gb.png differ
diff --git a/tests/test_results/TurtleTest/window_y_trigger_wx_offscreen.gb.png b/tests/test_results/TurtleTest/window_y_trigger_wx_offscreen.gb.png
new file mode 100644
index 000000000..1a1fb719d
Binary files /dev/null and b/tests/test_results/TurtleTest/window_y_trigger_wx_offscreen.gb.png differ
diff --git a/tests/test_results/blargg.json b/tests/test_results/blargg.json
index 3a2ef5e18..d750b23f1 100644
--- a/tests/test_results/blargg.json
+++ b/tests/test_results/blargg.json
@@ -20,10 +20,10 @@
     "blargg/dmg_sound/rom_singles/06-overflow on trigger.gb": "06-overflow on trigger\n\n7FFF 7FFF 7FFF 7FFF 7FFF 7FFF 7FFF \n8D7112A4 \nFailed\n",
     "blargg/dmg_sound/rom_singles/07-len sweep period sync.gb": "07-len sweep period sync\n\n\nLength period is wrong\n\nFailed #2\n",
     "blargg/dmg_sound/rom_singles/08-len ctr during power.gb": "08-len ctr during power\n\n00 00 00 00 2144DF1C \nFailed\n",
-    "blargg/dmg_sound/rom_singles/09-wave read while on.gb": "09-wave read while on\n\n88 33 11 00 FF FF FF 00 11 44 66 99 CC DD 55 AA AA FF 55 22 99 AA AA 33 CC 66 77 CC CC 33 FF CC 99 99 55 55 33 33 33 44 55 77 CC FF 22 66 CC 33 EE 44 11 88 FF 77 FF 88 11 BB 55 00 BB 33 CC 99 88 44 22 00 FF D075E68F \nFailed\n",
+    "blargg/dmg_sound/rom_singles/09-wave read while on.gb": "09-wave read while on\n\n55 33 11 00 00 FF FF 00 11 11 33 88 BB CC 44 44 EE EE 44 BB 99 11 99 22 22 55 FF 00 BB 22 22 EE BB 66 44 55 44 44 55 77 99 DD 22 88 BB FF 55 AA 11 77 DD 44 DD 77 FF AA DD 99 EE 99 44 22 00 DD AA 88 66 77 88 E7778138 \nFailed\n",
     "blargg/dmg_sound/rom_singles/10-wave trigger while on.gb": "10-wave trigger while on\n\n00 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF \n00 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF \n00 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF \n00 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF \n00 11 22 33 44 55 66 77 88 99",
     "blargg/dmg_sound/rom_singles/11-regs after power.gb": "11-regs after power\n\n\nPowering off should clear NR13\n\nFailed #3\n",
-    "blargg/dmg_sound/rom_singles/12-wave write while on.gb": "12-wave write while on\n\n00 11 22 33 44 F7 66 77 88 99 AA BB CC DD EE FF \n00 11 22 33 44 F7 66 77 88 99 AA BB CC DD EE FF \n00 11 22 33 F7 55 66 77 88 99 AA BB CC DD EE FF \n00 F7 22 33 44 55 66 77 88 99 AA BB CC DD EE FF \nF7 11 22 33 44 55 66 77 88 99 A",
+    "blargg/dmg_sound/rom_singles/12-wave write while on.gb": "12-wave write while on\n\n00 11 22 33 44 F7 66 77 88 99 AA BB CC DD EE FF \n00 11 22 F7 44 55 66 77 88 99 AA BB CC DD EE FF \n00 F7 22 33 44 55 66 77 88 99 AA BB CC DD EE FF \nF7 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF \n00 11 22 33 44 55 66 77 88 99 A",
     "blargg/instr_timing/instr_timing.gb": "instr_timing\n\n\nPassed\n",
     "blargg/interrupt_time/interrupt_time.gb": "interrupt time\n\n00 00 00 \n00 08 08 \n00 00 00 \n00 08 08 \n5DDD9187 \nFailed\n",
     "blargg/mem_timing/individual/01-read_timing.gb": "01-read_timing\n\n\nPassed\n",
@@ -52,7 +52,7 @@
     "blargg/cgb_sound/rom_singles/06-overflow on trigger.gb": "06-overflow on trigger\n\n7FFF 7FFF 7FFF 7FFF 7FFF 7FFF 7FFF \n8D7112A4 \nFailed\n",
     "blargg/cgb_sound/rom_singles/07-len sweep period sync.gb": "07-len sweep period sync\n\n\nLength period is wrong\n\nFailed #2\n",
     "blargg/cgb_sound/rom_singles/08-len ctr during power.gb": "08-len ctr during power\n\n00 00 00 00 2144DF1C \nFailed\n",
-    "blargg/cgb_sound/rom_singles/09-wave read while on.gb": "09-wave read while on\n\n55 33 11 11 00 FF FF FF 00 33 55 88 99 DD 11 AA AA 55 BB 22 99 11 11 99 22 BB FF AA 55 11 11 AA 77 77 66 33 22 22 22 33 44 66 88 BB EE 22 66 BB 00 88 55 CC 33 BB 33 CC 77 11 BB 11 CC 88 44 11 EE CC AA 99 AA B7836723 \nFailed\n",
+    "blargg/cgb_sound/rom_singles/09-wave read while on.gb": "09-wave read while on\n\n55 33 11 11 00 FF FF 00 22 33 77 88 BB 22 66 66 CC 11 77 EE 55 44 CC CC EE 88 22 22 EE 55 11 11 BB 99 99 66 77 77 88 99 CC 00 22 88 BB FF 33 88 DD 33 99 00 FF FF 77 99 22 CC 66 11 EE CC 88 22 FF DD BB AA 99 8EC3FF3B \nFailed\n",
     "blargg/cgb_sound/rom_singles/10-wave trigger while on.gb": "10-wave trigger while on\n\n00 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF \n00 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF \n00 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF \n00 11 22 33 44 55 66 77 88 99 AA BB CC DD EE FF \n00 11 22 33 44 55 66 77 88 99",
     "blargg/cgb_sound/rom_singles/11-regs after power.gb": "11-regs after power\n\n\nPowering off should clear NR13\n\nFailed #3\n",
     "blargg/cgb_sound/rom_singles/12-wave.gb": "12-wave\n\n\nTimer period or phase resetting is wrong\n\nFailed #2\n"
diff --git a/tests/test_rewind.py b/tests/test_rewind.py
index 60bdb20bd..13b57b318 100644
--- a/tests/test_rewind.py
+++ b/tests/test_rewind.py
@@ -1,10 +1,9 @@
-import platform
-
 import pytest
 
-is_pypy = platform.python_implementation() == "PyPy"
+from pyboy.utils import cython_compiled
 
-if is_pypy:
+# isort: skip_file
+if not cython_compiled:
     from pyboy.plugins.rewind import (
         FILL_VALUE,
         FIXED_BUFFER_SIZE,
@@ -19,7 +18,7 @@ def write_bytes(buf, values):
         buf.write(v % 0x100)
 
 
-@pytest.mark.skipif(not is_pypy, reason="This test doesn't work in Cython")
+@pytest.mark.skipif(cython_compiled, reason="This test doesn't work in Cython")
 class TestRewind:
     def test_all(self):
         for buf in [FixedAllocBuffers(), CompressedFixedAllocBuffers(), DeltaFixedAllocBuffers()]:
diff --git a/tests/test_shonumi.py b/tests/test_shonumi.py
index 8de127c77..c48e5a626 100644
--- a/tests/test_shonumi.py
+++ b/tests/test_shonumi.py
@@ -3,9 +3,7 @@
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
 
-import io
 import os.path
-import platform
 from pathlib import Path
 
 import PIL
diff --git a/tests/test_states.py b/tests/test_states.py
index 6be148adc..5ce0f5883 100644
--- a/tests/test_states.py
+++ b/tests/test_states.py
@@ -2,32 +2,24 @@
 # License: See LICENSE.md file
 # GitHub: https://github.com/Baekalfen/PyBoy
 #
+import copy
 import io
-import platform
 
-from pyboy import PyBoy
+import pytest
 
-NEXT_TETROMINO_ADDR = 0xC213
+from pyboy import PyBoy
+from pyboy.utils import IntIOWrapper, cython_compiled
 
 
-def test_load_save_consistency(tetris_rom):
-    pyboy = PyBoy(tetris_rom, window="null")
-    assert pyboy.cartridge_title == "TETRIS"
-    pyboy.set_emulation_speed(0)
-    pyboy.memory[NEXT_TETROMINO_ADDR]
-
-    ##############################################################
-    # Set up some kind of state, where not all registers are reset
-    ##############################################################
+def copy_attrs(obj, allowed_types=("int", "str", "float", "array", "dict", "list", "bool")):
+    attrs = [k for k in dir(obj) if type(getattr(obj, k)).__name__ in allowed_types]
+    return {k: copy.copy(getattr(obj, k)) for k in attrs}
 
-    tetris = pyboy.game_wrapper
-
-    timer_div = 0x00
-    saved_state = io.BytesIO()
 
+def boot(pyboy):
     # Boot screen
     while True:
-        pyboy.tick(1, True)
+        pyboy.tick(1, False)
         tilemap_background = pyboy.tilemap_background
         if tilemap_background[2:9, 14] == [89, 25, 21, 10, 34, 14, 27]:  # '1PLAYER' on the first screen
             break
@@ -35,28 +27,318 @@ def test_load_save_consistency(tetris_rom):
     # Start game. Just press Start when the game allows us.
     for i in range(2):
         pyboy.button("start")
-        pyboy.tick(7, True)
+        pyboy.tick(7, False)
+
+
+def progress(pyboy):
+    for _ in range(3):
+        # Do something
+        pyboy.tick(10, False)
+        pyboy.button("a")
+    pyboy.tick(1, False)  # Flush input
+
+
+ignored_attrs = [
+    "_spritecache0_raw",
+    "_spritecache0_state",
+    "_tilecache0_raw",
+    "_tilecache0_state",
+    "sprites_to_render",
+    "serialbuffer",
+    "serialbuffer_count",
+    "disable_renderer",  # Not set before calling .tick()
+    "__dict__",
+]
+
+
+def compare_attributes(a, b):
+    # Compare all attributes before and after save/load-state
+    success = True
+    for (module_name, attrs), (module_name2, attrs2) in zip(a.items(), b.items()):
+        attrs.pop("bail", None)  # Doesn't show before .tick() is called.
+        attrs2.pop("bail", None)
+        assert module_name == module_name2
+        assert set(attrs.keys()) ^ set(attrs2.keys()) == set(), "Expected same attributes in both sets"
+        for (k, v), (k2, v2) in zip(attrs.items(), attrs2.items()):
+            assert k == k2
+            # assert v == v2, k
+
+            if k in ignored_attrs:
+                continue
+
+            if v != v2:
+                print(module_name, k)
+                if isinstance(v, int):
+                    print(hex(v), hex(v2))
+                success = False
+    return success
+
+
+def compare_IntIOWrapper(metadata, _s1, _s2):
+    success = True
+    for m, s1, s2 in zip(metadata, _s1, _s2):
+        # i = 0
+        a = s1.buffer.getvalue()
+        b = s2.buffer.getvalue()
+        if a != b:
+            print("failed", m)
+            success = False
+    return success
+
+
+def get_modules(pyboy):
+    modules = [
+        pyboy.mb,
+        pyboy.mb.cartridge,
+        pyboy.mb.timer,
+        pyboy.mb.interaction,
+        pyboy.mb.bootrom,
+        pyboy.mb.ram,
+        pyboy.mb.cpu,
+        pyboy.mb.lcd,
+        pyboy.mb.lcd._LCDC,
+        pyboy.mb.lcd._STAT,
+        pyboy.mb.lcd.BGP,
+        pyboy.mb.lcd.OBP0,
+        pyboy.mb.lcd.OBP1,
+        pyboy.mb.lcd.renderer,
+        # pyboy.mb.sound, # TODO: Reenable when sound is implemented
+        # pyboy.mb.sound.noisechannel,
+        # pyboy.mb.sound.sweepchannel,
+        # pyboy.mb.sound.tonechannel,
+        # pyboy.mb.sound.wavechannel,
+    ]
+    if pyboy.mb.hdma is not None:
+        modules.append(pyboy.mb.hdma)
+    return modules
+
+
+@pytest.mark.skipif(cython_compiled, reason="This test requires access to internal registers not available in Cython")
+def test_state_null(tetris_rom):
+    pyboy = PyBoy(tetris_rom, window="null")
+    assert pyboy.cartridge_title == "TETRIS"
+    boot(pyboy)
+
+    ##############################################################
+    base_line = io.BytesIO()
+    pyboy.save_state(base_line)
 
+    module_attrs = {x.__class__.__name__: copy_attrs(x) for x in get_modules(pyboy)}
     ##############################################################
-    # Verify
+    base_line.seek(0)
+    pyboy.load_state(base_line)
+
+    module_attrs2 = {x.__class__.__name__: copy_attrs(x) for x in get_modules(pyboy)}
+    ##############################################################
+
+    assert compare_attributes(module_attrs, module_attrs2)  # class attributes
+
+
+@pytest.mark.skipif(cython_compiled, reason="This test requires access to internal registers not available in Cython")
+def test_state_attrs(tetris_rom):
+    pyboy = PyBoy(tetris_rom, window="null")
+    assert pyboy.cartridge_title == "TETRIS"
+    boot(pyboy)
+
+    ##############################################################
+    base_line = io.BytesIO()
+    pyboy.save_state(base_line)
+    module_attrs = {x.__class__.__name__: copy_attrs(x) for x in get_modules(pyboy)}
+    ##############################################################
+    progress(pyboy)  # Scrambles state
+    ##############################################################
+    base_line.seek(0)
+    pyboy.load_state(base_line)
+    module_attrs2 = {x.__class__.__name__: copy_attrs(x) for x in get_modules(pyboy)}
+    ##############################################################
+
+    assert compare_attributes(module_attrs, module_attrs2)  # class attributes
+
+
+@pytest.mark.skipif(cython_compiled, reason="This test requires access to internal registers not available in Cython")
+def test_state_attrs_migrate_instance(tetris_rom):
+    pyboy = PyBoy(tetris_rom, window="null")
+    assert pyboy.cartridge_title == "TETRIS"
+    boot(pyboy)
+
+    ##############################################################
+    progress(pyboy)
+    base_line = io.BytesIO()
+    pyboy.save_state(base_line)
+    # pyboy.tick()
+    module_attrs = {x.__class__.__name__: copy_attrs(x) for x in get_modules(pyboy)}
+    ##############################################################
+    pyboy2 = PyBoy(tetris_rom, window="null")
+    base_line.seek(0)
+    pyboy2.load_state(base_line)
+    # pyboy2.tick()
+    module_attrs2 = {x.__class__.__name__: copy_attrs(x) for x in get_modules(pyboy2)}
     ##############################################################
+    assert compare_attributes(module_attrs, module_attrs2)  # class attributes
 
-    # Save
-    saved_state.seek(0)
-    pyboy.save_state(saved_state)
-    tetris._set_timer_div(timer_div)
 
-    # Load
-    saved_state.seek(0)
-    pyboy.load_state(saved_state)
+@pytest.mark.skipif(cython_compiled, reason="This test requires access to internal registers not available in Cython")
+def test_state_deterministic(tetris_rom):
+    pyboy = PyBoy(tetris_rom, window="null")
+    assert pyboy.cartridge_title == "TETRIS"
+    boot(pyboy)
+
+    ##############################################################
+    base_line = io.BytesIO()
+    pyboy.save_state(base_line)
+
+    progress(pyboy)
+    module_attrs = {x.__class__.__name__: copy_attrs(x) for x in get_modules(pyboy)}
+    ##############################################################
+    base_line.seek(0)
+    pyboy.load_state(base_line)
 
-    # Save again
+    progress(pyboy)
+    module_attrs2 = {x.__class__.__name__: copy_attrs(x) for x in get_modules(pyboy)}
+    ##############################################################
+
+    assert compare_attributes(module_attrs, module_attrs2)  # class attributes
+
+
+@pytest.mark.skipif(cython_compiled, reason="This test requires access to internal registers not available in Cython")
+def test_state_deterministic_migrated(tetris_rom):
+    pyboy = PyBoy(tetris_rom, window="null")
+    assert pyboy.cartridge_title == "TETRIS"
+    boot(pyboy)
+
+    ##############################################################
+    base_line = io.BytesIO()
+    pyboy.save_state(base_line)
+
+    progress(pyboy)
+    module_attrs = {x.__class__.__name__: copy_attrs(x) for x in get_modules(pyboy)}
+    ##############################################################
+    pyboy2 = PyBoy(tetris_rom, window="null")
+    base_line.seek(0)
+    pyboy2.load_state(base_line)
+
+    progress(pyboy2)
+    module_attrs2 = {x.__class__.__name__: copy_attrs(x) for x in get_modules(pyboy2)}
+    ##############################################################
+
+    assert compare_attributes(module_attrs, module_attrs2)  # class attributes
+
+
+@pytest.mark.skipif(cython_compiled, reason="This test requires access to internal registers not available in Cython")
+def test_state_deterministic2(tetris_rom):
+    pyboy = PyBoy(tetris_rom, window="null")
+    assert pyboy.cartridge_title == "TETRIS"
+    boot(pyboy)
+
+    ##############################################################
+    base_line = io.BytesIO()
+    pyboy.save_state(base_line)
+
+    progress(pyboy)
+    module_attrs = {x.__class__.__name__: copy_attrs(x) for x in get_modules(pyboy)}
+    ##############################################################
+    base_line.seek(0)
+    pyboy.load_state(base_line)
+
+    progress(pyboy)
+    module_attrs2 = {x.__class__.__name__: copy_attrs(x) for x in get_modules(pyboy)}
+    ##############################################################
+
+    assert compare_attributes(module_attrs, module_attrs2)  # class attributes
+
+
+def test_state_deterministic_cython(tetris_rom):
+    pyboy = PyBoy(tetris_rom, window="null")
+    assert pyboy.cartridge_title == "TETRIS"
+    boot(pyboy)
+    state1 = io.BytesIO()
+    state2 = io.BytesIO()
+
+    ##############################################################
+    base_line = io.BytesIO()
+    pyboy.save_state(base_line)
+
+    progress(pyboy)
+    pyboy.save_state(state1)
+    ##############################################################
+    base_line.seek(0)
+    pyboy.load_state(base_line)
+
+    progress(pyboy)
+    pyboy.save_state(state2)
+    ##############################################################
+
+    assert state1.getvalue() == state2.getvalue()
+
+
+@pytest.mark.skipif(cython_compiled, reason="This test requires access to internal registers not available in Cython")
+def test_submodule_states(tetris_rom):
+    pyboy = PyBoy(tetris_rom, window="null")
+    assert pyboy.cartridge_title == "TETRIS"
+    boot(pyboy)
+
+    modules = [
+        # pyboy.mb,
+        pyboy.mb.cartridge,
+        pyboy.mb.timer,
+        pyboy.mb.interaction,
+        # pyboy.mb.bootrom,
+        pyboy.mb.ram,
+        pyboy.mb.cpu,
+        pyboy.mb.lcd,
+        # pyboy.mb.lcd._LCDC,
+        # pyboy.mb.lcd._STAT,
+        # pyboy.mb.lcd.BGP,
+        # pyboy.mb.lcd.OBP0,
+        # pyboy.mb.lcd.OBP1,
+        pyboy.mb.lcd.renderer,
+        pyboy.mb.sound,
+        # pyboy.mb.sound.noisechannel,
+        # pyboy.mb.sound.sweepchannel,
+        # pyboy.mb.sound.tonechannel,
+        # pyboy.mb.sound.wavechannel,
+    ]
+    if pyboy.mb.hdma is not None:
+        modules.append(pyboy.mb.hdma)
+
+    ##############################################################
+    ## Save base line
+    base_line = io.BytesIO()
+    pyboy.save_state(base_line)
+
+    # Check determinism as unaccounted attributes or cycles may be offset
+    progress(pyboy)
+
+    # State of clean progress from beginning to now
+    saved_state1 = io.BytesIO()
+    pyboy.save_state(saved_state1)
+
+    states1 = [IntIOWrapper(io.BytesIO()) for _ in modules]
+    for m, x in zip(modules, states1):
+        m.save_state(x)
+        x.seek(0)
+    module_attrs = {x.__class__.__name__: copy_attrs(x) for x in modules}
+
+    ##############################################################
+    ## Load base line to repeat process
+    base_line.seek(0)
+    pyboy.load_state(base_line)
+
+    # Rerun to check determinism
+    progress(pyboy)
+
+    # State of rerun progress from previous state
     saved_state2 = io.BytesIO()
     pyboy.save_state(saved_state2)
 
-    # Compare saves
-    saved_state2.seek(0)
-    saved_state.seek(0)
-    first = saved_state.read()
-    second = saved_state2.read()
-    assert first == second
+    states2 = [IntIOWrapper(io.BytesIO()) for _ in modules]
+    for m, x in zip(modules, states2):
+        m.save_state(x)
+        x.seek(0)
+    module_attrs2 = {x.__class__.__name__: copy_attrs(x) for x in modules}
+
+    ##############################################################
+    ## Compare saves
+    assert compare_attributes(module_attrs, module_attrs2)  # class attributes
+    assert compare_IntIOWrapper(modules, states1, states2)  # class states
+    assert saved_state1.getvalue() == saved_state2.getvalue()  # full state
diff --git a/tests/test_tetris_ai.py b/tests/test_tetris_ai.py
index 521315912..ba2e5b3b8 100644
--- a/tests/test_tetris_ai.py
+++ b/tests/test_tetris_ai.py
@@ -190,7 +190,6 @@ def test_tetris_ai(git_tetris_ai, tetris_rom):
     with open(Path(git_tetris_ai) / script_py, "w") as f:
         f.write(record_gif_py)
 
-    root_path = Path("../")
     assert os.system(f'rm -rf {Path(git_tetris_ai) / "recordings"}') == 0
     assert os.system(f"cp {tetris_rom} {Path(git_tetris_ai) / 'tetris_1.1.gb'}") == 0
     assert os.system(f'cd {git_tetris_ai} && . {Path(".venv") / "bin" / "activate"} && python {script_py}') == 0
diff --git a/tests/test_turtle.py b/tests/test_turtle.py
new file mode 100644
index 000000000..acaaf8775
--- /dev/null
+++ b/tests/test_turtle.py
@@ -0,0 +1,42 @@
+#
+# License: See LICENSE.md file
+# GitHub: https://github.com/Baekalfen/PyBoy
+#
+
+import os.path
+from pathlib import Path
+
+import PIL
+import pytest
+
+from pyboy import PyBoy
+
+OVERWRITE_PNGS = False
+
+
+@pytest.mark.parametrize(
+    "rom",
+    [
+        "window_y_trigger.gb",
+        "window_y_trigger_wx_offscreen.gb",
+    ],
+)
+def test_turtletests(rom, turtletests_dir):
+    pyboy = PyBoy(turtletests_dir + rom, window="null")
+    pyboy.tick(60 + 20, True)
+
+    png_path = Path(f"tests/test_results/TurtleTest/{rom}.png")
+    image = pyboy.screen.image
+    if OVERWRITE_PNGS:
+        png_path.parents[0].mkdir(parents=True, exist_ok=True)
+        image.save(png_path)
+    else:
+        # Converting to RGB as ImageChops.difference cannot handle Alpha: https://github.com/python-pillow/Pillow/issues/4849
+        old_image = PIL.Image.open(png_path).convert("RGB")
+        diff = PIL.ImageChops.difference(image.convert("RGB"), old_image)
+
+        if diff.getbbox() and os.environ.get("TEST_VERBOSE_IMAGES"):
+            image.show()
+            old_image.show()
+            diff.show()
+        assert not diff.getbbox(), f"Images are different! {rom}"
diff --git a/tests/test_vectroid.py b/tests/test_vectroid.py
new file mode 100644
index 000000000..1b1a0004c
--- /dev/null
+++ b/tests/test_vectroid.py
@@ -0,0 +1,16 @@
+#
+# License: See LICENSE.md file
+# GitHub: https://github.com/Baekalfen/PyBoy
+#
+
+
+from pyboy import PyBoy
+
+# https://gitlab.com/BonsaiDen/vectroid.gb
+# https://gitlab.com/BonsaiDen/vectroid.gb/-/jobs/artifacts/master/raw/build/vectroid.gbc?job=build_rom
+
+
+def test_vectroid(vectroid_file):
+    pyboy = PyBoy(vectroid_file, window="null")
+    pyboy.tick(120, False)
+    pyboy.screen.image