kigo-gui-framework 2.4__tar.gz → 2.6__tar.gz

{kigo_gui_framework-2.4 → kigo_gui_framework-2.6}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: kigo-gui-framework
-Version: 2.4
-Summary: Added WASM and HUD (HUD executed by F2) check out the website- https://kigo-the-best-gui-framework.netlify.app
+Version: 2.6
+Summary: Added Android support, smoke shader and ECS. Note that Kigo does NOT COME WITH ANY MALWARE, IF YOU SPOT IT PLEASE EMAIL bot28482@gmail.com
 Author-email: "Anand Kumar, Utkarsh Raghav Roy" <swiss.armyknife@icloud.com>
 License: zlib
 Keywords: gui,qt,pyqt6,physics,pybullet,simulation,robotics,animation
@@ -16,12 +16,11 @@ Requires-Dist: PyQt6==6.7.0
 Requires-Dist: pybullet>=3.2.5
 Requires-Dist: pybullet_data
 Requires-Dist: wasmtime>=25.0.0
+Requires-Dist: pyopengl>=3.1.10
 Provides-Extra: web
 Requires-Dist: PyQt6-WebEngine==6.7.0; extra == "web"
 Provides-Extra: full
 Requires-Dist: markdown; extra == "full"
 Requires-Dist: PyQt6-WebEngine==6.7.0; extra == "full"
 
-Asset Caching
-Kigo introduces asset caching. What it does is keep things in memory so that if your app needs them it can access that thing much faster. Also I passed
-in the exam and am going to class five pray for me plz
+Kigo now has Android support (experimental), ECS and a smoke shader. 

kigo_gui_framework-2.6/README.txt

@@ -0,0 +1 @@
+Kigo now has Android support (experimental), ECS and a smoke shader. 

kigo_gui_framework-2.6/kigo/app.py

@@ -0,0 +1,107 @@
+# SPDX-License-Identifier: Zlib
+# kigo/app.py
+
+from __future__ import annotations
+import sys
+import time
+
+from kigo.qt.backend import QtCore, QtWidgets, IS_ANDROID
+from kigo.android import AndroidLifecycle, is_android
+
+
+class App:
+    """
+    Base application class for Kigo.
+
+    - Desktop: PyQt6
+    - Android: PySide6
+    - Touch-friendly
+    - Lifecycle-aware
+    """
+
+    def __init__(self, *, dev: bool = False):
+        self.dev = dev
+        self._last_time = time.perf_counter()
+
+        # ----------------------------------
+        # Qt Application
+        # ----------------------------------
+        self.qt_app = QtWidgets.QApplication.instance()
+        if self.qt_app is None:
+            self.qt_app = QtWidgets.QApplication(sys.argv)
+
+        # ----------------------------------
+        # Android lifecycle
+        # ----------------------------------
+        self.lifecycle = None
+        if is_android():
+            self.lifecycle = AndroidLifecycle(self.qt_app)
+            self.lifecycle.paused.connect(self.on_pause)
+            self.lifecycle.resumed.connect(self.on_resume)
+
+        # ----------------------------------
+        # Frame update timer
+        # ----------------------------------
+        self._timer = QtCore.QTimer()
+        self._timer.timeout.connect(self._tick)
+
+    # --------------------------------------------------
+    # App lifecycle (override in subclasses)
+    # --------------------------------------------------
+    def on_start(self):
+        """
+        Called once when the app starts.
+        Override this to build UI.
+        """
+        pass
+
+    def on_pause(self):
+        """
+        Android only: app moved to background.
+        Override if needed.
+        """
+        if self.dev:
+            print("[Kigo] App paused")
+
+    def on_resume(self):
+        """
+        Android only: app returned to foreground.
+        Override if needed.
+        """
+        if self.dev:
+            print("[Kigo] App resumed")
+
+    def update(self, dt: float):
+        """
+        Called every frame.
+        Override for animations, logic, physics.
+        """
+        pass
+
+    # --------------------------------------------------
+    # Internal loop
+    # --------------------------------------------------
+    def _tick(self):
+        now = time.perf_counter()
+        dt = now - self._last_time
+        self._last_time = now
+        self.update(dt)
+
+    # --------------------------------------------------
+    # Run
+    # --------------------------------------------------
+    def run(self, fps: int = 60):
+        """
+        Start the application.
+        """
+        self.on_start()
+
+        interval_ms = int(1000 / max(1, fps))
+        self._timer.start(interval_ms)
+
+        if self.dev:
+            backend = "PySide6" if IS_ANDROID else "PyQt6"
+            platform = "Android" if is_android() else "Desktop"
+            print(f"[Kigo] Running on {platform} using {backend}")
+
+        return self.qt_app.exec()

kigo_gui_framework-2.6/kigo/gpu.py

@@ -0,0 +1,206 @@
+# SPDX-License-Identifier: Zlib
+# kigo/gpu.py
+
+from __future__ import annotations
+from typing import Any, Dict, Optional
+
+from kigo.qt import QtCore, QtWidgets
+
+# QtPy provides these modules when OpenGL is available
+try:
+    from qtpy import QtOpenGLWidgets, QtOpenGL, QtGui
+except Exception:
+    QtOpenGLWidgets = None
+    QtOpenGL = None
+    QtGui = None
+
+
+_VERTEX_GLSL_120 = r"""
+#version 120
+attribute vec2 a_pos;
+attribute vec2 a_uv;
+varying vec2 v_uv;
+
+void main() {
+    v_uv = a_uv;
+    gl_Position = vec4(a_pos.xy, 0.0, 1.0);
+}
+"""
+
+
+def _wrap_fragment_glsl_120(user_fragment: str) -> str:
+    """
+    Accepts your preset fragments (that use varying v_uv and gl_FragColor),
+    ensures they compile with GLSL 120 by NOT rewriting your code.
+    Requirement: user fragment must declare:
+        varying highp vec2 v_uv;  (or varying vec2 v_uv;)
+    and must write gl_FragColor.
+    """
+    s = (user_fragment or "").strip()
+    if not s:
+        # fallback shader (solid magenta)
+        return r"""
+        #version 120
+        varying vec2 v_uv;
+        uniform float time;
+        void main() { gl_FragColor = vec4(1.0, 0.0, 1.0, 1.0); }
+        """
+    if not s.startswith("#version"):
+        s = "#version 120\n" + s
+    return s
+
+
+class _GLShaderWidget(QtOpenGLWidgets.QOpenGLWidget):  # type: ignore
+    """
+    Internal OpenGL widget that renders a fullscreen quad using VBO+VAO.
+    """
+
+    def __init__(self, fragment_shader: str, parent=None):
+        super().__init__(parent)
+
+        # Prefer compatibility-style GLSL 120 so your existing presets compile
+        fmt = self.format()
+        fmt.setVersion(2, 1)
+        fmt.setProfile(fmt.OpenGLContextProfile.NoProfile)
+        self.setFormat(fmt)  # QOpenGLWidget supports setFormat [2](https://doc.qt.io/qtforpython-6.5/PySide6/QtOpenGLWidgets/QOpenGLWidget.html)
+
+        self._frag_src_user = fragment_shader
+        self._uniforms: Dict[str, Any] = {}
+
+        self._program = None
+        self._vao = None
+        self._vbo = None
+        self._gl = None
+
+        # attribute locations (cached)
+        self._loc_pos = -1
+        self._loc_uv = -1
+
+    def set_uniform(self, name: str, value: Any):
+        self._uniforms[name] = value
+        self.update()
+
+    def initializeGL(self):
+        # QOpenGLWidget makes the context current here [2](https://doc.qt.io/qtforpython-6.5/PySide6/QtOpenGLWidgets/QOpenGLWidget.html)[3](https://doc.qt.io/qt-6/qopenglwidget.html)
+        self._gl = self.context().functions()
+
+        # Create program
+        self._program = QtOpenGL.QOpenGLShaderProgram(self)  # [4](https://doc.qt.io/qt-6/qopenglshaderprogram.html)
+        ok_v = self._program.addShaderFromSourceCode(
+            QtOpenGL.QOpenGLShader.ShaderTypeBit.Vertex, _VERTEX_GLSL_120
+        )
+        frag_src = _wrap_fragment_glsl_120(self._frag_src_user)
+        ok_f = self._program.addShaderFromSourceCode(
+            QtOpenGL.QOpenGLShader.ShaderTypeBit.Fragment, frag_src
+        )
+
+        if not ok_v or not ok_f or not self._program.link():
+            # If shader fails, draw clear color only; keep app running
+            self._program = None
+            self._gl.glClearColor(0.2, 0.0, 0.2, 1.0)
+            return
+
+        self._program.bind()
+
+        # Attribute locations
+        self._loc_pos = self._program.attributeLocation("a_pos")
+        self._loc_uv = self._program.attributeLocation("a_uv")
+
+        # Fullscreen quad (triangle strip): 4 vertices
+        # a_pos(x,y), a_uv(u,v)
+        data = [
+            -1.0, -1.0,  0.0, 0.0,
+             1.0, -1.0,  1.0, 0.0,
+            -1.0,  1.0,  0.0, 1.0,
+             1.0,  1.0,  1.0, 1.0,
+        ]
+
+        # VAO (remembers VBO + attribute bindings) [5](https://wikis.khronos.org/opengl/Tutorial2:_VAOs,_VBOs,_Vertex_and_Fragment_Shaders_%28C_/_SDL%29)
+        self._vao = QtOpenGL.QOpenGLVertexArrayObject(self)
+        self._vao.create()
+        self._vao.bind()
+
+        # VBO (stores vertex data on GPU) [5](https://wikis.khronos.org/opengl/Tutorial2:_VAOs,_VBOs,_Vertex_and_Fragment_Shaders_%28C_/_SDL%29)
+        self._vbo = QtOpenGL.QOpenGLBuffer(QtOpenGL.QOpenGLBuffer.Type.VertexBuffer)
+        self._vbo.create()
+        self._vbo.bind()
+        self._vbo.setUsagePattern(QtOpenGL.QOpenGLBuffer.UsagePattern.StaticDraw)
+        self._vbo.allocate(bytes(bytearray(float(x).hex().encode() for x in [])))  # placeholder
+
+        # Qt buffer allocate wants bytes; easiest is to use QByteArray
+        arr = QtCore.QByteArray()
+        arr.resize(4 * 4 * 4)  # 4 vertices * 4 floats * 4 bytes
+        # write float32 into QByteArray
+        import struct
+        packed = struct.pack("<16f", *data)
+        for i, b in enumerate(packed):
+            arr[i] = b
+        self._vbo.allocate(arr)
+
+        stride = 4 * 4  # 4 floats per vertex
+
+        # Position attribute
+        self._program.enableAttributeArray(self._loc_pos)
+        self._program.setAttributeBuffer(self._loc_pos, QtOpenGL.GL_FLOAT, 0, 2, stride)
+
+        # UV attribute
+        self._program.enableAttributeArray(self._loc_uv)
+        self._program.setAttributeBuffer(self._loc_uv, QtOpenGL.GL_FLOAT, 2 * 4, 2, stride)
+
+        self._vbo.release()
+        self._vao.release()
+        self._program.release()
+
+        self._gl.glClearColor(0.0, 0.0, 0.0, 1.0)
+
+    def resizeGL(self, w: int, h: int):
+        if self._gl:
+            self._gl.glViewport(0, 0, w, h)
+
+    def paintGL(self):
+        if not self._gl:
+            return
+
+        self._gl.glClear(self._gl.GL_COLOR_BUFFER_BIT)
+
+        if not self._program or not self._vao:
+            return
+
+        self._program.bind()
+        self._vao.bind()
+
+        # Push uniforms
+        # (Only sets float/int; extend later if needed)
+        for k, v in self._uniforms.items():
+            try:
+                if isinstance(v, (int,)):
+                    self._program.setUniformValue(k, int(v))
+                else:
+                    self._program.setUniformValue(k, float(v))
+            except Exception:
+                pass
+
+        # Draw triangle strip quad
+        self._gl.glDrawArrays(self._gl.GL_TRIANGLE_STRIP, 0, 4)
+
+        self._vao.release()
+        self._program.release()
+
+
+class ShaderView:
+    """
+    Kigo-facing widget wrapper.
+    User code stays Kigo-style:
+        view = ShaderView(fragment_shader=shader)
+        view.set_uniform("time", t)
+    """
+
+    def __init__(self, fragment_shader: str):
+        if QtOpenGLWidgets is None or QtOpenGL is None:
+            raise RuntimeError("OpenGL backend not available")
+
+        self.qt_widget = _GLShaderWidget(fragment_shader)
+
+    def set_uniform(self, name: str, value: Any):
+        self.qt_widget.set_uniform(name, value)
+

kigo_gui_framework-2.6/kigo/shader_demo.py

@@ -0,0 +1,23 @@
+from kigo.app import App
+from kigo.ui import Window
+from kigo.gpu import ShaderView
+
+# choose ONE shader (fire/water presets from your page)
+shader = fire
+# shader = water
+
+class Demo(App):
+    def on_start(self):
+        self.main_window = Window(title="Kigo VBO Shader Demo", size=(600, 400))
+        self.view = ShaderView(fragment_shader=shader)
+        self.main_window.set_content(self.view)
+        self.main_window.show()
+
+        self.t = 0.0
+        self.schedule(self.update)
+
+    def update(self, dt):
+        self.t += dt
+        self.view.set_uniform("time", self.t)
+
+Demo(dev=True).run()

{kigo_gui_framework-2.4 → kigo_gui_framework-2.6}/kigo_gui_framework.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: kigo-gui-framework
-Version: 2.4
-Summary: Added WASM and HUD (HUD executed by F2) check out the website- https://kigo-the-best-gui-framework.netlify.app
+Version: 2.6
+Summary: Added Android support, smoke shader and ECS. Note that Kigo does NOT COME WITH ANY MALWARE, IF YOU SPOT IT PLEASE EMAIL bot28482@gmail.com
 Author-email: "Anand Kumar, Utkarsh Raghav Roy" <swiss.armyknife@icloud.com>
 License: zlib
 Keywords: gui,qt,pyqt6,physics,pybullet,simulation,robotics,animation
@@ -16,12 +16,11 @@ Requires-Dist: PyQt6==6.7.0
 Requires-Dist: pybullet>=3.2.5
 Requires-Dist: pybullet_data
 Requires-Dist: wasmtime>=25.0.0
+Requires-Dist: pyopengl>=3.1.10
 Provides-Extra: web
 Requires-Dist: PyQt6-WebEngine==6.7.0; extra == "web"
 Provides-Extra: full
 Requires-Dist: markdown; extra == "full"
 Requires-Dist: PyQt6-WebEngine==6.7.0; extra == "full"
 
-Asset Caching
-Kigo introduces asset caching. What it does is keep things in memory so that if your app needs them it can access that thing much faster. Also I passed
-in the exam and am going to class five pray for me plz
+Kigo now has Android support (experimental), ECS and a smoke shader. 

{kigo_gui_framework-2.4 → kigo_gui_framework-2.6}/kigo_gui_framework.egg-info/SOURCES.txt

@@ -7,13 +7,15 @@ kigo/accelerate.py
 kigo/app.py
 kigo/fx_gl2d.py
 kigo/fx_quick.py
+kigo/gpu.py
 kigo/hud.py
 kigo/hwaccel.py
 kigo/media.py
 kigo/physics.py
 kigo/physics_policy.py
-kigo/qt.py
 kigo/runtime.py
+kigo/shader_demo.py
+kigo/shim.py
 kigo/skins.py
 kigo/style.py
 kigo/tree.py

{kigo_gui_framework-2.4 → kigo_gui_framework-2.6}/kigo_gui_framework.egg-info/requires.txt

@@ -2,6 +2,7 @@ PyQt6==6.7.0
 pybullet>=3.2.5
 pybullet_data
 wasmtime>=25.0.0
+pyopengl>=3.1.10
 
 [full]
 markdown

{kigo_gui_framework-2.4 → kigo_gui_framework-2.6}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "kigo-gui-framework"
-version = "2.4"
-description = "Added WASM and HUD (HUD executed by F2) check out the website- https://kigo-the-best-gui-framework.netlify.app"
+version = "2.6"
+description = "Added Android support, smoke shader and ECS. Note that Kigo does NOT COME WITH ANY MALWARE, IF YOU SPOT IT PLEASE EMAIL bot28482@gmail.com"
 readme = "README.txt"
 requires-python = ">=3.8"
 license = { text = "zlib" }
@@ -37,9 +37,9 @@ dependencies = [
     "PyQt6==6.7.0",
     "pybullet>=3.2.5",
     "pybullet_data",
-    "wasmtime>=25.0.0"
+    "wasmtime>=25.0.0",
+    "pyopengl>=3.1.10",
 ]
-
 [project.optional-dependencies]
 web = ["PyQt6-WebEngine==6.7.0"]
 full = ["markdown", "PyQt6-WebEngine==6.7.0"]

kigo_gui_framework-2.4/README.txt

@@ -1,3 +0,0 @@
-Asset Caching
-Kigo introduces asset caching. What it does is keep things in memory so that if your app needs them it can access that thing much faster. Also I passed
-in the exam and am going to class five pray for me plz

kigo_gui_framework-2.4/kigo/app.py

@@ -1,409 +0,0 @@
-# SPDX-License-Identifier: Zlib
-# kigo/app.py — Core Kigo App with Studio (Esc), HUD (F2), and Python/WASM modes.
-
-from __future__ import annotations
-
-import sys
-from dataclasses import dataclass
-from typing import Any, Dict, Optional
-
-from kigo.qt import QtWidgets, QtCore, QtGui
-
-
-# =====================================================
-# Runtime state
-# =====================================================
-
-class Runtime:
-    def __init__(self, mode: str = "python"):
-        if mode is None:
-            mode = "python"
-        mode = str(mode).strip().lower()
-
-        if mode not in ("python", "wasm"):
-            raise ValueError("mode must be 'python' or 'wasm'")
-
-        self.mode = mode
-
-        # Counters for HUD
-        self.python_calls = 0
-        self.wasm_calls = 0
-        self.wasm_hits = 0
-        self.wasm_fallbacks = 0
-
-        # Capability flags
-        self.wasm_available = False
-        self.wasm_reason = ""
-
-    def is_wasm(self) -> bool:
-        return self.mode == "wasm"
-
-
-# =====================================================
-# Hot-path marker
-# =====================================================
-
-def hot(*, wasm: Optional[str] = None, module: str = "default"):
-    """
-    Marks a function as eligible for WASM acceleration.
-
-    Example:
-        @hot(wasm="mul42", module="math")
-        def heavy(x: int) -> int:
-            return x * 42
-    """
-    def decorate(fn):
-        fn.__kigo_hot__ = True
-        fn.__kigo_wasm_export__ = wasm or fn.__name__
-        fn.__kigo_wasm_module__ = module
-        return fn
-    return decorate
-
-
-# =====================================================
-# WASM Executor (Wasmtime)
-# =====================================================
-
-@dataclass
-class _WasmHandle:
-    store: Any
-    exports: Dict[str, Any]
-
-
-class WasmExecutor:
-    """
-    Loads WASM modules from a registry and calls exported functions.
-
-    Supports:
-      - WAT source (string starting with "(module")
-      - file path to .wasm
-    """
-
-    def __init__(self, runtime: Runtime):
-        self.runtime = runtime
-        self._mods: Dict[str, _WasmHandle] = {}
-        self._enabled = False
-
-        try:
-            from wasmtime import Store, Module, Instance
-            self._Store = Store
-            self._Module = Module
-            self._Instance = Instance
-            self._enabled = True
-            self.runtime.wasm_available = True
-        except Exception as e:
-            # Honest fallback: no wasmtime, no wasm mode.
-            self.runtime.wasm_available = False
-            self.runtime.wasm_reason = f"wasmtime not available: {e}"
-            self._enabled = False
-
-    def enabled(self) -> bool:
-        return self._enabled
-
-    def load_registry(self, registry: Dict[str, Any]) -> None:
-        if not self._enabled:
-            return
-
-        for name, spec in (registry or {}).items():
-            try:
-                self._load_one(name, spec)
-            except Exception as e:
-                # Don’t crash app: just mark wasm as partially available
-                self.runtime.wasm_reason = f"module '{name}' failed: {e}"
-
-    def _load_one(self, name: str, spec: Any) -> None:
-        store = self._Store()
-
-        # Allow either raw WAT string or a dict {"wat": "..."} / {"file": "..."}
-        wat_src = None
-        file_path = None
-
-        if isinstance(spec, str):
-            s = spec.lstrip()
-            if s.startswith("(module"):
-                wat_src = spec
-            else:
-                file_path = spec
-        elif isinstance(spec, dict):
-            if "wat" in spec:
-                wat_src = spec["wat"]
-            elif "file" in spec:
-                file_path = spec["file"]
-            else:
-                raise ValueError("invalid module spec dict; use {'wat': ...} or {'file': ...}")
-        else:
-            raise ValueError("invalid module spec; use WAT string, wasm file path, or dict spec")
-
-        if wat_src is not None:
-            module = self._Module(store.engine, wat_src)
-        else:
-            module = self._Module.from_file(store.engine, file_path)
-
-        instance = self._Instance(store, module, [])
-        exports = instance.exports(store)
-
-        self._mods[str(name)] = _WasmHandle(store=store, exports=exports)
-
-    def has_export(self, module: str, export: str) -> bool:
-        if not self._enabled:
-            return False
-        h = self._mods.get(module)
-        return bool(h and export in h.exports)
-
-    def call(self, module: str, export: str, *args):
-        self.runtime.wasm_calls += 1
-        h = self._mods[module]
-        fn = h.exports[export]
-        return fn(h.store, *args)
-
-
-# =====================================================
-# Live HUD (F2 toggled, top-right)
-# =====================================================
-
-class LiveHUD(QtWidgets.QWidget):
-    def __init__(self, runtime: Runtime, parent=None):
-        super().__init__(parent)
-        self.runtime = runtime
-
-        self.setFixedSize(240, 130)
-        self.setAttribute(QtCore.Qt.WidgetAttribute.WA_TransparentForMouseEvents, True)
-
-        self.setStyleSheet("""
-            background: rgba(0, 0, 0, 160);
-            color: #00ffcc;
-            font-family: Consolas;
-            font-size: 11px;
-            border-radius: 6px;
-        """)
-
-        self.label = QtWidgets.QLabel(self)
-        self.label.setGeometry(10, 8, 220, 114)
-
-        self.timer = QtCore.QTimer(self)
-        self.timer.timeout.connect(self.refresh)
-        self.timer.start(250)
-
-        self.hide()
-
-    def attach_to(self, window: QtWidgets.QWidget):
-        self.setParent(window)
-        self.reposition()
-        window.installEventFilter(self)
-
-    def eventFilter(self, obj, event):
-        if event.type() == QtCore.QEvent.Type.Resize:
-            self.reposition()
-        return False
-
-    def reposition(self):
-        if not self.parent():
-            return
-        r = self.parent().rect()
-        self.move(r.width() - self.width() - 10, 10)
-
-    def refresh(self):
-        total = self.runtime.wasm_hits + self.runtime.wasm_fallbacks
-        hit_pct = (self.runtime.wasm_hits * 100.0 / total) if total else 0.0
-
-        wasm_state = "OK" if self.runtime.wasm_available else "OFF"
-        if self.runtime.is_wasm() and not self.runtime.wasm_available:
-            wasm_state = "FALLBACK"
-
-        self.label.setText(
-            "KIGO HUD\n"
-            "────────────\n"
-            f"Mode: {self.runtime.mode.upper()}\n"
-            f"WASM: {wasm_state}\n"
-            f"WASM hits: {self.runtime.wasm_hits} ({hit_pct:.0f}%)\n"
-            f"WASM fallbacks: {self.runtime.wasm_fallbacks}\n"
-            f"Python calls: {self.runtime.python_calls}\n"
-            f"WASM calls: {self.runtime.wasm_calls}"
-        )
-
-
-# =====================================================
-# Studio overlay (Esc toggled) — dev only
-# =====================================================
-
-class StudioOverlay(QtWidgets.QWidget):
-    def __init__(self, parent=None):
-        super().__init__(parent)
-
-        self.setWindowFlags(
-            QtCore.Qt.WindowType.Tool |
-            QtCore.Qt.WindowType.FramelessWindowHint |
-            QtCore.Qt.WindowType.WindowStaysOnTopHint
-        )
-        self.setAttribute(QtCore.Qt.WidgetAttribute.WA_TranslucentBackground, True)
-
-        self.setStyleSheet("""
-            QWidget {
-                background-color: rgba(15, 15, 15, 215);
-                color: #e0e0e0;
-                font-family: Consolas, monospace;
-            }
-        """)
-
-        layout = QtWidgets.QVBoxLayout(self)
-        layout.setContentsMargins(24, 24, 24, 24)
-        layout.setSpacing(12)
-
-        title = QtWidgets.QLabel("Kigo Studio")
-        title.setStyleSheet("font-size: 20px; font-weight: bold;")
-
-        hint = QtWidgets.QLabel(
-            "Esc — toggle Studio\n"
-            "F2 — toggle HUD\n"
-            "Inspector panels coming soon"
-        )
-
-        layout.addWidget(title)
-        layout.addWidget(hint)
-        layout.addStretch(1)
-
-    def showEvent(self, e):
-        if self.parent():
-            self.setGeometry(self.parent().rect())
-        super().showEvent(e)
-
-
-class StudioController(QtCore.QObject):
-    def __init__(self, app: QtWidgets.QApplication, overlay: StudioOverlay):
-        super().__init__()
-        self.overlay = overlay
-        app.installEventFilter(self)
-
-    def eventFilter(self, obj, event):
-        if event.type() == QtCore.QEvent.Type.KeyPress:
-            if event.key() == QtCore.Qt.Key.Key_Escape:
-                self.toggle()
-                return True
-        return False
-
-    def toggle(self):
-        if self.overlay.isVisible():
-            self.overlay.hide()
-        else:
-            self.overlay.show()
-            self.overlay.raise_()
-
-
-# =====================================================
-# Core App
-# =====================================================
-
-class App:
-    """
-    Core Kigo application.
-
-    - mode: "python" (default) or "wasm"
-    - F2 toggles HUD
-    - Esc toggles Studio (only if studio=True)
-    """
-
-    def __init__(self, *, mode: str = "python", dev: bool = False, studio: bool = False):
-        self.runtime = Runtime(mode)
-        self.dev = bool(dev)
-        self.studio = bool(studio)
-
-        self.qt_app = QtWidgets.QApplication(sys.argv)
-
-        self.main_window: Optional[QtWidgets.QWidget] = None
-
-        # WASM executor (real if wasmtime present)
-        self.wasm = WasmExecutor(self.runtime) if self.runtime.is_wasm() else None
-
-        # If wasm mode requested but not available -> honest fallback
-        if self.runtime.is_wasm() and (not self.wasm or not self.wasm.enabled()):
-            self.runtime.mode = "python"
-
-        # Load wasm module registry if in wasm mode and runtime available
-        if self.runtime.is_wasm() and self.wasm and self.wasm.enabled():
-            try:
-                from kigo.wasm.module import WASM_MODULES
-            except Exception:
-                WASM_MODULES = {}
-                self.runtime.wasm_reason = "WASM registry not found"
-            self.wasm.load_registry(WASM_MODULES)
-
-        self.hud: Optional[LiveHUD] = None
-        self._hud_shortcut = None
-
-        self._studio_overlay: Optional[StudioOverlay] = None
-        self._studio_controller: Optional[StudioController] = None
-
-    # -----------------------------
-    # Unified execution path
-    # -----------------------------
-    def call(self, fn, *args):
-        # Try WASM only for hot functions
-        if getattr(fn, "__kigo_hot__", False) and self.runtime.is_wasm() and self.wasm:
-            mod = getattr(fn, "__kigo_wasm_module__", "default")
-            exp = getattr(fn, "__kigo_wasm_export__", fn.__name__)
-
-            if self.wasm.has_export(mod, exp):
-                self.runtime.wasm_hits += 1
-                return self.wasm.call(mod, exp, *args)
-
-            # wasm mode but export missing => fallback
-            self.runtime.wasm_fallbacks += 1
-            self.runtime.python_calls += 1
-            return fn(*args)
-
-        # Normal python path
-        self.runtime.python_calls += 1
-        return fn(*args)
-
-    # -----------------------------
-    # App lifecycle
-    # -----------------------------
-    def run(self):
-        self.on_start()
-
-        if self.dev:
-            self._attach_hud()
-
-        if self.dev and self.studio:
-            self._attach_studio()
-
-        sys.exit(self.qt_app.exec())
-
-    def on_start(self):
-        """
-        Override in user app. Must set self.main_window and show it.
-        """
-        raise NotImplementedError("on_start() not implemented")
-
-    # -----------------------------
-    # HUD wiring (F2 toggle)
-    # -----------------------------
-    def _attach_hud(self):
-        if not self.main_window:
-            raise RuntimeError("main_window not set")
-
-        self.hud = LiveHUD(self.runtime, parent=self.main_window)
-        self.hud.attach_to(self.main_window)
-
-        self._hud_shortcut = QtWidgets.QShortcut(QtGui.QKeySequence("F2"), self.main_window)
-        self._hud_shortcut.setContext(QtCore.Qt.ShortcutContext.ApplicationShortcut)
-        self._hud_shortcut.activated.connect(self._toggle_hud)
-
-    def _toggle_hud(self):
-        if not self.hud:
-            return
-        if self.hud.isVisible():
-            self.hud.hide()
-        else:
-            self.hud.show()
-            self.hud.raise_()
-
-    # -----------------------------
-    # Studio wiring (Esc toggle)
-    # -----------------------------
-    def _attach_studio(self):
-        if not self.main_window:
-            raise RuntimeError("main_window not set")
-
-        self._studio_overlay = StudioOverlay(parent=self.main_window)
-        self._studio_controller = StudioController(self.qt_app, self._studio_overlay)