From 3918124153b0434a5ae78161bd44984e57ae2e3a Mon Sep 17 00:00:00 2001
From: Almar Klein <almar@almarklein.org>
Date: Fri, 10 Apr 2026 14:28:52 +0200
Subject: [PATCH] WIP native osx backend

---
 rendercanvas/MetalIOSurfaceHelper.m        |  90 +++++
 rendercanvas/_native_osx.py                | 387 +++++++++++++++++++++
 rendercanvas/libMetalIOSurfaceHelper.dylib | Bin 0 -> 85792 bytes
 3 files changed, 477 insertions(+)
 create mode 100644 rendercanvas/MetalIOSurfaceHelper.m
 create mode 100644 rendercanvas/_native_osx.py
 create mode 100755 rendercanvas/libMetalIOSurfaceHelper.dylib

diff --git a/rendercanvas/MetalIOSurfaceHelper.m b/rendercanvas/MetalIOSurfaceHelper.m
new file mode 100644
index 00000000..684b7931
--- /dev/null
+++ b/rendercanvas/MetalIOSurfaceHelper.m
@@ -0,0 +1,90 @@
+/*
+
+clang -dynamiclib -fobjc-arc \
+  -framework Foundation -framework Metal -framework IOSurface \
+  -arch x86_64 -arch arm64 \
+  -mmacosx-version-min=10.13 \
+  -o libMetalIOSurfaceHelper.dylib MetalIOSurfaceHelper.m
+
+  maybe add '-framework MetalKit' too
+
+*/
+#import <Foundation/Foundation.h>
+#import <Metal/Metal.h>
+#import <IOSurface/IOSurface.h>
+
+@interface MetalIOSurfaceHelper : NSObject
+@property (nonatomic, readonly) id<MTLDevice> device;
+@property (nonatomic, readonly) id<MTLTexture> texture;
+
+- (instancetype)initWithWidth:(NSUInteger)width
+                       height:(NSUInteger)height;
+
+- (void *)baseAddress;
+- (NSUInteger)bytesPerRow;
+@end
+
+
+@implementation MetalIOSurfaceHelper {
+    IOSurfaceRef _surf;
+}
+
+- (instancetype)initWithWidth:(NSUInteger)width
+                       height:(NSUInteger)height
+{
+    if ((self = [super init])) {
+        // Create Metal device
+        _device = MTLCreateSystemDefaultDevice();
+        if (!_device) {
+            NSLog(@"❌ Failed to create Metal device");
+            return nil;
+        }
+
+        // Create IOSurface properties
+        NSDictionary *props = @{
+            (id)kIOSurfaceWidth: @(width),
+            (id)kIOSurfaceHeight: @(height),
+            (id)kIOSurfaceBytesPerElement: @(4),
+            (id)kIOSurfacePixelFormat: @(0x42475241) // 'BGRA'
+        };
+
+        _surf = IOSurfaceCreate((__bridge CFDictionaryRef)props);
+        if (!_surf) {
+            NSLog(@"❌ Failed to create IOSurface");
+            return nil;
+        }
+
+        // Create texture from IOSurface
+        MTLTextureDescriptor *desc =
+            [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatBGRA8Unorm
+                                                                width:width
+                                                               height:height
+                                                            mipmapped:NO];
+        desc.storageMode = MTLStorageModeShared;
+
+        _texture = [_device newTextureWithDescriptor:desc iosurface:_surf plane:0];
+        if (!_texture) {
+            NSLog(@"❌ Failed to create MTLTexture from IOSurface");
+            CFRelease(_surf);
+            return nil;
+        }
+    }
+    return self;
+}
+
+- (void *)baseAddress {
+    return IOSurfaceGetBaseAddress(_surf);
+}
+
+- (NSUInteger)bytesPerRow {
+    return IOSurfaceGetBytesPerRow(_surf);
+}
+
+- (void)dealloc {
+    if (_surf) {
+        CFRelease(_surf);
+        _surf = NULL;
+    }
+}
+
+@end
\ No newline at end of file
diff --git a/rendercanvas/_native_osx.py b/rendercanvas/_native_osx.py
new file mode 100644
index 00000000..811901ba
--- /dev/null
+++ b/rendercanvas/_native_osx.py
@@ -0,0 +1,387 @@
+"""
+
+This uses rubicon to load objc classes, mainly for Cocoa (MacOS's
+windowing API). For rendering to bitmap we follow the super-fast
+approach of creating an IOSurface that is wrapped in a Metal texture.
+On Apple silicon, the memory for that texture is in RAM, so we can write
+directly to the texture, no copies. This approach is used by e.g. video
+viewers.
+
+However, because Python (via Rubicon) cannot pass or create pure C-level
+IOSurfaceRef pointers, which are required by Metal’s
+newTextureWithDescriptor:iosurface:plane; Rubicon can only work with
+actual Objective-C objects.
+
+Therefore this code relies on a mirco objc libary that is shipped along
+in rendercanvas. This dylib handles the C-level IOSurface creation and
+wraps it in a proper MTLTexture that Python can safely use.
+"""
+
+# ruff: noqa - for now
+
+import os
+import time
+import ctypes
+
+import numpy as np  # TODO: no numpy?
+from rubicon.objc import ObjCClass, objc_method, ObjCInstance
+from rubicon.objc.runtime import load_library
+from rubicon.objc.types import NSRect, NSPoint, NSSize
+
+from .base import BaseCanvasGroup, BaseRenderCanvas
+from .asyncio import loop
+
+load_library("AppKit")
+# load_framework(
+#     ctypes.util.find_library("MetalKit"),
+#     framework_name="MetalKit"
+#     )
+
+__all__ = ["RenderCanvas", "CocoaRenderCanvas", "loop"]
+
+
+NSApplication = ObjCClass("NSApplication")
+NSWindow = ObjCClass("NSWindow")
+NSObject = ObjCClass("NSObject")
+
+
+# Application and window
+app = NSApplication.sharedApplication
+
+app.setActivationPolicy_(0)  # NSApplicationActivationPolicyRegular
+app.activateIgnoringOtherApps_(True)
+
+SHADER = """
+#include <metal_stdlib>
+using namespace metal;
+
+struct VertexOut {
+    float4 position [[position]];
+    float2 texcoord;
+};
+
+vertex VertexOut vertex_main(uint vertexID [[vertex_id]]) {
+    float2 pos[3] = {
+        float2(-1.0, -1.0),
+        float2( 3.0, -1.0),
+        float2(-1.0,  3.0)
+    };
+    VertexOut out;
+    out.position = float4(pos[vertexID], 0.0, 1.0);
+    out.texcoord = (pos[vertexID] * float2(1.0, -1.0) + 1.0) * 0.5;
+    return out;
+}
+
+fragment float4 fragment_main(VertexOut in [[stage_in]],
+                            texture2d<float> tex [[texture(0)]],
+                            sampler samp [[sampler(0)]]) {
+    constexpr sampler linearSampler(address::clamp_to_edge, filter::linear);
+    float4 color = tex.sample(linearSampler, in.texcoord);
+    return color;
+}
+"""
+
+
+class MetalRenderer(NSObject):
+    @objc_method
+    def initWithDevice_(self, device):  # -> ctypes.c_void_p:
+        self.init()
+        # self = ObjCInstance(send_message(self, "init"))
+        if self is None:
+            return None
+        self.device = device
+        self.queue = device.newCommandQueue()
+
+        self.texture = None
+
+        # --- Metal shader code ---
+
+        options = {}
+        error_placeholder = None  # ctypes.c_void_p()
+        library = device.newLibraryWithSource_options_error_(
+            SHADER, None, error_placeholder
+        )
+        if not library:
+            print("Shader compile failed:", error_placeholder)
+            return self
+
+        vertex_func = library.newFunctionWithName_("vertex_main")
+        frag_func = library.newFunctionWithName_("fragment_main")
+
+        desc = ObjCClass("MTLRenderPipelineDescriptor").alloc().init()
+        desc.vertexFunction = vertex_func
+        desc.fragmentFunction = frag_func
+        desc.colorAttachments.objectAtIndexedSubscript_(
+            0
+        ).pixelFormat = 80  # BGRA8Unorm
+
+        self.pipeline = device.newRenderPipelineStateWithDescriptor_error_(
+            desc, error_placeholder
+        )
+        if not self.pipeline:
+            print("Pipeline creation failed:", error_placeholder)
+        return self
+
+    @objc_method
+    def setTexture_(self, texture):
+        self.texture = texture
+
+    @objc_method
+    def drawInMTKView_(self, view):
+        drawable = view.currentDrawable
+        if drawable is None:
+            return
+
+        passdesc = ObjCClass("MTLRenderPassDescriptor").renderPassDescriptor()
+        passdesc.colorAttachments.objectAtIndexedSubscript_(
+            0
+        ).texture = drawable.texture
+        passdesc.colorAttachments.objectAtIndexedSubscript_(0).loadAction = 2  # Clear
+        passdesc.colorAttachments.objectAtIndexedSubscript_(0).storeAction = 1  # Store
+        passdesc.colorAttachments.objectAtIndexedSubscript_(
+            0
+        ).clearColor = view.clearColor
+
+        cmd_buf = self.queue.commandBuffer()
+        enc = cmd_buf.renderCommandEncoderWithDescriptor_(passdesc)
+
+        enc.setRenderPipelineState_(self.pipeline)
+        enc.setFragmentTexture_atIndex_(self.texture, 0)
+
+        enc.setRenderPipelineState_(self.pipeline)
+        enc.drawPrimitives_vertexStart_vertexCount_(3, 0, 3)
+        enc.endEncoding()
+        cmd_buf.presentDrawable_(drawable)
+        cmd_buf.commit()
+        # cmd_buf.waitUntilCompleted()
+
+    @objc_method
+    def mtkView_drawableSizeWillChange_(self, view, newSize):
+        # Update if needed
+        # print("resize", newSize)
+        pass
+
+
+class CocoaCanvasGroup(BaseCanvasGroup):
+    pass
+
+
+class CocoaRenderCanvas(BaseRenderCanvas):
+    """A native canvas for OSX using Cocoa."""
+
+    _rc_canvas_group = CocoaCanvasGroup(loop)
+
+    _helper_dylib = None
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        # Define window style
+        NSWindowStyleMaskTitled = 1 << 0
+        NSBackingStoreBuffered = 2
+        NSTitledWindowMask = 1 << 0
+        NSClosableWindowMask = 1 << 1
+        NSMiniaturizableWindowMask = 1 << 2
+        NSResizableWindowMask = 1 << 3
+        style_mask = (
+            NSTitledWindowMask
+            | NSClosableWindowMask
+            | NSMiniaturizableWindowMask
+            | NSResizableWindowMask
+        )
+
+        rect = NSRect(NSPoint(100, 100), NSSize(100, 100))
+        self._window = NSWindow.alloc().initWithContentRect_styleMask_backing_defer_(
+            rect, style_mask, NSBackingStoreBuffered, False
+        )
+        self._window.makeKeyAndOrderFront_(None)  # focus
+        self._keep_notified_of_resizes()
+
+        # Start out with no bitmap present enabled. Will do that jit when needed.
+        self._texture = None
+        self._renderer = None
+
+        self._final_canvas_init()
+
+    def _keep_notified_of_resizes(self):
+        def update_size():
+            pixel_ratio = self._window.screen.backingScaleFactor
+            size = self._window.frame.size
+            pwidth = int(size.width * pixel_ratio)
+            pheight = int(size.height * pixel_ratio)
+            print("new size", pwidth, pheight)
+            self._size_info.set_physical_size(pwidth, pheight, pixel_ratio)
+
+        class WindowDelegate(NSObject):
+            @objc_method
+            def windowDidResize_(self, notification):
+                update_size()
+
+            @objc_method
+            def windowDidChangeBackingProperties_(self, notification):
+                update_size()
+
+        self._delegate1 = WindowDelegate.alloc().init()
+        self._delegate2 = self._window.setDelegate_(self._delegate1)
+        update_size()
+
+    def _setup_for_bitmap_present(self):
+        # Create the helper first, because it also creates the device
+        self._create_surface_texture_array(1, 1)
+
+        # # Create more components
+        self._create_renderer()
+        self._create_mtk_view()
+
+        # TODO: move the _create_renderer, _create_mtk_view, and maybe _create_surface_texture_array to functions or a helper class
+        # -> keep bitmap/metal logic more separate
+
+    def _create_renderer(self):
+        # Instantiate the renderer and set as delegate
+        # renderer = MetalRenderer.alloc().init()
+        self._renderer = MetalRenderer.alloc().initWithDevice_(self._device)
+
+    def _create_mtk_view(self):
+        # Create MTKView
+        MTKView = ObjCClass("MTKView")
+        mtk_view = MTKView.alloc().initWithFrame_device_(
+            self._window.contentView.bounds, self._device
+        )
+        # Ensure we can write into the view's texture (not framebuffer-only) if we want to upload into it
+        try:
+            mtk_view.setFramebufferOnly_(False)
+        except Exception:
+            pass  # Not all setups require this call; ignore if not present
+
+        # TODO: use RGBA
+        # TODO: support yuv420p or something
+        # Choose pixel format. We'll assume BGRA8Unorm for Metal.
+        mtk_view.setColorPixelFormat_(80)  # MTLPixelFormatBGRA8Unorm
+
+        self._window.setContentView_(mtk_view)
+        mtk_view.setDelegate_(self._renderer)
+
+        # ?? vsync?
+        # mtk_view.enableSetNeedsDisplay = False
+        # mtk_view.preferredFramesPerSecond = 60
+
+        self._mtkView = mtk_view
+
+    def _create_surface_texture_array(self, width, height):
+        print("creating new texture")
+        if CocoaRenderCanvas._helper_dylib is None:
+            # Load our helper dylib to make its objc class available to rubicon.
+            CocoaRenderCanvas._helper_dylib = ctypes.CDLL(
+                os.path.abspath(
+                    os.path.join(__file__, "..", "libMetalIOSurfaceHelper.dylib")
+                )
+            )
+
+        # Init our little helper helper
+        MetalIOSurfaceHelper = ObjCClass("MetalIOSurfaceHelper")
+        self._helper = MetalIOSurfaceHelper.alloc().initWithWidth_height_(width, height)
+        self._texture = self._helper.texture
+        self._device = self._helper.device
+
+        # Access CPU memory
+        base_addr = self._helper.baseAddress()
+        bytes_per_row = self._helper.bytesPerRow()
+
+        # Map array onto the shared memory
+        total_bytes = bytes_per_row * height
+        array_type = ctypes.c_uint8 * total_bytes
+        pixel_buf = array_type.from_address(base_addr.value)
+        self._texture_array = np.frombuffer(
+            pixel_buf, dtype=np.uint8, count=total_bytes
+        )
+        self._texture_array.shape = height, -1
+        self._texture_array = self._texture_array[:, : width * 4]
+        self._texture_array.shape = height, width, 4
+
+        if self._renderer is not None:
+            self._renderer.setTexture(self._texture)
+
+    def _rc_gui_poll(self):
+        for mode in ("kCFRunLoopDefaultMode", "NSEventTrackingRunLoopMode"):
+            # Drain events (non-blocking). If we don't drain events, the animation becomes jaggy when e.g. the mouse moves.
+            # TODO: this seems to work, but lets check what happens here
+            while True:
+                event = app.nextEventMatchingMask_untilDate_inMode_dequeue_(
+                    0xFFFFFFFFFFFFFFFF,  # all events
+                    None,  # don't wait
+                    mode,
+                    True,
+                )
+                if event:
+                    app.sendEvent_(event)
+                else:
+                    break
+
+    def _rc_get_present_info(self, present_methods):
+        # Select method
+        the_method = present_methods[0]
+
+        # Apply
+        if the_method == "screen":
+            return {
+                "method": "screen",
+                "platform": "cocoa",
+                "window": self._window.ptr.value,
+            }
+        elif the_method == "bitmap":
+            return {
+                "method": "bitmap",
+                "formats": ["rgba-u8"],
+            }
+        else:
+            return None  # raises error
+
+    def _rc_request_draw(self):
+        # For this backend there's no need to wait (a direct call is allowed).
+        self._time_to_draw()
+
+    def _rc_request_paint(self):
+        # Schedule a new paint (a direct call is not allowed).
+        loop = self._rc_canvas_group.get_loop()
+        loop.call_soon(self._paint)
+
+    def _rc_force_paint(self):
+        self._paint()
+        app.updateWindows()  # does not work?
+
+    def _paint(self):
+        self._time_to_paint()
+        # app.updateWindows()  # I also want to update one
+
+    def _rc_present_bitmap(self, *, data, format, **kwargs):
+        if not self._texture:
+            self._setup_for_bitmap_present()
+        if data.shape[:2] != self._texture_array.shape[:2]:
+            self._create_surface_texture_array(data.shape[1], data.shape[0])
+
+        self._texture_array[:] = data
+        # print("present bitmap", data.shape)
+        # self._window.contentView.setNeedsDisplay_(True)
+        # self._mtkView.setNeedsDisplay_(True)
+
+    def _rc_set_logical_size(self, width, height):
+        frame = self._window.frame
+        frame.size.width = width
+        frame.size.height = height
+        self._window.setFrame_display_animate_(frame, True, False)
+
+    def _rc_close(self):
+        pass
+
+    def _rc_get_closed(self):
+        return False
+
+    def _rc_set_title(self, title):
+        self._window.setTitle_(title)
+
+    def _rc_set_cursor(self, cursor):
+        pass
+
+
+# Make available under a common name
+RenderCanvas = CocoaRenderCanvas
diff --git a/rendercanvas/libMetalIOSurfaceHelper.dylib b/rendercanvas/libMetalIOSurfaceHelper.dylib
new file mode 100755
index 0000000000000000000000000000000000000000..cc7457fb75f73510891272556676663ac1d51be1
GIT binary patch
literal 85792
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
Ir$+I=0LRyN4gdfE

literal 0
HcmV?d00001