chip8-py 0.1.1__py3-none-any.whl

chip8_py-0.1.1.dist-info/METADATA

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: chip8-py
+Version: 0.1.1
+Summary: A CHIP-8 emulator ecosystem.
+Author: las-r
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: platformdirs
+Requires-Dist: raylib
+Dynamic: license-file
+
+# pychip8
+A modular, extensible CHIP-8 emulator ecosystem written in modern Python.
+
+> **Note:** This is a remake of an old project of mine, [chip-8-python](https://github.com/las-r/chip-8-python), which aimed to do the same thing but was honestly pretty poorly made. It was monolithic and clunky, and this one is built to be an actual Python package.
+
+## Installation
+Requires Python 3.11+.
+
+```sh
+git clone https://github.com/las-r/pychip8
+cd pychip8
+pip install -e .
+```
+
+## Usage
+```sh
+pychip8 path/to/rom.ch8
+```
+
+## Config
+### Flags
+Flags override the config file.
+
+| Flag | Description |
+|---|---|
+| `--cpf <int>` | Cycles per frame (default: 10) |
+| `--scale <int>` | Display scale (default: 12) |
+| `--volume <float>` | Audio volume 0.0–1.0 (default: 0.2) |
+| `--cosmac-shift / --no-cosmac-shift` | COSMAC VIP shift quirk |
+| `--cosmac-jump / --no-cosmac-jump` | COSMAC VIP jump quirk |
+| `--cosmac-i-add / --no-cosmac-i-add` | COSMAC VIP index add quirk |
+| `--cosmac-font / --no-cosmac-font` | COSMAC VIP font quirk |
+| `--cosmac-ls / --no-cosmac-ls` | COSMAC VIP load/store quirk |
+| `--vf-reset / --no-vf-reset` | Reset VF after logic instructions |
+
+### File
+On first run, a default config is created at:
+- **Windows:** `C:/Users/YOUR_USER_PROFILE/AppData/Local/pychip8/`
+- **macOS:** `~/Library/Application Support/pychip8/`
+- **Linux:** `~/.config/pychip8/`
+
+Edit this file to set your preferred defaults.
+
+## Keypad
+The CHIP-8 hex keypad maps to the left side of a QWERTY keyboard:
+```
+CHIP-8    Keyboard
+1 2 3 C   1 2 3 4
+4 5 6 D   Q W E R
+7 8 9 E   A S D F
+A 0 B F   Z X C V
+```
+
+## Credits
+- [raylib](https://www.raylib.com/) ([Python](https://github.com/electronstudio/raylib-python-cffi/))
+- [Guide to making a CHIP-8 emulator](https://tobiasvl.github.io/blog/write-a-chip-8-emulator/)
+- [Timendus' CHIP-8 Test Suite](https://github.com/Timendus/chip8-test-suite)

chip8_py-0.1.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+chip8_py-0.1.1.dist-info/licenses/LICENSE,sha256=0sUKddG_MAEmXC_bOrbwo0aYFSfKiAdDgwirseE3cGo,1066
+pychip8/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pychip8/__main__.py,sha256=FcRWP3TQ4SnRmJRCYvNJK-kcZ5GJdqWBP-4qnwZ0ta8,3078
+pychip8/config.toml,sha256=3EgBXb_6xBvtTVdkaR3pi9DlCqKwmIYhh-tX7mkqXxo,192
+pychip8/cpu.py,sha256=UkbLwiPZ9hAhY8UQXl_M9uZMDP8Ly914cwAetoZhyf8,8041
+pychip8/display.py,sha256=yx-yxG_5XUOQY0vu_8xBOqJkIXAQvvMfVV-pwsPL4dk,1130
+pychip8/keypad.py,sha256=a1inot44EOiy_taiSFYYYVGr4wIoC843LURun2laai0,792
+pychip8/memory.py,sha256=kYmv88I8aS6X9SPl0XOHqIlL8_-sb5hfVTenxyvo29w,1222
+pychip8/timers.py,sha256=2bpiabZeGI2Ceee4po0y4Rez90M57MDKu0h_Gf24Wv8,1646
+chip8_py-0.1.1.dist-info/METADATA,sha256=MZaickaCSOmzmSQQhfCAqH8yFPDlycXeyJjwaGi2ewI,2185
+chip8_py-0.1.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+chip8_py-0.1.1.dist-info/entry_points.txt,sha256=RB3j_uxeFd9hXZaxNpXAqOKFilV8TpV8pTVuuNgc9gg,50
+chip8_py-0.1.1.dist-info/top_level.txt,sha256=uGwyF_4peqm6uOkGF5EGfiGWwppVMwvmQMVb7Lkt4ks,8
+chip8_py-0.1.1.dist-info/RECORD,,

chip8_py-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

chip8_py-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pychip8 = pychip8.__main__:main

chip8_py-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nayif Ehan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

chip8_py-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+pychip8

pychip8/__main__.py

@@ -0,0 +1,87 @@
+from .cpu import Processor
+from .display import Display
+from .keypad import Keypad
+from .memory import Memory
+from .timers import Timers
+
+from pathlib import Path
+from platformdirs import user_config_dir
+import argparse
+import shutil
+import tomllib
+import pyray as rl
+
+# setup and load config
+CONFDIR = Path(user_config_dir("pychip8"))
+CONFPATH = CONFDIR / "config.toml"
+if not CONFPATH.exists():
+    CONFDIR.mkdir(parents=True, exist_ok=True)
+    shutil.copy(Path(__file__).parent / "config.toml", CONFPATH)
+with open(CONFPATH, "rb") as f:
+    cfg = tomllib.load(f)
+
+# main
+def main():
+    # args
+    parser = argparse.ArgumentParser(prog="pychip8", description="A CHIP-8 emulator.")
+    parser.add_argument("rom", help="path to rom file")
+    parser.add_argument("--cpf", type=int, help="cycles per frame")
+    parser.add_argument("--scale", type=int, help="display scale")
+    parser.add_argument("--volume", type=float, help="audio volume (0.0-1.0)")
+    parser.add_argument("--cosmac-shift", action=argparse.BooleanOptionalAction)
+    parser.add_argument("--cosmac-jump", action=argparse.BooleanOptionalAction)
+    parser.add_argument("--cosmac-i-add", action=argparse.BooleanOptionalAction)
+    parser.add_argument("--cosmac-font", action=argparse.BooleanOptionalAction)
+    parser.add_argument("--cosmac-ls", action=argparse.BooleanOptionalAction)
+    parser.add_argument("--vf-reset", action=argparse.BooleanOptionalAction)
+    parser.add_argument("--fg", type=lambda x: int(x, 16), help="foreground color (hex, e.g. FFFFFFFF)")
+    parser.add_argument("--bg", type=lambda x: int(x, 16), help="background color (hex, e.g. 000000FF)")
+    args = parser.parse_args()
+
+    # config helpers
+    def gcpu(key, flag):
+        return flag if flag is not None else cfg["cpu"][key]
+    def gdisp(key, flag):
+        return flag if flag is not None else cfg["display"][key]
+    def gaud(key, flag):
+        return flag if flag is not None else cfg["audio"][key]
+
+    # load rom
+    with open(args.rom, "rb") as f:
+        rom = f.read()
+
+    # init
+    display = Display(
+        scale=gdisp("scale", args.scale),
+        fg=gdisp("fg", args.fg),
+        bg=gdisp("bg", args.bg),
+    )
+    keypad = Keypad()
+    timers = Timers(vol=gaud("volume", args.volume))
+    memory = Memory()
+    memory.load_rom(rom)
+    cpu = Processor(memory, display, keypad, timers, cpf=gcpu("cpf", args.cpf))
+
+    # apply quirks
+    cpu.cosmac_shift = gcpu("cosmac_shift", args.cosmac_shift)
+    cpu.cosmac_jump = gcpu("cosmac_jump", args.cosmac_jump)
+    cpu.cosmac_i_add = gcpu("cosmac_i_add", args.cosmac_i_add)
+    cpu.cosmac_font = gcpu("cosmac_font", args.cosmac_font)
+    cpu.cosmac_ls = gcpu("cosmac_ls", args.cosmac_ls)
+    cpu.vf_reset = gcpu("vf_reset", args.vf_reset)
+
+    # main loop
+    while not rl.window_should_close():
+        cpu.pkeys = cpu.kp.keys.copy()
+        cpu.kp.update()
+        for _ in range(cpu.cpf):
+            cpu.cycle()
+        cpu.tm.update()
+        cpu.disp.render()
+
+    # deinit
+    cpu.disp.deinit()
+    cpu.tm.deinit()
+
+if __name__ == "__main__":
+    main()

pychip8/config.toml

@@ -0,0 +1,15 @@
+[cpu]
+cpf = 10
+cosmac_shift = false
+cosmac_jump = false
+cosmac_i_add = false
+cosmac_font = true
+cosmac_ls = false
+vf_reset = true
+
+[display]
+scale = 12
+title = "pychip8"
+
+[audio]
+volume = 0.05

pychip8/cpu.py

@@ -0,0 +1,247 @@
+from .display import Display
+from .keypad import Keypad
+from .memory import Memory
+from .timers import Timers
+import numpy as np
+import random
+
+# pychip8 cpu
+# by las-r
+
+# processor class
+class Processor:
+    def __init__(self, ram: Memory, disp: Display, kp: Keypad, tm: Timers, cpf: int = 10):
+        self.ram = ram
+        self.disp = disp
+        self.kp = kp
+        self.tm = tm
+        self.cpf = cpf
+        
+        # opcode options
+        self.cosmac_shift = False # def: False
+        self.cosmac_jump = False # def: False
+        self.cosmac_i_add = False # def: False
+        self.cosmac_font = True # def: True
+        self.cosmac_ls = False # def: False
+        self.vf_reset = True # def: True
+        
+        # data storage
+        self.v = np.zeros(16, np.uint8)
+        self.pc = np.uint16(0x200)
+        self.i = np.uint16(0)
+        self.stack = []
+        
+        # other
+        self.pkeys = np.zeros(16, dtype=np.uint8)
+        
+    def fetch(self) -> np.uint16:
+        high = self.ram[self.pc]
+        low = self.ram[self.pc + 1]
+        opc = (np.uint16(high) << 8) | np.uint16(low)
+        self.pc += 2
+        return opc
+    
+    def execute(self, inst):
+        l = inst >> 12
+        x = (inst >> 8) & 0xf
+        y = (inst >> 4) & 0xf
+        n = inst & 0xf
+        nn = inst & 0xff
+        nnn = inst & 0xfff
+        
+        match (l, x, y, n):
+            # clear screen
+            case (0, 0, 14, 0):
+                self.disp.clear()
+                
+            # return from subroutine
+            case (0, 0, 14, 14):
+                self.pc = self.stack.pop()
+                
+            # jump to nnn
+            case (1, _, _, _):
+                self.pc = nnn
+                
+            # call subroutine
+            case (2, _, _, _):
+                self.stack.append(self.pc)
+                self.pc = nnn
+                
+            # skip if vx == nn
+            case (3, _, _, _):
+                if self.v[x] == nn:
+                    self.pc += 2
+                    
+            # skip if vx != nn
+            case (4, _, _, _):
+                if self.v[x] != nn:
+                    self.pc += 2
+                    
+            # skip if vx == vy
+            case (5, _, _, 0):
+                if self.v[x] == self.v[y]:
+                    self.pc += 2
+                
+            # set vx
+            case (6, _, _, _):
+                self.v[x] = nn
+                
+            # add to vx
+            case (7, _, _, _):
+                self.v[x] += nn
+                
+            # set vx to vy
+            case (8, _, _, 0):
+                self.v[x] = self.v[y]
+                
+            # set vx to vx OR vy
+            case (8, _, _, 1):
+                self.v[x] |= self.v[y]
+                if self.vf_reset:
+                    self.v[0xf] = 0
+                
+            # set vx to vx AND vy
+            case (8, _, _, 2):
+                self.v[x] &= self.v[y]
+                if self.vf_reset:
+                    self.v[0xf] = 0
+            
+            # set vx to vx XOR vy
+            case (8, _, _, 3):
+                self.v[x] ^= self.v[y]
+                if self.vf_reset:
+                    self.v[0xf] = 0
+                
+            # set vx to vx + vy
+            case (8, _, _, 4):
+                o = self.v[x]
+                self.v[x] += self.v[y]
+                self.v[0xf] = 1 if o > self.v[x] else 0
+            
+            # set vx to vx - vy
+            case (8, _, _, 5):
+                self.v[x] -= self.v[y]
+                self.v[0xf] = 1 if self.v[x] >= self.v[y] else 0
+                
+            # right shift
+            case (8, _, _, 6):
+                if self.cosmac_shift:
+                    self.v[x] = self.v[y]
+                self.v[0xf] = self.v[x] & 0x1
+                self.v[x] >>= 1
+                
+            # set vx to vy - vx
+            case (8, _, _, 7):
+                self.v[x] = self.v[y] - self.v[x]
+                self.v[0xf] = 1 if self.v[y] >= self.v[x] else 0
+            
+            # left shift
+            case (8, _, _, 14):
+                if self.cosmac_shift:
+                    self.v[x] = self.v[y]
+                self.v[0xf] = self.v[x] >> 7
+                self.v[x] <<= 1
+                
+            # skip if vx != vy
+            case (9, _, _, 0):
+                if self.v[x] != self.v[y]:
+                    self.pc += 2
+            
+            # set index register
+            case (10, _, _, _):
+                self.i = nnn
+                
+            # jump w/ offset
+            case (11, _, _, _):
+                self.pc = nnn + self.v[0 if self.cosmac_jump else x]
+                
+            # set vx to random AND nn
+            case (12, _, _, _):
+                self.v[x] = np.uint8(random.randint(0, 255) & nn)
+            
+            # draw
+            case (13, _, _, _):
+                sx = self.v[x] & 63
+                sy = self.v[y] & 31
+                self.v[0xF] = 0
+                sbytes = self.ram.mem[self.i : self.i + n]
+                sbits = np.unpackbits(sbytes).reshape(n, 8)
+                for ri in range(n):
+                    ty = (sy + ri) % 32
+                    for ci in range(8):
+                        tx = (sx + ci) % 64
+                        pixel = sbits[ri, ci]
+                        if pixel:
+                            if self.disp.grid[ty, tx] == 1:
+                                self.v[0xF] = 1
+                            self.disp.grid[ty, tx] ^= 1
+                            
+            # skip if key vx pressed
+            case (14, _, 9, 14):
+                if self.kp.is_pressed(self.v[x]):
+                    self.pc += 2
+                    
+            # skip if key vx not pressed
+            case (14, _, 10, 1):
+                if not self.kp.is_pressed(self.v[x]):
+                    self.pc += 2
+                    
+            # set vx to delay timer
+            case (15, _, 0, 7):
+                self.v[x] = self.tm.delay
+                
+            # get key
+            case (15, _, 0, 10):
+                print(f"pkeys: {self.pkeys}, keys: {self.kp.keys}")
+                released = None
+                for k in range(16):
+                    if self.pkeys[k] == 1 and self.kp.keys[k] == 0:
+                        released = k
+                        break
+                if released is not None:
+                    self.v[x] = released
+                else:
+                    self.pc -= 2
+                
+            # set delay timer to vx
+            case (15, _, 1, 5):
+                self.tm.set_delay(self.v[x])
+                
+            # set sound timer to vx
+            case (15, _, 1, 8):
+                self.tm.set_sound(self.v[x])
+            
+            # add to index
+            case (15, _, 1, 14):
+                self.i += self.v[x]
+                if not self.cosmac_i_add:
+                    if self.i > 0xfff:
+                        self.v[0xf] = 1
+                        
+            # set i to font character
+            case (15, _, 2, 9):
+                ch = (self.v[x] & 0xf) if self.cosmac_font else self.v[x]
+                self.i = 0x50 + (ch * 5)
+                
+            # bcd
+            case (15, _, 3, 3):
+                self.ram[int(self.i)] = np.uint8(self.v[x] // 100)
+                self.ram[int(self.i) + 1] = np.uint8((self.v[x] // 10) % 10)
+                self.ram[int(self.i) + 2] = np.uint8(self.v[x] % 10)
+                
+            # store in memory
+            case (15, _, 5, 5):
+                for j in range(0, x + 1):
+                    self.ram[int(self.i) + j] = self.v[j]
+                if self.cosmac_ls:
+                    self.i += x + 1
+                    
+            # load from memory
+            case (15, _, 6, 5):
+                for j in range(0, x + 1):
+                    self.v[j] = self.ram[int(self.i) + j]
+                if self.cosmac_ls:
+                    self.i += x + 1
+                            
+    def cycle(self):
+        self.execute(self.fetch())

pychip8/display.py

@@ -0,0 +1,41 @@
+import numpy as np
+import pyray as rl
+
+# pychip8 display
+# by las-r
+
+# display class
+class Display:
+    def __init__(self, scale: int = 12, title: str = "pychip8", fg: int = 0xFFFFFFFF, bg: int = 0x000000FF):
+        self.cols = 64
+        self.rows = 32
+        self.scale = scale
+        self.grid = np.zeros((self.rows, self.cols), dtype=np.uint8)
+        self.on = rl.get_color(fg)
+        self.off = rl.get_color(bg)
+
+        rl.init_window(self.cols * self.scale, self.rows * self.scale, title)
+        rl.set_target_fps(60)
+
+    def clear(self):
+        self.grid.fill(0)
+
+    def render(self):
+        rl.begin_drawing()
+        rl.clear_background(self.off)
+        
+        for y in range(self.rows):
+            for x in range(self.cols):
+                if self.grid[y, x] == 1:
+                    rl.draw_rectangle(
+                        x * self.scale,
+                        y * self.scale,
+                        self.scale,
+                        self.scale,
+                        self.on
+                    )
+                    
+        rl.end_drawing()
+
+    def deinit(self):
+        rl.close_window()

pychip8/keypad.py

@@ -0,0 +1,20 @@
+import pyray as rl
+import numpy as np
+
+KEYMAP = {
+    rl.KeyboardKey.KEY_ONE: 1, rl.KeyboardKey.KEY_TWO: 2, rl.KeyboardKey.KEY_THREE: 3, rl.KeyboardKey.KEY_FOUR: 12,
+    rl.KeyboardKey.KEY_Q: 4, rl.KeyboardKey.KEY_W: 5, rl.KeyboardKey.KEY_E: 6, rl.KeyboardKey.KEY_R: 13,
+    rl.KeyboardKey.KEY_A: 7, rl.KeyboardKey.KEY_S: 8, rl.KeyboardKey.KEY_D: 9, rl.KeyboardKey.KEY_F: 14,
+    rl.KeyboardKey.KEY_Z: 10, rl.KeyboardKey.KEY_X: 0, rl.KeyboardKey.KEY_C: 11, rl.KeyboardKey.KEY_V: 15,
+}
+
+class Keypad:
+    def __init__(self):
+        self.keys = np.zeros(16, dtype=np.uint8)
+
+    def update(self):
+        for raykey, chip8key in KEYMAP.items():
+            self.keys[chip8key] = 1 if rl.is_key_down(raykey) else 0
+
+    def is_pressed(self, key) -> bool:
+        return self.keys[int(key)] == 1

pychip8/memory.py

@@ -0,0 +1,40 @@
+import numpy as np
+
+# pychip8 memory
+# by las-r
+
+# font
+FONTSET = np.array([
+    0xF0, 0x90, 0x90, 0x90, 0xF0, # 0
+    0x20, 0x60, 0x20, 0x20, 0x70, # 1
+    0xF0, 0x10, 0xF0, 0x80, 0xF0, # 2
+    0xF0, 0x10, 0xF0, 0x10, 0xF0, # 3
+    0x90, 0x90, 0xF0, 0x10, 0x10, # 4
+    0xF0, 0x80, 0xF0, 0x10, 0xF0, # 5
+    0xF0, 0x80, 0xF0, 0x90, 0xF0, # 6
+    0xF0, 0x10, 0x20, 0x40, 0x40, # 7
+    0xF0, 0x90, 0xF0, 0x90, 0xF0, # 8
+    0xF0, 0x90, 0xF0, 0x10, 0xF0, # 9
+    0xF0, 0x90, 0xF0, 0x90, 0x90, # A
+    0xE0, 0x90, 0xE0, 0x90, 0xE0, # B
+    0xF0, 0x80, 0x80, 0x80, 0xF0, # C
+    0xE0, 0x90, 0x90, 0x90, 0xE0, # D
+    0xF0, 0x80, 0xF0, 0x80, 0xF0, # E
+    0xF0, 0x80, 0xF0, 0x80, 0x80, # F
+], dtype=np.uint8)
+
+# ram class
+class Memory:
+    def __init__(self, size: int = 4096):
+        self.mem = np.zeros(size, dtype=np.uint8)
+        self.mem[0x50:0xa0] = FONTSET
+        
+    def __setitem__(self, loc: int | np.uint16, val: int | np.uint8):
+        self.mem[loc] = val
+
+    def __getitem__(self, loc: int | np.uint16) -> np.uint8:
+        return self.mem[loc]
+        
+    def load_rom(self, romb: bytes, start: int = 0x200):
+        end = start + len(romb)
+        self.mem[start:end] = np.frombuffer(romb, dtype=np.uint8)

pychip8/timers.py

@@ -0,0 +1,55 @@
+import numpy as np
+import pyray as rl
+import math
+
+class Timers:
+    def __init__(self, vol: float = 0.05):
+        self.delay = np.uint8(0)
+        self.sound = np.uint8(0)
+        self.playing = False
+        
+        rl.init_audio_device()
+        smprate = 44100
+        smps = int(smprate * 0.5)
+        freq = 600
+        raw = []
+        for i in range(smps):
+            t = i / smprate
+            sample = math.sin(2 * math.pi * freq * t)
+            raw.append(sample)
+        self.data_buffer = rl.ffi.new(f"float[{smps}]", raw)
+        rl.set_audio_stream_buffer_size_default(smps)
+        self.stream = rl.load_audio_stream(smprate, 32, 1)
+        rl.update_audio_stream(self.stream, self.data_buffer, smps)
+        rl.set_audio_stream_volume(self.stream, vol)
+        
+    def set_delay(self, val):
+        self.delay = np.uint8(int(val))
+        
+    def set_sound(self, val):
+        self.sound = np.uint8(int(val))
+
+    def update(self):
+        if self.delay > 0:
+            self.delay -= 1
+        if self.sound > 0:
+            self.sound -= 1
+            self.play_beep()
+        else:
+            self.stop_beep()
+
+    def play_beep(self):
+        if not self.playing:
+            rl.play_audio_stream(self.stream)
+            self.playing = True
+        if rl.is_audio_stream_processed(self.stream):
+            rl.update_audio_stream(self.stream, self.data_buffer, len(self.data_buffer))
+
+    def stop_beep(self):
+        if self.playing:
+            rl.stop_audio_stream(self.stream)
+            self.playing = False
+    
+    def deinit(self):
+        rl.unload_audio_stream(self.stream)
+        rl.close_audio_device()