doodle-ui 1.0.9__tar.gz

doodle_ui-1.0.9/MANIFEST.in

@@ -0,0 +1,2 @@
+include src/*.h
+include src/*.c

doodle_ui-1.0.9/PKG-INFO

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: doodle-ui
+Version: 1.0.9
+Summary: Hardware-accelerated DOM-based UI & 2D Game Engine
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Doodle Engine 🎨🚀
+### Hardware-Accelerated Hybrid C-Python UI & 2D Game Engine
+
+Doodle is a high-performance, lightweight UI and 2D game engine combining a **native C rendering core (powered by Raylib)** with a **highly reactive Python scripting layer**.
+
+By bypassing heavy browser runtimes (like Chromium/Electron), Doodle parses dynamic HTML-like templates and CSS stylesheets in a single pass directly to GPU-accelerated graphics, procedural audio synths, and collision meshes.
+
+---
+
+## 📂 Repository Organization
+
+```text
+Doodle/
+├── docs/                   # Full reference specifications & requirements
+│   ├── cheatsheet.md       # API & layout syntax quick reference
+│   ├── requirements.md     # Engine specifications and architecture blueprint
+│   └── unused_reference.md  # Unused HTML/CSS/C engine features reference
+├── doodle/                 # Python package wrapper
+│   ├── __init__.py         # Tween animations, reactive state binding, event emitter
+│   └── cli.py              # PyInstaller packager cli
+├── examples/               # Game demonstrations
+│   └── breakout/           # Breakout game demo
+│       ├── layout.html     # Game view DOM nodes & inline handlers
+│       ├── styles.css      # Retro arcade UI styles, flexbox, and crt shaders
+│       ├── shaders/        # Custom GLSL Fragment shaders
+│       └── main.py         # Collision, input, and game state script
+├── src/                    # C-Extension Core (complies to _doodle.pyd)
+│   ├── setup.py            # Setuptools compilation script
+│   ├── expose_raylib.c     # Python-to-C bindings, Raylib window, and particle pool
+│   ├── mparser.h / .c      # n-ary DOM parser, CSS registry handler, and layout box solver
+│   ├── dutils.h / .c       # Custom color parser, fast unit converter, and math helpers
+│   └── daudio.h / .c       # Polyphonic synth, multi-voice ADSR envelope generator
+├── third_party/            # Static Raylib binaries & dependencies
+└── README.md               # You are here!
+```
+
+---
+
+## 🛠️ Getting Started & Compilation
+
+### 1. Requirements
+* **OS**: Windows (x64) / linux
+* **Python**: Python 3.11+ (with virtual environment capability)
+* **C Toolchain**: MSYS2/MinGW-w64 (`C:\msys64\ucrt64\bin` for `gcc` and compilation libraries) / linux cc compiler
+
+### 2. Quick Setup & Build
+From the repository root directory, run the setuptools compilation with your virtual environment's python. Specify the compiler:
+
+```bash
+# Add GCC to PATH (if not global)
+$env:PATH = "C:\msys64\ucrt64\bin;" + $env:PATH
+
+# Compile the native C extension
+cd src
+..\.venv\Scripts\python.exe setup.py build_ext --inplace -c mingw32
+
+# Copy the compiled pyd module to the doodle library
+cd ..
+Copy-Item -Path "src\_doodle.cp311-win_amd64.pyd" -Destination "doodle\_doodle.pyd" -Force
+```
+
+### 3. Run the Breakout Demo
+Launch the breakout game:
+```bash
+cd examples/breakout
+..\..\.venv\Scripts\python.exe main.py
+```
+
+---
+
+## 🏗️ XML Markup (`layout.html`) & CSS (`styles.css`)
+
+Doodle supports layout-driven layouts with traditional tag structures and inline event bindings.
+
+### Core Elements
+* `<view>`: Structural container. Standard flex container or a 2D camera boundary using `<view camera="true">`.
+* `<text>`: Text layout with reactive state-bound variables like `SCORE: {{ score }}`.
+* `<image>`: Renders cached bitmaps using `src="..."`.
+* `<button>`: Clickable target with mouse state callbacks.
+* `<circle>`: Renders shapes using `radius` and `color` parameters.
+* `<line>`: Renders vectors using `x2`, `y2`, `thickness`, and `color`.
+
+### Event Hooks
+Directly attach Python functions inline:
+* `onclick="python_function_name"`
+* `onhover="python_function_name"`
+
+### Layout Styles
+* **Sizing Rules**: `width` / `height` support pixels (`100px`), percentages (`50%`), growth parameters (`grow`), and content sizing (`fit`).
+* **Flexbox Attributes**: `display: flex`, `flex-direction` (`row` | `column`), `justify-content` (`center` | `space-between` | `space-around`), `align-items`.
+* **Cosmetics**: `background-color`, `border-radius`, `border-color`, `border-width`, `opacity`, `font-family`, `font-size`.
+* **Juice Shaders**: Add custom GLSL fragment shaders directly to views using `shader-path: "shaders/crt.fs"`.
+
+---
+
+## 🐍 Python OOP APIs
+
+### Initialization
+```python
+import doodle
+
+# Game state passed for template rendering
+state = {"score": 0, "lives": 3}
+
+doodle.run(
+    layout="layout.html",
+    style="styles.css",
+    width=800,
+    height=600,
+    title="Game Window",
+    state=state
+)
+```
+
+### Node Manipulation
+```python
+# Fetch reference
+paddle = doodle.get_node("paddle")
+
+# Read/Write positions
+paddle.position = (350, 500)
+paddle.x += 10.0
+
+# Easing animations
+doodle.animate("paddle", target_x=350, target_y=500, duration=0.4, ease="quad_out")
+```
+
+### Input Polling
+```python
+# Keys
+doodle.is_key_down(263)      # Left arrow key code
+doodle.is_key_pressed(82)    # R key code
+
+# Mouse
+mx = doodle.get_mouse_x()
+doodle.set_mouse_cursor(4)   # Changes mouse pointer style
+```
+
+---
+
+## 🔊 Polyphonic Procedural Sound Synthesizer
+
+Doodle includes an integrated multi-voice synthesizer utilizing **ADSR Envelopes** to play retro sound waves without lagging the update tick loop.
+
+```python
+# Play procedural tone
+doodle.play_synth(
+    freq=440.0,
+    duration=0.15,
+    wave_type=doodle.WAVE_TRIANGLE,
+    attack=0.01,
+    decay=0.05,
+    sustain=0.3,
+    release=0.05
+)
+```
+
+**Wave Types**: `WAVE_SINE` (`0`), `WAVE_SQUARE` (`1`), `WAVE_TRIANGLE` (`2`), `WAVE_SAWTOOTH` (`3`), `WAVE_NOISE` (`4`)
+
+---
+
+## ⚡ Performance Optimizations
+
+Doodle is engineered for maximum performance, featuring multiple custom optimizations:
+1. **Single-Item DOM Lookup Cache**: Node lookup (`FindNodeById`) caches the pointer of the last requested node. Repetitive state checks (like checking click and hover events in the same frame) resolve in $O(1)$ without scanning the DOM tree.
+2. **Precompiled Format Templating**: Template variables `{{ score }}` are compiled once into native Python `{score}` string format structures, converting reactive updates from regex replacements to C-speed string builders.
+3. **Loop Division Elimination**: Particle shaders and polyphonic audio generators use cached precalculated inverse values (`inv_max_lifetime` and `phase_increment`) to replace expensive division operations with single-clock multiplication instructions.
+4. **Square Wave Optimization**: Square waves skip standard trignometric `sinf` calculations, computing high-low status directly from phase boundaries.

doodle_ui-1.0.9/README.md

@@ -0,0 +1,168 @@
+# Doodle Engine 🎨🚀
+### Hardware-Accelerated Hybrid C-Python UI & 2D Game Engine
+
+Doodle is a high-performance, lightweight UI and 2D game engine combining a **native C rendering core (powered by Raylib)** with a **highly reactive Python scripting layer**.
+
+By bypassing heavy browser runtimes (like Chromium/Electron), Doodle parses dynamic HTML-like templates and CSS stylesheets in a single pass directly to GPU-accelerated graphics, procedural audio synths, and collision meshes.
+
+---
+
+## 📂 Repository Organization
+
+```text
+Doodle/
+├── docs/                   # Full reference specifications & requirements
+│   ├── cheatsheet.md       # API & layout syntax quick reference
+│   ├── requirements.md     # Engine specifications and architecture blueprint
+│   └── unused_reference.md  # Unused HTML/CSS/C engine features reference
+├── doodle/                 # Python package wrapper
+│   ├── __init__.py         # Tween animations, reactive state binding, event emitter
+│   └── cli.py              # PyInstaller packager cli
+├── examples/               # Game demonstrations
+│   └── breakout/           # Breakout game demo
+│       ├── layout.html     # Game view DOM nodes & inline handlers
+│       ├── styles.css      # Retro arcade UI styles, flexbox, and crt shaders
+│       ├── shaders/        # Custom GLSL Fragment shaders
+│       └── main.py         # Collision, input, and game state script
+├── src/                    # C-Extension Core (complies to _doodle.pyd)
+│   ├── setup.py            # Setuptools compilation script
+│   ├── expose_raylib.c     # Python-to-C bindings, Raylib window, and particle pool
+│   ├── mparser.h / .c      # n-ary DOM parser, CSS registry handler, and layout box solver
+│   ├── dutils.h / .c       # Custom color parser, fast unit converter, and math helpers
+│   └── daudio.h / .c       # Polyphonic synth, multi-voice ADSR envelope generator
+├── third_party/            # Static Raylib binaries & dependencies
+└── README.md               # You are here!
+```
+
+---
+
+## 🛠️ Getting Started & Compilation
+
+### 1. Requirements
+* **OS**: Windows (x64) / linux
+* **Python**: Python 3.11+ (with virtual environment capability)
+* **C Toolchain**: MSYS2/MinGW-w64 (`C:\msys64\ucrt64\bin` for `gcc` and compilation libraries) / linux cc compiler
+
+### 2. Quick Setup & Build
+From the repository root directory, run the setuptools compilation with your virtual environment's python. Specify the compiler:
+
+```bash
+# Add GCC to PATH (if not global)
+$env:PATH = "C:\msys64\ucrt64\bin;" + $env:PATH
+
+# Compile the native C extension
+cd src
+..\.venv\Scripts\python.exe setup.py build_ext --inplace -c mingw32
+
+# Copy the compiled pyd module to the doodle library
+cd ..
+Copy-Item -Path "src\_doodle.cp311-win_amd64.pyd" -Destination "doodle\_doodle.pyd" -Force
+```
+
+### 3. Run the Breakout Demo
+Launch the breakout game:
+```bash
+cd examples/breakout
+..\..\.venv\Scripts\python.exe main.py
+```
+
+---
+
+## 🏗️ XML Markup (`layout.html`) & CSS (`styles.css`)
+
+Doodle supports layout-driven layouts with traditional tag structures and inline event bindings.
+
+### Core Elements
+* `<view>`: Structural container. Standard flex container or a 2D camera boundary using `<view camera="true">`.
+* `<text>`: Text layout with reactive state-bound variables like `SCORE: {{ score }}`.
+* `<image>`: Renders cached bitmaps using `src="..."`.
+* `<button>`: Clickable target with mouse state callbacks.
+* `<circle>`: Renders shapes using `radius` and `color` parameters.
+* `<line>`: Renders vectors using `x2`, `y2`, `thickness`, and `color`.
+
+### Event Hooks
+Directly attach Python functions inline:
+* `onclick="python_function_name"`
+* `onhover="python_function_name"`
+
+### Layout Styles
+* **Sizing Rules**: `width` / `height` support pixels (`100px`), percentages (`50%`), growth parameters (`grow`), and content sizing (`fit`).
+* **Flexbox Attributes**: `display: flex`, `flex-direction` (`row` | `column`), `justify-content` (`center` | `space-between` | `space-around`), `align-items`.
+* **Cosmetics**: `background-color`, `border-radius`, `border-color`, `border-width`, `opacity`, `font-family`, `font-size`.
+* **Juice Shaders**: Add custom GLSL fragment shaders directly to views using `shader-path: "shaders/crt.fs"`.
+
+---
+
+## 🐍 Python OOP APIs
+
+### Initialization
+```python
+import doodle
+
+# Game state passed for template rendering
+state = {"score": 0, "lives": 3}
+
+doodle.run(
+    layout="layout.html",
+    style="styles.css",
+    width=800,
+    height=600,
+    title="Game Window",
+    state=state
+)
+```
+
+### Node Manipulation
+```python
+# Fetch reference
+paddle = doodle.get_node("paddle")
+
+# Read/Write positions
+paddle.position = (350, 500)
+paddle.x += 10.0
+
+# Easing animations
+doodle.animate("paddle", target_x=350, target_y=500, duration=0.4, ease="quad_out")
+```
+
+### Input Polling
+```python
+# Keys
+doodle.is_key_down(263)      # Left arrow key code
+doodle.is_key_pressed(82)    # R key code
+
+# Mouse
+mx = doodle.get_mouse_x()
+doodle.set_mouse_cursor(4)   # Changes mouse pointer style
+```
+
+---
+
+## 🔊 Polyphonic Procedural Sound Synthesizer
+
+Doodle includes an integrated multi-voice synthesizer utilizing **ADSR Envelopes** to play retro sound waves without lagging the update tick loop.
+
+```python
+# Play procedural tone
+doodle.play_synth(
+    freq=440.0,
+    duration=0.15,
+    wave_type=doodle.WAVE_TRIANGLE,
+    attack=0.01,
+    decay=0.05,
+    sustain=0.3,
+    release=0.05
+)
+```
+
+**Wave Types**: `WAVE_SINE` (`0`), `WAVE_SQUARE` (`1`), `WAVE_TRIANGLE` (`2`), `WAVE_SAWTOOTH` (`3`), `WAVE_NOISE` (`4`)
+
+---
+
+## ⚡ Performance Optimizations
+
+Doodle is engineered for maximum performance, featuring multiple custom optimizations:
+1. **Single-Item DOM Lookup Cache**: Node lookup (`FindNodeById`) caches the pointer of the last requested node. Repetitive state checks (like checking click and hover events in the same frame) resolve in $O(1)$ without scanning the DOM tree.
+2. **Precompiled Format Templating**: Template variables `{{ score }}` are compiled once into native Python `{score}` string format structures, converting reactive updates from regex replacements to C-speed string builders.
+3. **Loop Division Elimination**: Particle shaders and polyphonic audio generators use cached precalculated inverse values (`inv_max_lifetime` and `phase_increment`) to replace expensive division operations with single-clock multiplication instructions.
+4. **Square Wave Optimization**: Square waves skip standard trignometric `sinf` calculations, computing high-low status directly from phase boundaries.

doodle_ui-1.0.9/doodle/__init__.py

@@ -0,0 +1,260 @@
+try:
+    from . import _doodle
+except ImportError:
+    import _doodle
+import sys
+import os
+import re
+import time
+import math
+
+# Re-export all flat APIs from _doodle
+for name in dir(_doodle):
+    if not name.startswith('_'):
+        globals()[name] = getattr(_doodle, name)
+
+# Event listener registry
+# node_id -> event_type -> list of callables
+_event_listeners = {}
+_event_context = {}
+_inline_listeners = {}
+_all_event_nodes = []
+
+def _rebuild_event_nodes():
+    global _all_event_nodes
+    _all_event_nodes = list(set(list(_event_listeners.keys()) + [k[0] for k in _inline_listeners.keys()]))
+
+def add_event_listener(node_id, event_type, callback):
+    if node_id not in _event_listeners:
+        _event_listeners[node_id] = {}
+    if event_type not in _event_listeners[node_id]:
+        _event_listeners[node_id][event_type] = []
+    _event_listeners[node_id][event_type].append(callback)
+    _rebuild_event_nodes()
+
+def set_event_context(context_dict):
+    global _event_context
+    _event_context.update(context_dict)
+
+# OOP Wrapper Node Class
+class NodeStyleProxy:
+    def __init__(self, node_id):
+        self._id = node_id
+    def __setattr__(self, name, value):
+        if name.startswith('_'):
+            super().__setattr__(name, value)
+        else:
+            # Convert python_name to css-property-name (e.g. background_color -> background-color)
+            css_name = name.replace('_', '-')
+            _doodle.set_style(self._id, css_name, str(value))
+    def __getattr__(self, name):
+        return ""
+
+class Node:
+    def __init__(self, node_id):
+        self.id = node_id
+        self.style = NodeStyleProxy(node_id)
+
+    @property
+    def position(self):
+        return _doodle.get_position(self.id)
+
+    @position.setter
+    def position(self, pos):
+        _doodle.set_position(self.id, float(pos[0]), float(pos[1]))
+
+    @property
+    def x(self):
+        return _doodle.get_position(self.id)[0]
+
+    @x.setter
+    def x(self, val):
+        y = _doodle.get_position(self.id)[1]
+        _doodle.set_position(self.id, float(val), y)
+
+    @property
+    def y(self):
+        return _doodle.get_position(self.id)[1]
+
+    @y.setter
+    def y(self, val):
+        x = _doodle.get_position(self.id)[0]
+        _doodle.set_position(self.id, x, float(val))
+
+    @property
+    def text(self):
+        return ""
+
+    @text.setter
+    def text(self, value):
+        _doodle.update_text(self.id, str(value))
+
+    def show(self):
+        _doodle.show_node(self.id)
+
+    def hide(self):
+        _doodle.hide_node(self.id)
+
+def get_node(node_id):
+    return Node(node_id)
+
+# Tweens Animation Engine
+_active_tweens = []
+
+def animate(node_id, target_x=None, target_y=None, duration=0.5, ease="quad_out"):
+    node = Node(node_id)
+    start_x, start_y = node.position
+    
+    if target_x is not None:
+        _active_tweens.append({
+            "node": node,
+            "prop": "x",
+            "start": start_x,
+            "end": target_x,
+            "duration": duration,
+            "elapsed": 0.0,
+            "ease": ease
+        })
+    if target_y is not None:
+        _active_tweens.append({
+            "node": node,
+            "prop": "y",
+            "start": start_y,
+            "end": target_y,
+            "duration": duration,
+            "elapsed": 0.0,
+            "ease": ease
+        })
+
+def _update_tweens(dt):
+    global _active_tweens
+    still_active = []
+    for t in _active_tweens:
+        t["elapsed"] += dt
+        progress = min(t["elapsed"] / t["duration"], 1.0)
+        
+        if t["ease"] == "linear":
+            val = progress
+        elif t["ease"] == "quad_out":
+            val = progress * (2 - progress)
+        elif t["ease"] == "quad_in":
+            val = progress * progress
+        else:
+            val = progress
+            
+        current_val = t["start"] + val * (t["end"] - t["start"])
+        setattr(t["node"], t["prop"], current_val)
+        
+        if t["elapsed"] < t["duration"]:
+            still_active.append(t)
+    _active_tweens = still_active
+
+# Waveform Constants
+WAVE_SINE = 0
+WAVE_SQUARE = 1
+WAVE_TRIANGLE = 2
+WAVE_SAWTOOTH = 3
+WAVE_NOISE = 4
+
+# Template Data Binding
+_templates = {}
+
+def _parse_layout_templates(layout_path):
+    global _templates
+    _templates = {}
+    try:
+        with open(layout_path, "r", encoding="utf-8") as f:
+            content = f.read()
+            
+        # Match elements containing {{ variable }} with template group markers
+        pattern = r'<([a-zA-Z0-9]+)\s+[^>]*id="([^"]+)"[^>]*>([^<]*\{\{.*?\}\}[^<]*)<\/\1>'
+        matches = re.findall(pattern, content, re.DOTALL)
+        for tag, node_id, template_str in matches:
+            # Convert '{{ var }}' to '{var}' for built-in fast formatting
+            _templates[node_id] = re.sub(r'\{\{\s*([a-zA-Z0-9_]+)\s*\}\}', r'{\1}', template_str)
+    except Exception as e:
+        print(f"Template parsing warning: {e}")
+
+_tick_callback = None
+
+def register_tick_callback(callback):
+    global _tick_callback
+    _tick_callback = callback
+
+def _update_templates(state):
+    for node_id, format_str in _templates.items():
+        try:
+            _doodle.update_text(node_id, format_str.format(**state))
+        except Exception:
+            pass
+
+# Extended main run loop
+def run(layout="layout.html", style="styles.css", width=800, height=600, title="Doodle Engine", state=None):
+    if hasattr(sys, "_MEIPASS"):
+        try:
+            os.chdir(sys._MEIPASS)
+        except Exception:
+            pass
+    _parse_layout_templates(layout)
+    
+    # Extract inline event callbacks from layout.html
+    global _inline_listeners
+    _inline_listeners = {}
+    try:
+        with open(layout, "r", encoding="utf-8") as f:
+            content = f.read()
+        tag_pattern = r'<[a-zA-Z0-9]+\s+([^>]*id="([^"]+)"[^>]*)>'
+        tags = re.findall(tag_pattern, content)
+        for attr_str, node_id in tags:
+            click_match = re.search(r'onclick="([^"]+)"', attr_str)
+            if click_match:
+                _inline_listeners[(node_id, "click")] = click_match.group(1)
+            hover_match = re.search(r'onhover="([^"]+)"', attr_str)
+            if hover_match:
+                _inline_listeners[(node_id, "hover")] = hover_match.group(1)
+    except Exception as e:
+        print(f"Event parsing warning: {e}")
+        
+    _rebuild_event_nodes()
+
+    last_time = time.perf_counter()
+    
+    def wrapper_tick():
+        nonlocal last_time
+        now = time.perf_counter()
+        dt = now - last_time
+        last_time = now
+        
+        _update_tweens(dt)
+        
+        if state is not None:
+            _update_templates(state)
+            
+        for node_id in _all_event_nodes:
+            if _doodle.is_node_clicked(node_id):
+                if node_id in _event_listeners and "click" in _event_listeners[node_id]:
+                    for cb in _event_listeners[node_id]["click"]:
+                        cb()
+                if (node_id, "click") in _inline_listeners:
+                    cb_name = _inline_listeners[(node_id, "click")]
+                    cb = _event_context.get(cb_name) or globals().get(cb_name) or sys.modules['__main__'].__dict__.get(cb_name)
+                    if cb:
+                        cb()
+                        
+            if _doodle.is_node_hovered(node_id):
+                if node_id in _event_listeners and "hover" in _event_listeners[node_id]:
+                    for cb in _event_listeners[node_id]["hover"]:
+                        cb()
+                if (node_id, "hover") in _inline_listeners:
+                    cb_name = _inline_listeners[(node_id, "hover")]
+                    cb = _event_context.get(cb_name) or globals().get(cb_name) or sys.modules['__main__'].__dict__.get(cb_name)
+                    if cb:
+                        cb()
+                        
+        if _tick_callback:
+            _tick_callback()
+
+    # Setup Python wrapper's registration hook
+    _doodle.register_tick_callback(wrapper_tick)
+    
+    return _doodle.run(layout=layout, style=style, width=width, height=height, title=title)

doodle_ui-1.0.9/doodle/cli.py

@@ -0,0 +1,78 @@
+import sys
+import os
+import subprocess
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python -m doodle.cli package <entrypoint.py>")
+        sys.exit(1)
+        
+    cmd = sys.argv[1]
+    if cmd != "package":
+        print(f"Unknown command: {cmd}. Available commands: package")
+        sys.exit(1)
+        
+    if len(sys.argv) < 3:
+        print("Please specify the entrypoint script (e.g. main.py)")
+        sys.exit(1)
+        
+    entrypoint = sys.argv[2]
+    if not os.path.exists(entrypoint):
+        print(f"Error: Entrypoint file '{entrypoint}' not found.")
+        sys.exit(1)
+        
+    print(f"=== Doodle Standalone Packager ===")
+    print(f"Packing '{entrypoint}' into a standalone executable...")
+    
+    # Check if PyInstaller is installed
+    try:
+        import PyInstaller
+    except ImportError:
+        print("PyInstaller is not installed. Installing it via pip...")
+        subprocess.run([sys.executable, "-m", "pip", "install", "pyinstaller"], check=True)
+        
+    # Build command line arguments
+    # On Windows, path separator is ;. On Unix it is :.
+    sep = ";" if os.name == "nt" else ":"
+    
+    import doodle
+    doodle_dir = os.path.dirname(os.path.abspath(doodle.__file__))
+    doodle_pyd = os.path.join(doodle_dir, "_doodle.pyd")
+    entrypoint_dir = os.path.dirname(os.path.abspath(entrypoint))
+    
+    layout_path = os.path.join(entrypoint_dir, "layout.html")
+    styles_path = os.path.join(entrypoint_dir, "styles.css")
+    shaders_path = os.path.join(entrypoint_dir, "shaders")
+    assets_path = os.path.join(entrypoint_dir, "assets")
+    
+    pyinstaller_args = [
+        sys.executable,
+        "-m",
+        "PyInstaller",
+        "--onefile",
+        "--noconsole",
+        f"--add-binary={doodle_pyd}{sep}doodle",
+        f"--add-data={layout_path}{sep}.",
+        f"--add-data={styles_path}{sep}.",
+    ]
+    
+    # Add folders if they exist
+    if os.path.exists(shaders_path):
+        pyinstaller_args.append(f"--add-data={shaders_path}{sep}shaders")
+    if os.path.exists(assets_path):
+        pyinstaller_args.append(f"--add-data={assets_path}{sep}assets")
+        
+    # Link against raylib dll if found locally
+    if os.path.exists("raylib.dll"):
+        pyinstaller_args.append(f"--add-binary=raylib.dll{sep}.")
+    elif os.path.exists("src/raylib.dll"):
+        pyinstaller_args.append(f"--add-binary=src/raylib.dll{sep}.")
+        
+    pyinstaller_args.append(entrypoint)
+    
+    print(f"Running: {' '.join(pyinstaller_args)}")
+    subprocess.run(pyinstaller_args)
+    print(f"Packager completed. Check the 'dist/' folder for your executable.")
+
+if __name__ == "__main__":
+    main()