meltygui 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

meltygui/core/cache/mask_batch.py

@@ -92,6 +92,7 @@ def batches(stamps):
 class MaskBatch:
     def __init__(self):
         self.program = self.vao = self.vbo = None
+        self.flat_texture = None
         self.source = None
         self.multi_bind = False
         self.fb_location = self.textures_location = None
@@ -103,6 +104,9 @@ class MaskBatch:
             gl.glDeleteBuffers(1, [self.vbo])
         if self.vao is not None:
             gl.glDeleteVertexArrays(1, [self.vao])
+        if getattr(self, 'flat_texture', None) is not None:
+            gl.glDeleteTextures([self.flat_texture])
+        self.flat_texture = None
         self.program = self.vao = self.vbo = None
         self.source = None
 
@@ -155,10 +159,18 @@ class MaskBatch:
                 gl.glBufferData(gl.GL_ARRAY_BUFFER, len(data), data, gl.GL_STREAM_DRAW)
             first_instance = 0
             for textures, data, count in packed:
-                # Populate unused slots with a valid source, avoiding feedback
-                # from a texture attached to the current framebuffer. Zero is
-                # bound to GL_TEXTURE_2D explicitly (bulk zero unbinds ALL targets).
-                bank = textures + [textures[0]] * (TEXTURES_PER_BATCH - len(textures)) if textures else [0] * TEXTURES_PER_BATCH
+                # Apple requires complete samplers even for the flat branch.
+                # Own a tiny source for that case; never sample the destination.
+                if not textures and self.flat_texture is None:
+                    self.flat_texture = int(gl.glGenTextures(1))
+                    gl.glActiveTexture(gl.GL_TEXTURE0)
+                    gl.glBindTexture(gl.GL_TEXTURE_2D, self.flat_texture)
+                    gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MIN_FILTER, gl.GL_NEAREST)
+                    gl.glTexParameteri(gl.GL_TEXTURE_2D, gl.GL_TEXTURE_MAG_FILTER, gl.GL_NEAREST)
+                    gl.glTexImage2D(gl.GL_TEXTURE_2D, 0, gl.GL_RGBA8, 1, 1, 0,
+                                    gl.GL_RGBA, gl.GL_UNSIGNED_BYTE, bytes(4))
+                bank = (textures + [textures[0]] * (TEXTURES_PER_BATCH - len(textures))
+                        if textures else [self.flat_texture] * TEXTURES_PER_BATCH)
                 if self.multi_bind and textures:
                     gl.glBindTextures(0, TEXTURES_PER_BATCH, bank)
                 else:

meltygui/core/cache/tile_cache.py

@@ -130,6 +130,19 @@ def _tile_alloc(t) -> Tuple[int, int]:
     return getattr(t, "alloc_size", None) or t.size
 
 
+def _pixel_rect(rect, scale):
+    """Window-point bounds to integer texel bounds, including fractional DPI."""
+    x, y, w, h = rect
+    sx, sy = scale
+    left, bottom = snap_int(x * sx), snap_int(y * sy)
+    return left, bottom, snap_int((x + w) * sx) - left, snap_int((y + h) * sy) - bottom
+
+
+def _tile_pixel_size(tile, *, allocated=False):
+    size = _tile_alloc(tile) if allocated else tile.size
+    return _pixel_rect((0, 0, *size), tile.pixel_scale)[2:]
+
+
 def _tile_uv_rect(t) -> Tuple[float, float, float, float]:
     """uUVRect (xy scale, zw offset) mapping a 0..1 dest-rect UV onto the
     top-anchored logical subrect of a bucket-padded tile texture."""
@@ -150,7 +163,8 @@ class Tile:
     mask_tex: int  # Cached subtree mask for this tile
     rbo: Optional[int]
     size: Tuple[int, int]  # LOGICAL view size; the texture may be larger (alloc_size)
-    alloc_size: Optional[Tuple[int, int]] = None  # bucketed texture dims, None = same as size
+    alloc_size: Optional[Tuple[int, int]] = None  # bucketed window-point dims, None = same as size
+    pixel_scale: Tuple[float, float] = (1.0, 1.0)  # physical texels per window point
     dirty: bool = True
     last_clean_frame: int = -1
     last_invalidated_frame: int = 3
@@ -364,7 +378,8 @@ def _clear_mask_regions(mask_tex: int, rects) -> None:
         gl.glClear(gl.GL_COLOR_BUFFER_BIT)
 
 
-def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, draw_state=None, tile_id=None) -> \
+def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, draw_state=None, tile_id=None,
+                 pixel_scale=(1.0, 1.0)) -> \
         Optional[Tile]:
     # Layout occasionally hands us fractional or negative dims (e.g. a
     # midline is 0.333... width). glTexImage2D coerces those to int and lands on
@@ -374,7 +389,8 @@ def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, dr
     h = int(h) if h and h > 0 else 0
     if w <= 0 or h <= 0:
         return None
-    if existing and existing.size == (w, h):
+    same_scale = existing is not None and existing.pixel_scale == pixel_scale
+    if same_scale and existing.size == (w, h):
         return existing
 
     aw = _bucket(w)
@@ -390,7 +406,7 @@ def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, dr
         aw = max(aw, snap_int(eaw))
         ah = max(ah, snap_int(eah))
 
-    if existing and _tile_alloc(existing) == (aw, ah):
+    if same_scale and _tile_alloc(existing) == (aw, ah):
         # Same bucket: update the logical size in place - no GL realloc, no
         # crop-blit (top-anchored content keeps the screen-top-left corner on
         # the same texels). Returning the SAME object is the caller's signal
@@ -424,6 +440,7 @@ def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, dr
                 # one) would leave stale G/B/A inside the new logical rect.
                 gl.glColorMask(gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE)
                 gl.glClearColor(0, 0, 0, 0.0)
+                bands = [_pixel_rect(rect, pixel_scale) for rect in bands]
                 for x, y, cw, ch in bands:
                     gl.glScissor(int(x), int(y), int(cw), int(ch))
                     gl.glClear(gl.GL_COLOR_BUFFER_BIT)
@@ -480,7 +497,8 @@ def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, dr
     except Exception:
         pass
     try:
-        new_tex = _create_color_tex(aw, ah)
+        pixel_aw, pixel_ah = _pixel_rect((0, 0, aw, ah), pixel_scale)[2:]
+        new_tex = _create_color_tex(pixel_aw, pixel_ah)
     except Exception as e:
         existing_size = existing.size if existing else None
         reset = "\033[0m"
@@ -490,13 +508,13 @@ def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, dr
               f"\nCurrent size {existing_size}\n{'=' * 10}{reset}")
         return None
 
-    new_mask_tex = _create_mask_tex(aw, ah)
+    new_mask_tex = _create_mask_tex(pixel_aw, pixel_ah)
     # No depth-stencil renderbuffer: tiles are only ever written by the PASS 3
     # copy shader and the crop-blit, neither of which depth/stencil-tests, and
     # the D24S8 attachment was 4 B/px of VRAM plus the slowest part of the
     # create/destroy/delete cycle. Tile.rbo stays None; the guarded delete
     # sites will free RBOs on tiles created before this change.
-    new_fbo, new_rbo = _create_fbo_with_tex(new_tex, False, aw, ah)
+    new_fbo, new_rbo = _create_fbo_with_tex(new_tex, False, pixel_aw, pixel_ah)
 
     if existing:
         st = _GLState()
@@ -533,13 +551,15 @@ def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, dr
                 cw = max(0, min(ow, w))
                 ch = max(0, min(oh, h))
             if cw > 0 and ch > 0:
+                src_x, src_y, src_w, src_h = _pixel_rect((0, old_ah - ch, cw, ch), existing.pixel_scale)
+                dst_x, dst_y, dst_w, dst_h = _pixel_rect((0, ah - ch, cw, ch), pixel_scale)
                 gl.glBlitFramebuffer(
-                    0, snap_int(old_ah) - ch, cw, snap_int(old_ah),  # src (old FBO, top-left in screen)
-                    0, ah - ch, cw, ah,  # dst (new FBO, same screen corner)
+                    src_x, src_y, src_x + src_w, src_y + src_h,
+                    dst_x, dst_y, dst_x + dst_w, dst_y + dst_h,
                     gl.GL_COLOR_BUFFER_BIT,
                     gl.GL_NEAREST,  # No scaling -> NEAREST is exact and cheap
                 )
-            _clear_mask_regions(new_mask_tex, [(0, 0, aw, ah)])
+            _clear_mask_regions(new_mask_tex, [(0, 0, pixel_aw, pixel_ah)])
         finally:
             st.restore()
 
@@ -562,12 +582,12 @@ def _ensure_tile(existing: Optional[Tile], w: int, h: int, frame_id: int = 0, dr
                 gl.glColorMask(gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE)
                 gl.glClearColor(0, 0, 0, 0.0)
                 gl.glClear(gl.GL_COLOR_BUFFER_BIT)
-                _clear_mask_regions(new_mask_tex, [(0, 0, aw, ah)])
+                _clear_mask_regions(new_mask_tex, [(0, 0, pixel_aw, pixel_ah)])
             finally:
                 st.restore()
 
     t = Tile(draw_state=draw_state, fbo=new_fbo, tex=new_tex, mask_tex=new_mask_tex, rbo=new_rbo, size=(w, h),
-             alloc_size=(aw, ah), dirty=True)
+             alloc_size=(aw, ah), pixel_scale=pixel_scale, dirty=True)
     # Seed filled_bbox to what the crop-copy above covered (in tile-local
     # top-left coords). On a shrink it's the whole tile -> tile reads are fully
     # covered and the scroll-invalidate gate stops early; on a grow it's
@@ -1194,6 +1214,9 @@ void main() { oColor = uColor; }
 # Main class
 # ==============================
 class TileCacheMasked:
+    # Existing live caches acquire per-window backing scale on their next
+    # frame after a hotswap; unscaled caches retain their previous behavior.
+    _pixel_scale = (1.0, 1.0)
     def __init__(self):
         self.initial_value = {}
         self.did_deviate = {}
@@ -1260,6 +1283,7 @@ class TileCacheMasked:
         self.all_keys = set()
 
         self._fb_size: Tuple[int, int] = (0, 0)
+        self._pixel_scale = (1.0, 1.0)
         # Allocated dims of the four co-sized internal surfaces (_mask,
         # _sub_mask, _full_sub_mask, snapshot). For monitor only, grow-only.
         # _fb_size stays the LOGICAL framebuffer size everywhere.
@@ -1537,10 +1561,10 @@ class TileCacheMasked:
         fl, ft, fr, fb = t.filled_bbox
         return fl > vl + 0.5 or ft > vt + 0.5 or fr < vr - 0.5 or fb < vb - 0.5
 
-    @staticmethod
-    def _oversized(size: Optional[Tuple[int, int]]) -> bool:
+    def _oversized(self, size: Optional[Tuple[int, int]]) -> bool:
         """True if a view this size is too large to back with an offscreen tile."""
-        return size is not None and (size[0] > MAX_TILE_DIM or size[1] > MAX_TILE_DIM)
+        return size is not None and (size[0] * self._pixel_scale[0] > MAX_TILE_DIM
+                                     or size[1] * self._pixel_scale[1] > MAX_TILE_DIM)
 
     def _discard_tile(self, key: str) -> None:
         """Drop a tile and free its GL resources (e.g. a view grew too large to cache)."""
@@ -2245,8 +2269,13 @@ class TileCacheMasked:
                     key = self.key_to_parent_key.get(key)
         self._resize_input_keys = keys
 
-    def mask_begin_frame(self, framebuffer_size: Tuple[int, int]) -> None:
+    def mask_begin_frame(self, framebuffer_size: Tuple[int, int], pixel_scale=None) -> None:
         fb_w, fb_h = map(int, framebuffer_size)
+        if pixel_scale is not None and tuple(pixel_scale) != getattr(self, '_pixel_scale', (1.0, 1.0)):
+            self._pixel_scale = tuple(pixel_scale)
+            # A move between displays changes the backing resolution once.
+            # Wake cached ancestors as well as leaves so every tile recaptures.
+            self.invalidate_all(other_windows=False)
         self._note_frame_stats()
         self._refresh_resize_input_keys()
         self._frame_id += 1
@@ -3186,7 +3215,7 @@ class TileCacheMasked:
                     (ix0, iy0, ix1 - ix0, iy1 - iy0),
                     (d_and_l[0] * rank_scale, d_and_l[1] * rank_scale,
                      d_and_l[2] * rank_scale, d_and_l[3] * rank_scale,
-                     cr if cr > 0 else 0.0, margin))
+                     max(0.0, cr) * s_x, margin * s_x))
             _, ix0, iy0, ix1, iy1, own_clip, _owner, inset, rect4, tail6 = base
             if ix1 <= ix0 or iy1 <= iy0:
                 continue
@@ -3222,8 +3251,9 @@ class TileCacheMasked:
             gl.glUseProgram(self._prog_shadow_batch)
             _win_tex = getattr(self, "_win_mask_tex", None)
             gl.glActiveTexture(gl.GL_TEXTURE1)
-            gl.glBindTexture(gl.GL_TEXTURE_2D,
-                             _win_tex if (win_gate and _win_tex) else 0)
+            # WinZ=1 disables occlusion for tile bakes. The sampler still
+            # needs a complete texture on Apple even when that branch is off.
+            gl.glBindTexture(gl.GL_TEXTURE_2D, _win_tex or 0)
             gl.glActiveTexture(gl.GL_TEXTURE0)
             gl.glUniform1i(self._loc_sb_uWinMask, 1)
             gl.glUniform2f(self._loc_sb_uFBSize,
@@ -3313,8 +3343,7 @@ class TileCacheMasked:
         gl.glUseProgram(self._prog_shadow_grad)
         _win_tex = getattr(self, "_win_mask_tex", None)
         gl.glActiveTexture(gl.GL_TEXTURE1)
-        gl.glBindTexture(gl.GL_TEXTURE_2D,
-                         _win_tex if (win_gate and _win_tex) else 0)
+        gl.glBindTexture(gl.GL_TEXTURE_2D, _win_tex or 0)
         gl.glActiveTexture(gl.GL_TEXTURE0)
         gl.glUniform1i(self._loc_sg_uWinMask, 1)
         _fbw, _fbh = self._fb_size
@@ -3431,8 +3460,8 @@ class TileCacheMasked:
                            float(d_and_l[2]) / 65535.5,
                            float(d_and_l[3]) / 65535.5)
             gl.glUniform2f(self._loc_sg_uRectSize, float(iw), float(ih))
-            gl.glUniform1f(self._loc_sg_uCornerRadius, max(0.0, cr))
-            gl.glUniform1f(self._loc_sg_uMargin, margin)
+            gl.glUniform1f(self._loc_sg_uCornerRadius, max(0.0, cr) * s_x)
+            gl.glUniform1f(self._loc_sg_uMargin, margin * s_x)
             gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)
         gl.glDisable(gl.GL_SCISSOR_TEST)
         gl.glBlendEquation(gl.GL_FUNC_ADD)
@@ -3505,7 +3534,7 @@ class TileCacheMasked:
             gl.glUniform2f(self._loc_maskr_uRectSize, float(iw), float(ih))
             gl.glUniform1f(self._loc_maskr_uCornerRadius,
                            max(0.0, float(getattr(wds, "corner_radius", 6.0)
-                                          or 0.0)))
+                                          or 0.0)) * s_x)
             gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)
         gl.glColorMask(gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE, gl.GL_TRUE)
 
@@ -3726,10 +3755,10 @@ class TileCacheMasked:
         right texels, and fb_h is the REAL height for the y flip."""
         dd = imgui.get_draw_data()
         dp_x, dp_y = dd.display_pos
-        s_x, s_y = 1, 1
+        s_x, s_y = imgui.get_io().display_fb_scale
         ox, oy = getattr(Melty, "frame_origin", None) or (0, 0)
-        dp_x -= int(ox)
-        dp_y -= int(oy)
+        dp_x -= int(ox) / s_x
+        dp_y -= int(oy) / s_y
         real = getattr(Melty, "framebuffer_size", None)
         if real:
             fb_w, fb_h = snap_int(real[0]), snap_int(real[1])
@@ -3841,7 +3870,8 @@ class TileCacheMasked:
         if key in getattr(self, '_resize_input_keys', ()):
             return False
         tile = self._tiles.get(key)
-        if tile is None or not tile.tex or tile.last_clean_frame < 0:
+        if (tile is None or not tile.tex or tile.last_clean_frame < 0
+                or tile.pixel_scale != self._pixel_scale):
             return False
         if key in self._frozen_served:
             return True
@@ -4149,6 +4179,7 @@ class TileCacheMasked:
             bands.append((0, ah - ch, cw, ch - h))
         if cw > w:  # right band: screen cols [w, cw), full content height
             bands.append((w, ah - ch, cw - w, ch))
+        bands = [_pixel_rect(rect, t.pixel_scale) for rect in bands]
         st = _GLState()
         try:
             gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, t.fbo)
@@ -4257,6 +4288,7 @@ class TileCacheMasked:
             if t is not None and getattr(t, 'content_stale', False):
                 self._scrub_stale_content(t, draw_state)
             use_image = (t and has_area
+                         and t.pixel_scale == self._pixel_scale
                          and (t.size == (size[0], size[1]))
                          and (not self._is_dirty(t))
                          and (not draw_state.size_change))
@@ -4276,6 +4308,7 @@ class TileCacheMasked:
             dragging = Melty.resize_gesture_live()
             frozen = False
             if (draw_state.freeze_resize and t is not None and has_area and dragging
+                    and t.pixel_scale == self._pixel_scale
                     and rkey not in getattr(self, '_resize_input_keys', ())
                     and (t.size != (size[0], size[1])
                          or Melty.resize_press_frame == Melty.frame_count
@@ -4600,7 +4633,8 @@ class TileCacheMasked:
                     and not imgui.is_mouse_down(1) and not imgui.is_mouse_down(2)
                     and not Melty.space_mouse_drag):
                 old_t = t
-                t = _ensure_tile(t, ctx.size[0], ctx.size[1], frame_id=self._frame_id, draw_state=ctx.draw_state)
+                t = _ensure_tile(t, ctx.size[0], ctx.size[1], frame_id=self._frame_id,
+                                 draw_state=ctx.draw_state, pixel_scale=self._pixel_scale)
 
                 if t is not None and t is old_t:
                     # Within-bucket logical resize: the tile was updated in
@@ -4854,8 +4888,8 @@ class TileCacheMasked:
             gl.glUseProgram(self._prog_mask_rounded)
             gl.glUniform1f(self._loc_maskr_uRankNorm, rank_norm)
             gl.glUniform2f(self._loc_maskr_uRectSize, float(iw), float(ih))
-            gl.glUniform1f(self._loc_maskr_uCornerRadius, r.corner_radius)
-            gl.glUniform1f(self._loc_maskr_uMargin, shadow_margin)
+            gl.glUniform1f(self._loc_maskr_uCornerRadius, r.corner_radius * s_x)
+            gl.glUniform1f(self._loc_maskr_uMargin, shadow_margin * s_x)
 
         else:
             gl.glUseProgram(self._prog_mask)
@@ -4920,15 +4954,15 @@ class TileCacheMasked:
             gl.glBindTexture(gl.GL_TEXTURE_2D, t.mask_tex)
             gl.glUniform1i(self._loc_texr_uTex, 0)
             gl.glUniform2f(self._loc_texr_uRectSize, float(iw), float(ih))
-            gl.glUniform1f(self._loc_texr_uCornerRadius, r.corner_radius)
-            gl.glUniform1f(self._loc_texr_uMargin, shadow_margin)
+            gl.glUniform1f(self._loc_texr_uCornerRadius, r.corner_radius * s_x)
+            gl.glUniform1f(self._loc_texr_uMargin, shadow_margin * s_x)
 
         else:
             gl.glUseProgram(self._prog_mask_rounded)
             gl.glUniform1f(self._loc_maskr_uRankNorm, float(r.layer) * INV_65535)
             gl.glUniform2f(self._loc_maskr_uRectSize, float(iw), float(ih))
-            gl.glUniform1f(self._loc_maskr_uCornerRadius, r.corner_radius)
-            gl.glUniform1f(self._loc_maskr_uMargin, shadow_margin)
+            gl.glUniform1f(self._loc_maskr_uCornerRadius, r.corner_radius * s_x)
+            gl.glUniform1f(self._loc_maskr_uMargin, shadow_margin * s_x)
 
         gl.glDrawArrays(gl.GL_TRIANGLES, 0, 3)
 
@@ -5122,8 +5156,8 @@ class TileCacheMasked:
                             gl.glBindFramebuffer(gl.GL_FRAMEBUFFER, p.tile.fbo)
                             # Write into the top-anchored logical subrect of the
                             # (possibly bucket-padded) texture.
-                            t_lw, t_lh = snap_int(p.tile.size[0]), snap_int(p.tile.size[1])
-                            t_ah = snap_int(_tile_alloc(p.tile)[1])
+                            t_lw, t_lh = _tile_pixel_size(p.tile)
+                            t_ah = _tile_pixel_size(p.tile, allocated=True)[1]
                             gl.glViewport(0, t_ah - t_lh, t_lw, t_lh)
 
                             # Pre-tint: multiplicative blending drifts stale pixels toward blue
@@ -5341,8 +5375,8 @@ class TileCacheMasked:
                                 iw,
                                 ih,
                                 offset,
-                                r.corner_radius,
-                                r.draw_state.shadow_margin if r.draw_state is not None else 0.0,
+                                r.corner_radius * s_x,
+                                r.draw_state.shadow_margin * s_x if r.draw_state is not None else 0.0,
                                 uv_rect=_tile_uv_rect(t_child),
                             )
                         else:
@@ -5357,9 +5391,9 @@ class TileCacheMasked:
                                 gl.glUseProgram(self._prog_mask_rounded)
                                 gl.glUniform1f(self._loc_maskr_uRankNorm, rank_norm)
                                 gl.glUniform2f(self._loc_maskr_uRectSize, float(iw), float(ih))
-                                gl.glUniform1f(self._loc_maskr_uCornerRadius, r.corner_radius)
+                                gl.glUniform1f(self._loc_maskr_uCornerRadius, r.corner_radius * s_x)
                                 shadow_margin = r.draw_state.shadow_margin if r.draw_state is not None else 0.0
-                                gl.glUniform1f(self._loc_maskr_uMargin, shadow_margin)
+                                gl.glUniform1f(self._loc_maskr_uMargin, shadow_margin * s_x)
 
                             else:
                                 gl.glUseProgram(self._prog_mask)
@@ -5402,8 +5436,8 @@ class TileCacheMasked:
 
                         # Dst is the top-anchored logical subrect of the (possibly
                         # bucket-ized) mask texture, mirroring PASS 3's viewport.
-                        m_lw, m_lh = int(p.tile.size[0]), int(p.tile.size[1])
-                        m_ah = int(_tile_alloc(p.tile)[1])
+                        m_lw, m_lh = _tile_pixel_size(p.tile)
+                        m_ah = _tile_pixel_size(p.tile, allocated=True)[1]
                         gl.glBlitFramebuffer(
                             int(x0),
                             int(y0),
@@ -5488,13 +5522,13 @@ class TileCacheMasked:
 
                         mask_stamps.append((t.mask_tex, (ix0, iy0, iw, ih),
                                             (clip_ix0, clip_iy0, clip_iw, clip_ih),
-                                            _tile_uv_rect(t), offset, r.corner_radius, shadow_margin))
+                                            _tile_uv_rect(t), offset, r.corner_radius * s_x, shadow_margin * s_x))
                     else:
                         clip = (clip_ix0, clip_iy0, clip_iw, clip_ih)
                         shadow_margin = r.draw_state.shadow_margin if r.draw_state is not None else 0.0
                         mask_stamps.append((None, clip, clip, (1, 1, 0, 0),
                                             float(depth_and_layer) / 65535.5,
-                                            r.corner_radius, shadow_margin))
+                                            r.corner_radius * s_x, shadow_margin * s_x))
 
                 if getattr(self, "_mask_batch", None) is None:
                     from meltygui.core.cache.mask_batch import MaskBatch

meltygui/core/graphics/overlay_renderer.py

@@ -829,7 +829,8 @@ class SplitOverlayRenderer(WindowRenderer):
             from OpenGL.GL import shaders
             return shaders.compileProgram(
                 shaders.compileShader(self._STYLE_CONTEXT_VERT, gl.GL_VERTEX_SHADER),
-                shaders.compileShader(self._STYLE_CONTEXT_FRAG, gl.GL_FRAGMENT_SHADER))
+                shaders.compileShader(self._STYLE_CONTEXT_FRAG, gl.GL_FRAGMENT_SHADER),
+                validate=False)  # The VAO is constructed below, after linking.
         program = self._style_gl.get('style_context_program', build_program, gl.glDeleteProgram)
 
         def build_vao():
@@ -880,7 +881,10 @@ class SplitOverlayRenderer(WindowRenderer):
         """Texture unit 1 = StyleContext for the whole command render."""
         gl.glActiveTexture(gl.GL_TEXTURE1)
         previous = int(gl.glGetIntegerv(gl.GL_TEXTURE_BINDING_2D))
-        gl.glBindTexture(gl.GL_TEXTURE_2D, int(texture_id))
+        # Even an unused sampler must name a complete texture on Apple's
+        # driver. The atlas is already resident; DynamicStyles=0 prevents
+        # sampling it as a background when no context texture is needed.
+        gl.glBindTexture(gl.GL_TEXTURE_2D, int(texture_id or self.io.fonts.texture_id))
         gl.glActiveTexture(gl.GL_TEXTURE0)
         return previous
 

meltygui/core/graphics/screenshot.py

@@ -396,6 +396,7 @@ def _capture_tile(name):
     import OpenGL.GL as gl
     from PIL import Image
     from meltygui.core.melty import Melty
+    from meltygui.core.cache.tile_cache import _tile_pixel_size
 
     mw = _find_window(name)
     if mw is None:
@@ -409,7 +410,7 @@ def _capture_tile(name):
     tile = tiles.get(tile_id)
     if tile is None:
         return None
-    w, h = tile.size
+    w, h = _tile_pixel_size(tile)
     if not w or not h or tile.fbo in (None, -1):
         return None
 
@@ -418,7 +419,7 @@ def _capture_tile(name):
     gl.glPixelStorei(gl.GL_PACK_ALIGNMENT, 1)
     # Content is top-anchored in a possibly bottom-padded texture: the logical
     # w x h pixels live in the texture rows [alloc_h - h, alloc_h), not at y=0.
-    alloc_h = (getattr(tile, "alloc_size", None) or tile.size)[1]
+    alloc_h = _tile_pixel_size(tile, allocated=True)[1]
     # Tiles hold LINEAR scRGB (fp16, hdr_color.py): read floats and sRGB-encode
     # for the PNG the way the presentation pass does for the screen.
     data = gl.glReadPixels(0, int(alloc_h) - int(h), int(w), int(h), gl.GL_RGBA, gl.GL_FLOAT)

meltygui/core/melty.py

@@ -613,10 +613,19 @@ class FileWatch:
         return cls._self_write_text.get(resolved)
 
     @classmethod
-    def shutdown(cls):
+    def stop(cls):
+        """Join native file callbacks before the Python runtime goes away.
+
+        Standalone apps own their save policy and need this resource cleanup
+        without importing the code stack or flushing edits from a failed frame.
+        """
+        cls.observer.stop()
         if cls.observer.is_alive():
-            cls.observer.stop()
             cls.observer.join()
+
+    @classmethod
+    def shutdown(cls):
+        cls.stop()
         from meltygui.code.libcst_conversion import shutdown_jedi_pool
         from meltygui.code.libcst_conversion import shutdown_symbol_index_daemon
         shutdown_jedi_pool()
@@ -2300,8 +2309,13 @@ class Melty:
 
         if cls.font_mgr is None:
             return
-        if cls.font_mgr.scale != cls.ui_scale:
-            if not cls.font_mgr.rebuild(cls.ui_scale, impl):
+        io = imgui.get_io()
+        # Surfaces share one atlas. Keep the highest backing density seen so
+        # windows on different displays cannot continually rebuild each other.
+        pixel_scale = max(cls.font_mgr.pixel_scale, *io.display_fb_scale)
+        io.font_global_scale = 1.0 / pixel_scale
+        if cls.font_mgr.scale != cls.ui_scale or cls.font_mgr.pixel_scale != pixel_scale:
+            if not cls.font_mgr.rebuild(cls.ui_scale, impl, pixel_scale=pixel_scale):
                 return
         # Lazy fonts: bake whatever last-frame's get()s queued (fonts
         # are seeded minimally at boot - see FontManager.prewarm). Same
@@ -2965,7 +2979,7 @@ class Melty:
         cls.display_size = (fb_w, fb_h)
         # Masks/tiles cover the WHOLE framebuffer (shadow margin included).
         real_fb = cls.framebuffer_size or (fb_w, fb_h)
-        cls.cache.mask_begin_frame((int(real_fb[0]), int(real_fb[1])))
+        cls.cache.mask_begin_frame((int(real_fb[0]), int(real_fb[1])), imgui.get_io().display_fb_scale)
 
         # Channel-split the foreground/overlay draw list the same way as the
         # window draw list (max_depth channels) so per-window overlays can be
@@ -5058,8 +5072,8 @@ class Melty:
                 # Glow rects as light sources: hand the composite the low-res
                 # glow buffer (add_glow marks, stamped in finalize_captures
                 # PASS 6). glow_strength=0 skips the path in the shader, so an
-                # empty/absent glow costs nothing; texture 0 is a legal
-                # placeholder bind for the sampler in that case.
+                # empty/absent glow costs nothing. Still bind a complete
+                # texture for Apple's driver, even when the branch is off.
                 _glow_tex = (Melty.cache.glow_tex
                              if Melty.cache.glow_active else None)
                 _glow_on = _glow_tex is not None and Toggles.glow
@@ -5083,7 +5097,7 @@ class Melty:
                     shadow_size=(float(composite_shadow_size[0]),
                                  float(composite_shadow_size[1])),
                     depth_sharpness=float(Toggles.shadow_edge_sharpness),
-                    glow_map=_glow_tex if _glow_on else 0,
+                    glow_map=_glow_tex if _glow_on else shadow_raw,
                     glow_strength=(float(Toggles.glow_strength)
                                    if _glow_on else 0.0),
                     glow_shadow_cut=float(Toggles.glow_shadow_cut),

meltygui/core/runtime/app.py

@@ -141,7 +141,7 @@ def boot(app_id=None):
     # without xdg-decoration), which also means the compositor's frame.
     if backend == 'glfw' and os.environ.get('MELTY_LIBDECOR'):
         sys._lsd_wayland_libdecor_disabled = False
-    from meltygui.core.windowing.glfw_utils import apply_wayland_frame_hint
+    from meltygui.core.windowing.glfw_utils import apply_wayland_frame_hint, apply_opengl_context_hints
     apply_wayland_frame_hint()
     if not glfw.init():
         raise SystemExit('glfw.init failed')
@@ -149,9 +149,7 @@ def boot(app_id=None):
     if backend == 'glfw':
         warm_start.remember_glfw_library(cache)
     glfw.window_hint(glfw.VISIBLE, False)
-    glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
-    glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
-    glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
+    apply_opengl_context_hints()
     owner = glfw.create_window(1, 1, 'meltygui owner', None, None)
     if not owner:
         raise SystemExit('glfw.create_window (owner) failed')
@@ -232,7 +230,10 @@ def _init_melty():
     imgui.get_io().ini_file_name = None
     imgui.get_io().display_size = (1.0, 1.0)     # the atlas hinting pass frames on it
     Melty.glfw_window = owner
-    Melty.font_mgr = FontManager(imgui.get_io(), Melty.resolve_ui_scale())
+    window_size, framebuffer_size = glfw.get_window_size(owner), glfw.get_framebuffer_size(owner)
+    pixel_scale = max(1.0, *(pixels / max(1, points)
+                              for pixels, points in zip(framebuffer_size, window_size)))
+    Melty.font_mgr = FontManager(imgui.get_io(), Melty.resolve_ui_scale(), pixel_scale=pixel_scale)
     Melty.font_mgr.prewarm()
     warm_start.cache_hinted_atlas(Melty.font_mgr, _state['cache'])
     mark('fonts loaded')
@@ -596,6 +597,65 @@ def _unhook_main_return():
     _state['hooked'] = False
 
 
+def _process_events(timeout=None):
+    """Dispatch OS events at a point where a refresh may safely draw.
+
+    Cocoa can stay inside this call for a whole native resize gesture.
+    Window creation, pending geometry writes and rendering are outside it.
+    """
+    import meltygui.core.windowing.window_api as glfw
+    _state['processing_events'] = True
+    try:
+        if timeout is None:
+            glfw.poll_events()
+        else:
+            glfw.wait_events_timeout(timeout)
+    finally:
+        _state['processing_events'] = False
+    # Exceptions cannot cross GLFW's ctypes callback boundary. Raise them
+    # back in the app loop, whose finally skips saving a failed session.
+    error = _state.pop('refresh_error', None)
+    if error is not None:
+        raise error
+
+
+def refresh_surface(surface):
+    """Present fresh content while Cocoa owns the native resize event loop.
+
+    Only draw between ordinary frames, on the render thread. A refresh
+    emitted by a resize or swap during this frame stays queued. Creation,
+    destruction and event polling remain in the outer loop.
+    """
+    if (sys.platform != 'darwin' or not _state.get('processing_events')
+            or _state.get('refreshing') or _state['failed']
+            or surface.closed or surface.frames == 0):
+        return
+    import meltygui.core.windowing.window_api as glfw
+    import meltygui_imgui as imgui
+    from meltygui.core.melty import Melty
+    from meltygui.core.windowing import glfw_utils
+    if threading.get_ident() != glfw_utils._render_thread_id:
+        return
+    previous_gl, previous_imgui = glfw.get_current_context(), imgui.get_current_context()
+    _state['refreshing'] = True
+    try:
+        if surface.wants_frame():
+            Melty.app_tick += 1
+            surface.frame()
+            # Mark children against THIS tick before the outer loop advances
+            # again. Their actual native-window teardown stays outside GLFW.
+            _close_stale_children()
+    except Exception as error:
+        _state['failed'] = True
+        _state['refresh_error'] = error
+    finally:
+        # The Surface callback wrapper restores per-window Python state;
+        # rendering also switched GL/ImGui, which ordinary input never does.
+        glfw.make_context_current(previous_gl)
+        imgui.set_current_context(previous_imgui)
+        _state['refreshing'] = False
+
+
 def run():
     """Open every registered window and run until the last one closes."""
     if _state['ran']:
@@ -635,7 +695,7 @@ def run():
     glfw_utils.request_render()
     try:
         while Surface.all:
-            glfw.poll_events()
+            _process_events()
             _open_requested_children()
             # A frame only on a request (request_render: the input layer's
             # callbacks, Surface's focus/resize/close hooks, animations via
@@ -690,10 +750,14 @@ def run():
             # requests nothing: poll while any exist. The idle wait is
             # bounded so a signal (Ctrl+C) gets a turn: Python runs its
             # handler between bytecodes, never inside a blocked OS call.
-            glfw.wait_events_timeout(1 / 60 if any(s.children for s in Surface.all) else 1.0)
+            _process_events(1 / 60 if any(s.children for s in Surface.all) else 1.0)
     finally:
         _debug(f'{frames} frames rendered')
         input_recording_core.stop_on_exit()
+        # Standalone apps do not run Melty.cleanup. Cocoa's file watcher
+        # must stop before interpreter teardown, even after a failed frame.
+        from meltygui.core.melty import FileWatch
+        FileWatch.stop()
         if not _state['failed']:
             _flush_pending_saves()
             _save_session()

meltygui/core/services/terminal_core.py

@@ -17,6 +17,7 @@ import shutil
 import signal
 import struct
 import subprocess
+import sys
 import threading
 import time
 import uuid
@@ -89,7 +90,9 @@ def _inheritable_fds():
     """Every fd >= 3 that would survive an exec (not FD_CLOEXEC). Python-created fds are
     CLOEXEC by default (PEP 446); this catches the C libraries' (CUDA / GL / inotify)."""
     fds = []
-    for name in os.listdir("/proc/self/fd"):
+    # macOS exposes descriptors through devfs, without Linux's procfs mount.
+    directory = "/dev/fd" if sys.platform == "darwin" else "/proc/self/fd"
+    for name in os.listdir(directory):
         fd = int(name)
         if fd < 3:
             continue

meltygui/core/styling/fonts.py

@@ -159,6 +159,10 @@ def detect_auto_scale(window=None) -> float:
     by which video mode contains the window's center; falls back to the
     primary monitor when the window is None or sits off every monitor
     (mid-drag between screens). 1.0 on any glfw failure."""
+    # Cocoa window geometry is already in the user's chosen logical points.
+    # Retina backing resolution controls raster quality, not layout size.
+    if sys.platform == 'darwin':
+        return 1.0
     try:
         import meltygui.core.windowing.window_api as glfw
         target = None
@@ -233,10 +237,10 @@ def _expand_ranges(ranges: Tuple[int, ...]):
 class FontManager:
     # no external change
     """Owns the imgui font atlas: one handle per Font enum entry, all baked
-    at `scale` x their authored pixel size.
+    at `scale` x their authored point size and `pixel_scale` texels per point.
 
     The scale is baked into the RASTERIZED size rather than applied as a
-    draw-time multiplier (io.font_global_scale) so glyphs stay sharp — a
+    draw-time UI zoom so glyphs stay sharp — a
     scaled atlas is resampled text, which is exactly the soft/aliased look
     the whole-interface zoom had. The cost is that changing the scale means
     re-rasterizing every font (see `rebuild`), so it happens only when the
@@ -247,9 +251,13 @@ class FontManager:
     # can make imgui's atlas build fail outright.
     MIN_SIZE = 4.0
 
-    def __init__(self, io, scale: float = 1.0):
+    # Existing managers pick up the backing density between frames on hotswap.
+    pixel_scale = 1.0
+
+    def __init__(self, io, scale: float = 1.0, pixel_scale: float = 1.0):
         self.io = io
         self.scale = float(scale)
+        self.pixel_scale = float(pixel_scale)
         self._handles: dict = {}
         # imgui keeps a POINTER to each font's glyph ranges until the atlas is
         # built, and a GlyphRanges frees its array when collected: the bake
@@ -269,7 +277,7 @@ class FontManager:
         # the per-frame get() of a steady style allocates nothing.
         self._variant_memo = {}
 
-    def rebuild(self, scale: float, impl=None) -> bool:
+    def rebuild(self, scale: float, impl=None, *, pixel_scale=None) -> bool:
         """Re-bake every LOADED font at `scale` and hand the new atlas to the
         renderer. No-op (False) when the scale is unchanged.
 
@@ -279,9 +287,11 @@ class FontManager:
         cached one (Melty.large_font, LSDStudio.fa_font) have to re-`get` it.
         """
         scale = float(scale)
-        if scale == self.scale and self._handles:
+        pixel_scale = self.pixel_scale if pixel_scale is None else float(pixel_scale)
+        if scale == self.scale and pixel_scale == self.pixel_scale and self._handles:
             return False
         self.scale = scale
+        self.pixel_scale = pixel_scale
         self._loaded |= self._pending
         self._pending.clear()
         self._bake(self._loaded)
@@ -355,6 +365,10 @@ class FontManager:
         self._variant_last_used = {f: t for f, t in self._variant_last_used.items() if f in include}
         self._handles.clear()
         self.io.fonts.clear()
+        # Rasterize at physical resolution, then express glyph geometry in
+        # window points. This cancels the framebuffer scale, never upscales
+        # a low-resolution atlas. Every Surface applies the same reciprocal.
+        self.io.font_global_scale = 1.0 / self.pixel_scale
         self._glyph_ranges.clear()
         variants = sorted((f for f in include if isinstance(f, FontSpec)),
                           key=lambda f: (f.path, f.size, f.weight))
@@ -364,19 +378,19 @@ class FontManager:
             if font not in include:
                 continue
             spec = font if isinstance(font, FontSpec) else font.value
-            size = max(self.MIN_SIZE, spec.size * self.scale)
+            size = max(self.MIN_SIZE, spec.size * self.scale) * self.pixel_scale
             if spec.merge:
                 merge_cfg = dict(
                     merge_mode=True,
-                    glyph_extra_spacing_x=spec.extra_spacing * self.scale,
-                    glyph_extra_spacing_y=spec.extra_spacing * self.scale,
+                    glyph_extra_spacing_x=spec.extra_spacing * self.scale * self.pixel_scale,
+                    glyph_extra_spacing_y=spec.extra_spacing * self.scale * self.pixel_scale,
                 )
                 # Merged icon fonts cover wide ranges, so they dominate the
                 # atlas - spread them out as the scale grows. Untouched at
                 # scale <= 1 because the authored atlas is unchanged: imgui's
                 # own defaults are (h=3, v=1), and spelling them out is
                 # what keeps v from silently becoming 3 here.
-                if self.scale > 1.0:
+                if self.scale * self.pixel_scale > 1.0:
                     merge_cfg["oversample_h"] = self._oversample(spec)
                     merge_cfg["oversample_v"] = 1
                 cfg = imgui.FontConfig(**merge_cfg)
@@ -521,10 +535,13 @@ class FontManager:
         relative to the add_text pen, texel rect in the atlas. Codepoints
         that emit no quad (spaces) are absent; imgui's fallback glyph shows
         up as repeated rects, deduped by the caller."""
-        io = self.io
-        saved = (io.display_size, io.delta_time)
+        # Probe the active context (a Surface can share the owner's atlas).
+        # Hinting needs physical glyph metrics even when the UI uses points.
+        io = imgui.get_io()
+        saved = (io.display_size, io.delta_time, io.font_global_scale)
         io.display_size = (4096.0, 4096.0)
         io.delta_time = 1.0 / 60.0
+        io.font_global_scale = 1.0
         out = {}
         try:
             imgui.new_frame()
@@ -556,7 +573,7 @@ class FontManager:
                            int(round(v0[2] * tex_w)), int(round(v0[3] * tex_h)),
                            int(round(v2[2] * tex_w)), int(round(v2[3] * tex_h)))
         finally:
-            io.display_size, io.delta_time = saved
+            io.display_size, io.delta_time, io.font_global_scale = saved
         return out
 
     def hint_atlas(self, width: int, height: int, pixels: bytes):
@@ -583,7 +600,7 @@ class FontManager:
             handle = self._handles.get(font)
             if spec.merge or not spec.hint or handle is None:
                 continue
-            size = max(self.MIN_SIZE, spec.size * self.scale)
+            size = max(self.MIN_SIZE, spec.size * self.scale) * self.pixel_scale
             if size > HINT_MAX_SIZE:
                 continue
             cps = _expand_ranges(spec.glyph_ranges or _UI_RANGE)
@@ -636,4 +653,4 @@ class FontManager:
         end_time = time.time()
         print(f"FontManager: hinting pass took {end_time - start_time:.3f} s")
         print(f"wall time {end_time}")
-        return atlas.tobytes()
+        return atlas.tobytes()

meltygui/core/windowing/glfw_utils.py

@@ -31,6 +31,19 @@ UI_SCALE_MIN = 0.5
 UI_SCALE_MAX = 3.0
 
 
+def apply_opengl_context_hints():
+    """Use the same core context for the owner and every shared window.
+
+    Apple's OpenGL driver stops at 4.1 and requires a forward-compatible
+    core profile. Other backends retain 4.3 for the compute-based tools.
+    """
+    glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
+    glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 1 if sys.platform == 'darwin' else 3)
+    glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
+    if sys.platform == 'darwin':
+        glfw.window_hint(glfw.OPENGL_FORWARD_COMPAT, True)
+
+
 def clamp_ui_scale(value) -> float:
     """Sanitize a candidate ui scale: a float within
     [UI_SCALE_MIN, UI_SCALE_MAX] passes through; anything crazy — out of
@@ -1426,4 +1439,4 @@ def request_render(for_frames: int | None = None):
         _requested_surfaces.add(scope)
     else:
         _all_surfaces_generation += 1
-    _wake_render_loop()
+    _wake_render_loop()

meltygui/core/windowing/os_frame.py

@@ -10,7 +10,7 @@ Parent-relative nested positions must be accounted for when applying results;
 driving-edge phases below are an implementation strategy, not product rules.
 Hand-drag replay restores displaced geometry when the gesture reverses.
 
-Geometry/position availability determines whether the native frame can move.
+An available adjustment path AND geometry determine whether the native frame can move.
 The GLFW and Wayland adapters must honor those capabilities. See
 ``docs/WINDOW_COLLISION_COLUMNS.md`` for the authoritative behavior contract.
 """
@@ -79,6 +79,7 @@ _STATE.setdefault("learned", {"x": [None, None], "y": [None, None]})
 _STATE.setdefault("learned_area", None)
 _STATE.setdefault("pin_rebases", {})
 _STATE.setdefault("move_requests", {"x": [], "y": []})
+_STATE.setdefault("pending_surface_collision", False)
 
 
 def _trace(msg):
@@ -111,6 +112,7 @@ def reset(reason="studio start"):
     _STATE["unapplied_far"] = [0.0, 0.0]
     _STATE["pin_rebases"] = {}
     _STATE["move_requests"] = {"x": [], "y": []}
+    _STATE["pending_surface_collision"] = False
     _STATE["window_id"] = None
     _STATE["feed_far"] = [None, None]
     _STATE["generation"] += 1
@@ -125,7 +127,7 @@ def _enabled():
 
 def mode():
     """"feed" (Wayland, the extension's position), "x11" (glfw's position)
-    or "walls" (no position: the OS edges are immovable)."""
+    or "walls" (no reliable native adjustment: the OS edges are immovable)."""
     return _STATE["mode"]
 
 
@@ -173,11 +175,13 @@ def _observe():
     """((x, y), (work_x, work_y, work_w, work_h), mode, (far_x, far_y),
     window_id) of the content rect on screen — the far edges from the
     SAME source as the position (the feed's own width / height; glfw's on
-    X11) — or None when no position is known."""
+    X11) — or None without both geometry and a native adjustment path."""
     import meltygui.core.windowing.titlebar as titlebar
+    window = titlebar._studio_window()
+    if not titlebar.can_adjust_window_edges(window):
+        return None
     if titlebar._on_wayland():
         import meltygui.core.windowing.geometry_feed as geometry_feed
-        geometry_feed.ensure_started()      # a hotswap, not a restart (or a backend switch): start it here
         # the Hyprland backend reports the SURFACE: shrink by the shadow
         # inset to the content (a no-op on the GNOME feed's geometry rect)
         rect, area = geometry_feed.frame_rect(inset=titlebar.window_inset()), geometry_feed.resize_workarea()
@@ -186,9 +190,6 @@ def _observe():
         frame = geometry_feed._current_frame() or {}     # the ACTIVE surface's window (extension.py)
         return ((float(rect[0]), float(rect[1])), tuple(float(v) for v in area), "feed",
                 (float(rect[0] + rect[2]), float(rect[1] + rect[3])), frame.get("id"))
-    window = titlebar._studio_window()
-    if window is None:
-        return None
     try:
         x, y = glfw.get_window_pos(window)
         w, h = glfw.get_window_size(window)
@@ -503,6 +504,11 @@ def _rebase(ds, axis, delta):
 def _set_mode(new_mode):
     if _STATE["mode"] != new_mode:
         _STATE["mode"] = new_mode
+        if new_mode == "walls":
+            # The old coordinate space and requests no longer describe
+            # geometry we can apply. Never replay their pending rebases.
+            reset("native adjustments unavailable")
+            return
         _STATE["generation"] += 1          # every root forgets where it saw the OS edges
         _STATE["gestures"] = {}
         _STATE["expected"] = [None, None]
@@ -555,7 +561,8 @@ def begin_frame():
         for axis, i in _AXIS.items():
             near, far = _STATE["edges"][axis]
             near[axis], far[axis] = 0.0, size[i]
-            _STATE["os_seen"][i] = (0.0, size[i])
+            if _STATE["os_seen"][i] is None:
+                _STATE["os_seen"][i] = (0.0, size[i])
         return
     (pos, area, new_mode, feed_far, window_id) = observed
     _set_mode(new_mode)
@@ -824,7 +831,7 @@ def queue_drag(axis, index, inc):
     """A cursor-driven drag of the OS window's own frame edge (``index`` 0
     = near / left / top, 1 = far) by ``inc`` px — the background right-drag
     (titlebar). Solved by the first root pass of the frame, else by flush."""
-    if inc:
+    if inc and available():
         _STATE["pending"][axis].append((int(index), float(inc)))
 
 
@@ -1525,7 +1532,7 @@ def flush():
     in one commit). Returns the requested content size or None."""
     import meltygui.core.windowing.titlebar as titlebar
     from meltygui.core.melty import Melty
-    if not _enabled():
+    if not _enabled() or not available():
         return None
     window = titlebar._studio_window()
     display = Melty.display_size
@@ -1577,9 +1584,10 @@ def flush():
                 glfw.set_window_pos(window, x + offset[0], y + offset[1])
             except Exception:
                 pass
-        titlebar.request_surface_size(window, *surface)
+        titlebar.request_surface_size(window, *surface, collision=True)
     else:
-        titlebar.request_surface_size(window, *surface, offset=tuple(offset) if any(offset) else None)
+        titlebar.request_surface_size(window, *surface, offset=tuple(offset) if any(offset) else None,
+                                      collision=True)
     _trace(f"flush: content {size} offset {offset} → surface {surface}")
     return tuple(size)
 

meltygui/core/windowing/surface.py

@@ -162,9 +162,7 @@ class Surface:
 
         glfw.default_window_hints()
         glfw.window_hint(glfw.VISIBLE, True)
-        glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
-        glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 3)
-        glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
+        glfw_utils.apply_opengl_context_hints()
         glfw.window_hint(glfw.TRANSPARENT_FRAMEBUFFER, transparent)
         glfw.window_hint(glfw.ALPHA_BITS, 8 if transparent else 0)
         glfw.window_hint(glfw.DECORATED, glfw.FALSE if self.chrome else glfw.TRUE)
@@ -215,6 +213,7 @@ class Surface:
         # (the owner's is), so select ours before touching its io.
         imgui.set_current_context(self.ctx)
         imgui.get_io().ini_file_name = None
+        imgui.get_io().font_global_scale = owner_io.font_global_scale
         # The renderer uploads the atlas in its constructor, BEFORE it stamps
         # display_size: the FreeType hinting pass (fonts.hint_atlas) frames on
         # the current context and dies on the (-1, -1) default.
@@ -343,9 +342,14 @@ class Surface:
         hook(glfw.set_window_focus_callback, self._on_focus)
         hook(glfw.set_framebuffer_size_callback, self._on_framebuffer_size)
         hook(glfw.set_window_close_callback, lambda *_: request_render())
-        # Damage (an uncomposited X11 expose): a clean surface is not redrawn
-        # otherwise. The native Wayland backend has no such event.
-        hook(glfw.set_window_refresh_callback, lambda *_: request_render())
+        # Cocoa delivers refreshes inside its modal live-resize loop. Waiting
+        # for poll_events to return would stretch the last presented buffer.
+        hook(glfw.set_window_refresh_callback, self._on_refresh)
+
+    def _on_refresh(self):
+        request_render()
+        from meltygui.core.runtime.app import refresh_surface
+        refresh_surface(self)
 
     def _on_focus(self, focused):
         request_render()
@@ -445,10 +449,12 @@ class Surface:
         # edits deferred while a picker/slider held the pointer here too.
         from meltygui.core.rendering.parameter_core import flush_deferred_writes
         flush_deferred_writes()
+        # Collision bounds belong to the surface, including when the OS
+        # supplies its title bar and cannot accept collision-driven moves.
+        os_frame.begin_frame()
         if self.chrome:
-            os_frame.begin_frame()
             titlebar.poll_os_window_drag()
-            os_frame.solve()
+        os_frame.solve()
         imgui.set_cursor_screen_pos((0, 0))
         imgui.set_item_allow_overlap()
         draw_list = imgui.get_window_draw_list()
@@ -466,7 +472,7 @@ class Surface:
         imgui.set_cursor_screen_pos((0, top))
         # The root fills the OS MODEL's size (os_frame.content_size): equal
         # to the display except while our own resize is still landing.
-        fill_w, fill_h = os_frame.content_size((disp_w, disp_h)) if self.chrome else (disp_w, disp_h)
+        fill_w, fill_h = os_frame.content_size((disp_w, disp_h))
         Melty.root_fill = (float(fill_w), float(fill_h) - top, float(top))   # (w, h below the chrome, top y)
         Melty.root_fill_used = False
         # The body runs INSIDE the ground, as the studio's windows run inside
@@ -489,8 +495,7 @@ class Surface:
         Melty.end_frame()
         if self.request is not None:
             Melty.finish_surface_root(self.request, self)
-        if self.chrome:
-            os_frame.flush()
+        os_frame.flush()
         Melty.window_stack.pop()
         draw_list.channels_merge()
         Melty.channels_split = False

meltygui/core/windowing/titlebar.py

@@ -238,6 +238,35 @@ def backend_supported():
     return sys.platform.startswith("linux")
 
 
+def can_adjust_window_edges(window):
+    """Can collision pushes control this native frame's position AND size?
+
+    Reading a position or starting a compositor-owned interactive resize is
+    insufficient. Only the implemented X11 and Wayland control paths opt in;
+    Cocoa and unknown backends keep the observed content bounds fixed.
+    """
+    if window is None or not sys.platform.startswith("linux"):
+        return False
+    try:
+        if not glfw.get_window_attrib(window, glfw.RESIZABLE) or _fullscreen(window):
+            return False
+        if not _on_wayland():
+            return (glfw.get_platform() == glfw.PLATFORM_X11
+                    and not bool(glfw.get_window_attrib(window, glfw.MAXIMIZED)))
+        import meltygui.core.windowing.geometry_feed as geometry_feed
+        geometry_feed.ensure_started()
+        frame = geometry_feed._current_frame()
+        if (not geometry_feed._STATE['available'] or not frame
+                or frame.get('maximized') or frame.get('fullscreen')):
+            return False
+        backend = geometry_feed.backend()
+        if backend == 'hyprland':
+            return bool(frame.get('floating') and frame.get('address'))
+        return backend == 'gnome' and wayland_move.offset_available()
+    except Exception:
+        return False
+
+
 def titlebar_enabled():
     """X11: Toggles.Melty.enhanced_titlebar (it replaces the WM frame, an
     opt-in). Wayland: whenever the native frame is up — GLFW's fallback frame
@@ -1022,7 +1051,8 @@ def draw_titlebar(window):
     # (the drag events themselves are consumed by poll_os_window_drag at
     # the frame's START - before the root windows solve - so the OS edge
     # moves in the same frame the hand did)
-    if _rdrag is not None:
+    from meltygui.core.windowing import os_frame
+    if _rdrag is not None and os_frame.available():
         mouse_cursor.request(_EDGE_CURSOR[_SIZE_TOPLEFT if _rdrag["top_left"] else _SIZE_BOTTOMRIGHT])
 
     # The buttons themselves are painted earlier in the frame, in the main
@@ -1356,7 +1386,7 @@ _pending_surface_wait = globals().get("_pending_surface_wait") or 0
 PENDING_SURFACE_WAIT_FRAMES = 300
 
 
-def request_surface_size(window, width, height, offset=None, fit=False):
+def request_surface_size(window, width, height, offset=None, fit=False, collision=False):
     """Queue an app-side resize (the right-drag) for the top of the NEXT
     frame (apply_pending_surface_size, before process_inputs). Applied
     mid-frame it committed a new buffer size and geometry with content laid
@@ -1369,11 +1399,15 @@ def request_surface_size(window, width, height, offset=None, fit=False):
     the CONTENT inside the work area at the new size — the compositor
     centred the window at its INITIAL size and the box grows anchored at
     its top-left, so a restored studio ran off the bottom and right of
-    the screen (and the OS-edge walls then hold it there, 09-09)."""
+    the screen (and the OS-edge walls then hold it there, 09-09).
+    ``collision`` marks a solver request, cancelled if native adjustment
+    becomes unavailable before it is applied. Explicit sizes still work."""
     global _pending_surface_size, _pending_surface_offset, _pending_surface_fit
+    from meltygui.core.windowing import os_frame
     _pending_surface_size = (int(width), int(height))
     _pending_surface_offset = tuple(int(v) for v in offset) if offset else None
     _pending_surface_fit = bool(fit)
+    os_frame._STATE['pending_surface_collision'] = bool(collision)
 
 
 def fit_offset(rect, size, area, inset):
@@ -1400,6 +1434,17 @@ def apply_pending_surface_size(window):
     import meltygui.core.windowing.wayland_move as wayland_move
     import meltygui.core.windowing.os_frame as os_frame
     wayland_move.clear_surface_offset()          # last frame's offset is spent
+    collision = os_frame._STATE.get('pending_surface_collision', False)
+    if not can_adjust_window_edges(window):
+        # Discard speculative compensation BEFORE it moves any child. A
+        # readable but uncontrollable frame must never rebase local content.
+        os_frame._set_mode('walls')
+        if collision:
+            _pending_surface_size = _pending_surface_offset = None
+            _pending_surface_fit = False
+            _pending_surface_wait = 0
+            _frame_surface_offset = None
+            os_frame._STATE['pending_surface_collision'] = False
     # The roots' passes re-base with the OS near edge's motion lands HERE,
     # with the move it compensates (os_frame: the solve booked it).
     os_frame.apply_rebase()
@@ -1440,6 +1485,7 @@ def apply_pending_surface_size(window):
     _pending_surface_fit = False
     _pending_surface_size = None
     _pending_surface_offset = None
+    os_frame._STATE['pending_surface_collision'] = False
     from meltygui.core.runtime.toggles import Toggles
     if Toggles.Melty.push_os_window_edges_trace:
         try:

meltygui/graphics/shader_compiler.py

@@ -59,7 +59,10 @@ class ProgramCompiler:
         try:
             vertex_shader = shaders.compileShader(vertex_src, GL.GL_VERTEX_SHADER)
             fragment_shader = shaders.compileShader(fragment_src, GL.GL_FRAGMENT_SHADER)
-            program_id = shaders.compileProgram(vertex_shader, fragment_shader)
+            # Validation examines the current VAO/texture bindings, which the
+            # executor installs only when drawing. Apple's driver correctly
+            # rejects that incomplete state here; compile/link checks still run.
+            program_id = shaders.compileProgram(vertex_shader, fragment_shader, validate=False)
         except shaders.ShaderCompilationError as e:
             raise ShaderCompilationError(f"Failed to compile shader '{shader.name}': {e}")
         
@@ -92,8 +95,11 @@ class ProgramCompiler:
         parts = [GLSL_VERSION]
         
         # Add input declarations
-        for name, gl_type in shader_type.vertex_in.items():
-            parts.append(f"in {gl_type.value} {name};")
+        # FilterExecutor supplies position at 0 and texcoord at 1. Linkers
+        # may assign different locations unless the source pins that layout
+        # (Apple otherwise feeds UVs to position, drawing only one quarter).
+        for location, (name, gl_type) in enumerate(shader_type.vertex_in.items()):
+            parts.append(f"layout(location = {location}) in {gl_type.value} {name};")
         
         # Add output declarations (varyings)
         for name, gl_type in shader_type.vertex_out.items():

{meltygui-0.1.2.dist-info → meltygui-0.1.3.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.5
 Name: meltygui
-Version: 0.1.2
+Version: 0.1.3
 Summary: Immediate-mode Python UI, live inspection, HDR and tensor visualization
 License-Expression: Apache-2.0
 License-File: LICENSE
 Classifier: Development Status :: 3 - Alpha
+Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: Microsoft :: Windows
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python :: 3.11
@@ -60,11 +61,13 @@ MeltyGUI is capable of rendering tensors exceeding 64GB in size. The primary cha
 MeltyGUI is not yet published to PyPI. For now, install from a checkout using
 [the setup guide](docs/DEVELOPMENT.md#setup).
 
-The current setup targets Linux x86-64 with Python 3.11, 3.12 or 3.13 and a
-working OpenGL 4.3 context. CUDA tensor rendering also requires PyTorch, an
+Linux x86-64 uses Python 3.11, 3.12 or 3.13 and OpenGL 4.3. The UI and editor
+also run on Apple Silicon macOS with Python 3.12, OpenGL 4.1 and Retina
+rendering. CUDA tensor rendering requires PyTorch, an
 NVIDIA GPU, a CUDA toolkit, and MeltyGUI's GL-enabled CUDA binding. The native
 bindings install as prebuilt wheels on those targets; elsewhere installers
 compile them, see [when no wheel matches](docs/SUPPORT_WHEELS.md#when-no-wheel-matches).
+CUDA rendering is unavailable on macOS.
 
 ## Visualize a tensor
 

{meltygui-0.1.2.dist-info → meltygui-0.1.3.dist-info}/RECORD

@@ -67,7 +67,7 @@ meltygui/core/README.md,sha256=_4lJ5-kykF6BBi3ZTfPRlmAIptDfSeygGkT4wtFCDhQ,6158
 meltygui/core/__init__.py,sha256=NQnuSYYGxJhquq6jFPaDzG0m66heXxXRbfO8Zoq5BqM,31
 meltygui/core/core_render.py,sha256=Ks_f_RG87moGSDDU0XiwvQsB87-SBb-ffxU1KYjoPh4,360878
 meltygui/core/definition_hotswap.py,sha256=uyeQdmo0Fsc8sxi1YWQ_xbnK2PFgb-TlwLtPG3ftX9c,13163
-meltygui/core/melty.py,sha256=oziIh61KhT_LSYRhr4ue_QVmg6wH53rCzG5EcjxQ85M,338827
+meltygui/core/melty.py,sha256=oQ6sEh_3bKBK1qqxnWfTpR4rxhBDFn8mMPbk-YLvr3M,339552
 meltygui/core/module_map.json,sha256=nQpRabbt79yUp383CmHHoriY3BR7Wt-u3iwXRLKKk6k,71038
 meltygui/core/module_names.py,sha256=Y4fFyW8B9Sp68OymFQcYzFNpdDppwFV4TEBTPwOJv0Q,587
 meltygui/core/automation/__init__.py,sha256=qLfR1a21ndcddqigc3kz2QEeefXyAxrUR2Aavgts94M,45
@@ -88,9 +88,9 @@ meltygui/core/cache/__init__.py,sha256=lqIupeNqK0CgSSyX-oVxiKbl_-6oisCQfj0DJPcOC
 meltygui/core/cache/cache_diagnostics.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 meltygui/core/cache/invalidation_decoration.py,sha256=9OADxQcWK7GESxDXADK_4xvvTBb7pk2egmdlL2yLv3M,8068
 meltygui/core/cache/invalidation_tracker.py,sha256=WkbK-8mgkwxlMiRV1HQ154R5-7akAsJSUBVIudmtfQk,2781
-meltygui/core/cache/mask_batch.py,sha256=QWaedBiPaji8n0RYzaqXT4_yHJBxhYNMYk6cPDOJDqY,7597
+meltygui/core/cache/mask_batch.py,sha256=-3yv2DSrdtKdM0v5Wt94sfwM8ei8MgT6JOKnOzSwSDA,8345
 meltygui/core/cache/parameter_dependencies.py,sha256=xZ9LoTVPqibptYqG-EmSLgueCn0ZMFDxEPcqIZu1jzE,2218
-meltygui/core/cache/tile_cache.py,sha256=1UsmuGtWBmFGTEdWzwauIAkzxjfRXHyvAR6OFrarFnA,304529
+meltygui/core/cache/tile_cache.py,sha256=ub_jH8ztxCuR5Hb0BO4-jZfrIoMBBZMqM6W8lNmNJb8,306739
 meltygui/core/cache/tile_marks.py,sha256=mF4ZXw-q0QzBMVV2c5mhJ6rLhawbgBzxvYBvvzbq1Lw,5186
 meltygui/core/conversion/__init__.py,sha256=e2s7OoBQMD2xb-odKUzBme7QmQUYZUAmRW6VVyw0c_U,45
 meltygui/core/conversion/bubbling.py,sha256=BmnQoru9ogOaCx5tyHahllW6V0LtAyjWXNEqEySKke8,23281
@@ -136,9 +136,9 @@ meltygui/core/graphics/cuda_kernel_core.py,sha256=HmiZyDq7_5pbpa01SXO9pkTU0YbbdM
 meltygui/core/graphics/framebuffer_recorder.py,sha256=Q5GhivJHmkDlUMH9XkMoTLOmEYlNB70H6IGMxEzuuBg,10877
 meltygui/core/graphics/gl_state.py,sha256=7V85zk2Ryoi17zQjYHSV3fmx1x4W7Il1-g3Q3s0EMcg,29184
 meltygui/core/graphics/lut_core.py,sha256=nw1GZs3tOwcOH9WGNulCm4OJh260Bsz53GwuClZVdX4,2230
-meltygui/core/graphics/overlay_renderer.py,sha256=DvgtOM40sdWL0vVrHP-9FA1EHJ_ALBiAknoRNjkpC7w,49950
+meltygui/core/graphics/overlay_renderer.py,sha256=MUAYDfxl7GJtgxSwLrz0XZV1hDinfXAsFkuBHlbsoPw,50278
 meltygui/core/graphics/scene_target.py,sha256=YEhzvksdnnkYVXubAGsfsGYlj1bsoVG-3jxC5n8ZeHM,7918
-meltygui/core/graphics/screenshot.py,sha256=MTqM9RDg7o3pZTBNAUOAWdnLLnq4DWl_3XyuYrJYOHk,17593
+meltygui/core/graphics/screenshot.py,sha256=bmU9yBEootNwiIh6kq2B0kKFJz7Q1QSGksllztl5fp0,17660
 meltygui/core/graphics/shader_func.py,sha256=9N2HsN_pXLJAnV9Vt-J_YnwTeaEXP4y-AXNv02NZyyY,20165
 meltygui/core/graphics/tensor_core.py,sha256=E6OCvyp34szA_5Lg7g2V7dFNDRzMZrdjmqZjFO1kOac,2216
 meltygui/core/graphics/text_texture.py,sha256=Txmlxm606pkrN1fevTAAAmEkCoWPs49_coZJNmfiCSk,14450
@@ -183,7 +183,7 @@ meltygui/core/rendering/shaped.py,sha256=6jnm33vfb6U27RhNvXPB--ufxgVPi28FKTDkFGF
 meltygui/core/rendering/view_identity.py,sha256=QP_U-vY50_2BZmJQC5XdDHEfm3PSJ12fHLU1yAcuwh0,8678
 meltygui/core/rendering/window_decoration.py,sha256=tnwgqGH1qTQ6JAtZuFEn2UbGVDOJ2vEM5CTL4HsSgyo,491
 meltygui/core/runtime/__init__.py,sha256=aU32lxO4bl8_2zNk527p33s8IbbN-aBg-VfFeHLJQk8,42
-meltygui/core/runtime/app.py,sha256=g4aSZhWe0uaRWQRueHfP7vRCOTzg14vZtqcJPuvZ21o,43592
+meltygui/core/runtime/app.py,sha256=U0n7JZfSo6dCEsyT_w4pdXMDrX50RfQwxqw2rmVIjow,46337
 meltygui/core/runtime/app_session.py,sha256=52MTDyZJAZakgtgYZV9p0Y9IiRY-RbDtKZGCpbcfWVs,6327
 meltygui/core/runtime/app_settings.py,sha256=amcflSd7jhoHioy97_90U4Few3e9IZ4rS-ULTQ40GSw,7790
 meltygui/core/runtime/background.py,sha256=GgsxehbxZXrpSc0WDGzWZEczVs21dbMCK9CY_rxzvqw,24824
@@ -201,11 +201,11 @@ meltygui/core/services/__init__.py,sha256=BRdDyeLvek-RS-VygUhYck0AG7MZ440zSeEnoO
 meltygui/core/services/account_core.py,sha256=-LP4uXEjZn6yhgAGT8oNQTm0ltBzFAGH-rC2gjfKYfQ,299
 meltygui/core/services/chat_core.py,sha256=t9KkzqY4raq6Vi2cJau59gYNcfjKT0t2EZg9T1kr7X0,727
 meltygui/core/services/claude_terminal_core.py,sha256=Wue2qc4IyP-Ax9V2eOoSCnQi-XC0IEbvoZYeoYWquk0,16978
-meltygui/core/services/terminal_core.py,sha256=dGm3C5fNLeHoUXWgkeNaCUIJUbJxloJe-9ux9Z-4lBk,21752
+meltygui/core/services/terminal_core.py,sha256=jYxcnlumBy43CZBKhGzgLUwc6JzvnFUJETk8dt6AOQc,21909
 meltygui/core/services/terminal_runtime.py,sha256=AadnkQGvA0ahx-FqpBe8ZNekof9HDxLLdlcvDLzfWp8,2890
 meltygui/core/styling/__init__.py,sha256=cREBOWuRcF5jiDBSkCw8gJSmxNDl146z2BMHbxP_-JY,42
 meltygui/core/styling/color_core.py,sha256=qCtHCkAEXpueguvsXAeMXRPKIG3HOFnlqHYN4cE8MBA,1855
-meltygui/core/styling/fonts.py,sha256=H9xfmV3oEEka6fV3297mbdoaKueNR8-y9ou6PDwTIUw,30802
+meltygui/core/styling/fonts.py,sha256=eKhZVdNesvP9CdaQhDcs-NFSuNCbf-iPMgX37X6pzrU,31991
 meltygui/core/styling/global_style.py,sha256=HBvr9nwb4QEMFCE8oPZ2bYJoS7p-iAPk4--YpK3AvD8,9131
 meltygui/core/styling/style.py,sha256=sDB5KH70lWZeRv_HHoqPvIO6Wouhy49CaFSMS6ERQXc,9071
 meltygui/core/styling/style_core.py,sha256=5c-fFnyr34XkRfbzdH5KJkGUA5ZO88zMmzH6kUDPaI4,22639
@@ -214,10 +214,10 @@ meltygui/core/windowing/__init__.py,sha256=sxb996QyIPT-sdBwoRORUA_zo2TK2xJ6Uh0-b
 meltygui/core/windowing/dock_core.py,sha256=qRg1TqjRxjkgCo1reT20L-flFyX5vtM_mjHOFdPAGdc,8415
 meltygui/core/windowing/frame_geometry.py,sha256=jP9OzjYXhRAAKVIcge7AnW0aPGY72DSZtJSzCYuvtMw,1605
 meltygui/core/windowing/geometry_feed.py,sha256=O39MSf5r1e3MqruToZT6ZBC9ohykNk4lu35rtffMvHM,40289
-meltygui/core/windowing/glfw_utils.py,sha256=xNJcYC5op3u2MHA0NFgbZ45k_XJfLAyFALWB3qfIMkk,55023
-meltygui/core/windowing/os_frame.py,sha256=7l1BPp3i8gKYvCwciQ2QMQYuadqlWprqgqPkivavQ7Y,77124
-meltygui/core/windowing/surface.py,sha256=GWVVYyMZgJ5RBTcVMJ6yLmjILcBpXXPCFSQWDXhmy2w,36416
-meltygui/core/windowing/titlebar.py,sha256=dL1oY4E1pBUOxg6qrJFa0spwA3vS2a1U2jBtFKUHq3c,77703
+meltygui/core/windowing/glfw_utils.py,sha256=RfKAFdm0r3qXlNC-qfS6JBWklxo3lt6UUUzn8DX4Z1U,55586
+meltygui/core/windowing/os_frame.py,sha256=ywRa3afuRZ-dNaCKA1CdXdWHnLHy-kgRySygxoF9KzU,77602
+meltygui/core/windowing/surface.py,sha256=jGiRKXOtVIfEYyEc3kgzkS8su6c1KCqUaYw9P3Ry1ac,36568
+meltygui/core/windowing/titlebar.py,sha256=Cf-jIjTlImP6Qbfkt0E78ylMMlTGdIACE5-RRPL4pwU,79988
 meltygui/core/windowing/titlebar_buttons.py,sha256=sSrDcTg_c5l_ZE6WYm2rF8xg1u1lgzXvUPx7CTqKo9U,10828
 meltygui/core/windowing/wayland_move.py,sha256=LiAndHFsePNwU2I9azBDVZPoRpv9d2s_xZSBTcktoUA,41642
 meltygui/core/windowing/window_api.py,sha256=VcBQPVXvefp9mJhOV1C914R36J-GAz0syIC6QbGARjY,2340
@@ -284,7 +284,7 @@ meltygui/graphics/filter.py,sha256=uuEnIkrpzmaeR-87TA14J_VKn0fyVR-jx--eHgA9UBo,2
 meltygui/graphics/filter.pyi,sha256=wG9CeyTsShji_W95MXA_-1PQhwwaM0rRYniBc9N6FVM,35551
 meltygui/graphics/generate_stubs.py,sha256=-WUJanBHvIBkObgMb4HnoAm9SggStYbK1NQcX5tCd1A,599
 meltygui/graphics/registry.py,sha256=IMnJDopE-1MqIa0Ocopa8ESnfBxEMHx5yuynBG_Aglk,6198
-meltygui/graphics/shader_compiler.py,sha256=O9VBngR6DYv_WLuV3Rne7zq2ASbDfvB5h0bj3WyfqMQ,5356
+meltygui/graphics/shader_compiler.py,sha256=aeEtGJgXaXuRlayFMANHZklsXa1NfNGsUOZKJEHxTGY,5888
 meltygui/graphics/shaders.py,sha256=8lysNqIeuGLX9NPiX_VJ5l9gmZJ7zK5By2GMiaN5HQ8,46613
 meltygui/graphics/stub_generator.py,sha256=5i3kBhD0FOCEjydqHLoKmgs7lHRnj5KN6w_HcLyZ2Go,8765
 meltygui/graphics/texture_min_max.py,sha256=PcgSQYT3eonJbmj8I-z4Xk5EJEgXwfyF6UZdWHAAOvc,9941
@@ -411,7 +411,7 @@ meltygui/view/trace_view.py,sha256=pxcfvdx2evR745hBF72TH1D_5aEqX5GlYn_NBeYk4s8,5
 meltygui/view/voxel_cuda_view.py,sha256=KlIfRza6EvaJ-Mm9FVHxF4YCy9Vhb6kGenOdM-pJqAc,44045
 meltygui/view/voxel_view.py,sha256=mhtmUnOpCdXhDwtz3LEvEwQSRQaqXEBMPRDJKBP17VQ,101406
 meltygui/view/window_view.py,sha256=k9RNiWFtyO4jjYX51LeqnIPCt0cF8amY01KUCPkXivY,4982
-meltygui-0.1.2.dist-info/METADATA,sha256=V4PvSTc6RrZ-Cn73oUSXlcJmXepCWoDncd8D32fGCSs,5954
-meltygui-0.1.2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-meltygui-0.1.2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-meltygui-0.1.2.dist-info/RECORD,,
+meltygui-0.1.3.dist-info/METADATA,sha256=EAYgn_nuxkJzmY2xqb0lt3UXznp6U4TAHbozGym82Cg,6095
+meltygui-0.1.3.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+meltygui-0.1.3.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+meltygui-0.1.3.dist-info/RECORD,,