metaco 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fafdd0cb9aab0b39bca483167bb12a6caf1bedea3f4270af88badfd21f2e0ab7
-  data.tar.gz: 4f41f6f4b2ea9b826c799abddf2cfcb09d8d64724e6ac910a45237596774cb8b
+  metadata.gz: 56719f087b9757be4e9f9b47df20a2be5e48e30fffe781c130c982a4d5da0593
+  data.tar.gz: 9be3b5f19b8d255953964097538d705fbd00ca184b7301ecc51acbeeecad6f49
 SHA512:
-  metadata.gz: 229d3371dc99c8248aa8e676264d3f67c240542d22ea676ff9ef90a1ff60e11770d1ff34d059c0eb14f9a3f0b29ce957e247c61df46e556df69c6c22826a47c2
-  data.tar.gz: e5c641c5d10a0dc278f2405e5f61b8e8fc4097450bf441fe56601953576d963ec8ec7dd30622c8a20be7be8ced73ff61137e31551840548263b01daf3cae58f3
+  metadata.gz: fb8667d5665d9392cd1d8efec9128211f83be708e82f2a8eebcfe3623fc2deb3dd4785daf8756e286d6edd378cfe316d2898fd7def72e94a777d846cee13a0d1
+  data.tar.gz: c83bd6e0bf4164c9af4028e7103219d4005a7bd6df06fab57dc8db365381692fd986ba5a9c8d2d5740fa82b835470df504c1eecd8fb054dc98e0c7dcf3ecb810

data/CHANGELOG.md

@@ -1,7 +1,13 @@
 # Changelog
 
-## Unreleased
+## 0.2.0 - 2026-09-09
+
+- Replace integer window pointers with GC-managed `Metaco::Window` handles. Validate closed handles, main-thread access, dimensions, and pixel buffer capacity.
+- Preserve Ruby exception cleanup, UTF-8/NUL key input, and right/middle mouse and drag events. Complete the unsupported-platform API without hiding macOS load errors.
+- Preserve RGBA colors through a Metal render pass, synchronize GPU work without holding the GVL, propagate GPU errors, and validate all rendering/compute allocations.
+- Keep the previous shader on recompilation failure; reject uniforms over 256 bytes and zero unused bytes. Dispatch exactly the image dimensions within pipeline limits.
+- Add native pixel readback and fault-injection regressions; run GUI tests in macOS CI and support mandatory Metal validation on a GPU runner.
 
 ## 0.1.0 - 2026-01-02
 
-- Initial release.
+- Initial release.

data/README.md

@@ -87,6 +87,7 @@ if Metaco.metal_compute_available?(handle)
         constant float4 &uniforms [[buffer(0)]],
         uint2 gid [[thread_position_in_grid]])
     {
+        if (gid.x >= output.get_width() || gid.y >= output.get_height()) return;
         float2 uv = float2(gid) / float2(output.get_width(), output.get_height());
         output.write(float4(uv.x, uv.y, uniforms.x, 1.0), gid);
     }
@@ -114,8 +115,8 @@ Metaco.window_destroy(handle)
 | Method | Description |
 |--------|-------------|
 | `init` | Initialize Cocoa application |
-| `window_create(width, height, title)` | Create a new window, returns handle |
-| `window_destroy(handle)` | Destroy the window |
+| `window_create(width, height, title)` | Create a new window, returns a `Metaco::Window` handle |
+| `window_destroy(handle)` | Close and release the window; repeated calls are safe |
 | `should_close?(handle)` | Check if window should close |
 | `poll_events(handle)` | Poll and return pending events |
 
@@ -124,7 +125,7 @@ Metaco.window_destroy(handle)
 | Method | Description |
 |--------|-------------|
 | `set_pixels(handle, buffer, width, height)` | Set pixel data (RGBA format) |
-| `present(handle)` | Present the frame |
+| `present(handle)` | Present the frame and wait for GPU completion |
 
 ### Compute Shaders
 
@@ -132,8 +133,8 @@ Metaco.window_destroy(handle)
 |--------|-------------|
 | `metal_compute_available?(handle)` | Check if Metal compute is available |
 | `compile_compute_shader(handle, msl_source)` | Compile MSL compute shader |
-| `dispatch_compute(handle, uniforms)` | Execute compute shader |
-| `present_compute(handle)` | Present compute shader output |
+| `dispatch_compute(handle, uniforms)` | Execute compute shader and wait for GPU completion |
+| `present_compute(handle)` | Present compute shader output and wait for GPU completion |
 | `has_compute_shader?(handle)` | Check if shader is compiled |
 
 ### Event Types
@@ -144,6 +145,19 @@ Metaco.window_destroy(handle)
 - `:mouse_release` - Mouse button released (`:x`, `:y`, `:button`)
 - `:mouse_move` - Mouse moved (`:x`, `:y`)
 
+### API contracts
+
+- Call `init` before creating windows. All native APIs must run on the process's main thread; worker-thread calls raise `ThreadError`. GPU completion waits release Ruby's GVL.
+- Handles are opaque `Metaco::Window` objects, replacing the integer pointers returned by 0.1.0. Pass them unchanged to Metaco methods. A closed handle raises `ArgumentError` on operations other than `window_destroy`; unrelated objects raise `TypeError`.
+- Release windows in an `ensure` block. GC also releases abandoned windows, scheduling AppKit cleanup on the main thread when necessary; `poll_events` services this queue.
+- Width and height must be between 1 and 16,384. `set_pixels` requires the original window dimensions and at least `width * height * 4` bytes of row-major RGBA data, with unpremultiplied alpha. Extra trailing bytes are ignored. Invalid dimensions or short buffers raise `ArgumentError`.
+- Titles and shader sources must contain valid UTF-8. Key event `:char` strings use UTF-8 and preserve embedded NUL characters. Mouse buttons are numbered 0 (left), 1 (right), and 2 (middle); dragging produces `:mouse_move` events.
+- Compute shaders use the entry point `compute_shader`, output texture 0, and a uniform buffer at index 0. Uniforms may contain 0–256 bytes; remaining bytes are zeroed on every dispatch. Larger inputs raise `ArgumentError`. Shader uniform structures must fit within 256 bytes.
+- Failed compilation preserves the previous shader and its resources. Dispatch and compute presentation require a compiled shader. GPU command failures raise `RuntimeError` after native resources have been cleaned up.
+- Dispatch covers exactly the window's pixels. Threadgroup dimensions may vary by pipeline and image width; shaders must not assume a fixed group size. The example's bounds check also makes it safe with other dispatch implementations.
+- Presentation is synchronous so pixel uploads cannot overwrite an in-flight frame. An occluded window may have no drawable, in which case presentation is skipped. Rendering resource allocation failures select the bitmap fallback; compute availability then returns `false`.
+- On unsupported platforms both compute availability queries return `false`, and other APIs raise `LoadError`. On macOS, native extension loading errors retain their original diagnostics.
+
 ## Development
 
 ```bash
@@ -155,8 +169,15 @@ bundle exec rake compile
 
 # Run tests
 bundle exec rake test
+
+# Require actual GPU execution and validate Metal commands/shaders
+METACO_REQUIRE_METAL=1 MTL_DEBUG_LAYER=1 MTL_SHADER_VALIDATION=1 bundle exec rake test
 ```
 
+The test task includes a separate native test extension for GPU pixel readback, allocation and command failure injection, Unicode input, and GC/exception cleanup. These helpers are excluded from the gem. CI runs window and bitmap tests on macOS even when Metal is unavailable; only GPU-specific tests are omitted in that case. Set `METACO_SKIP_GUI=1` explicitly for a session without WindowServer. Argument and fallback tests still run.
+
+The optional `run_metal` workflow-dispatch input runs the same suite with mandatory GPU execution on a self-hosted runner labeled `macOS` and `metal`. It requires a logged-in GUI session and a Metal device.
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](LICENSE).

data/Rakefile

@@ -3,6 +3,7 @@
 require "bundler/gem_tasks"
 require "rake/extensiontask"
 require "rake/testtask"
+require "rbconfig"
 
 Rake::ExtensionTask.new("metaco") do |ext|
   ext.lib_dir = "lib/metaco"
@@ -14,5 +15,18 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/test_*.rb"]
 end
 
-task test: :compile
+desc "Run native regression tests with GPU readback and fault injection"
+task :test_native do
+  next unless RUBY_PLATFORM.include?("darwin")
+
+  build_dir = File.expand_path("tmp/native/#{RUBY_PLATFORM}/#{RUBY_VERSION}", __dir__)
+  mkdir_p build_dir
+  Dir.chdir(build_dir) do
+    ruby File.expand_path("test/native/extconf.rb", __dir__)
+    sh RbConfig::CONFIG.fetch("MAKE", "make")
+  end
+  ruby "-I#{build_dir}", "test/native/regressions.rb"
+end
+
+task test: [:compile, :test_native]
 task default: :test

data/ext/metaco/metaco.m

@@ -6,53 +6,33 @@
 #import <Metal/Metal.h>
 #import <QuartzCore/CAMetalLayer.h>
 #import <ruby.h>
+#import <ruby/thread.h>
+#include <limits.h>
+#include <pthread.h>
+#include <stdint.h>
+
+static void native_error(NSError **error, NSString *message) {
+    if (error) *error = [NSError errorWithDomain:@"Metaco" code:1
+                                      userInfo:@{NSLocalizedDescriptionKey: message}];
+}
 
 @interface MetacoMetalView : NSView
 @property (nonatomic, strong) CAMetalLayer *metalLayer;
 @property (nonatomic, strong) id<MTLDevice> device;
 @property (nonatomic, strong) id<MTLCommandQueue> commandQueue;
 @property (nonatomic, strong) id<MTLTexture> texture;
+@property (nonatomic, strong) id<MTLRenderPipelineState> renderPipeline;
 @property (nonatomic, assign) int texWidth;
 @property (nonatomic, assign) int texHeight;
-// Compute shader support
 @property (nonatomic, strong) id<MTLComputePipelineState> computePipeline;
 @property (nonatomic, strong) id<MTLBuffer> uniformBuffer;
 @property (nonatomic, strong) id<MTLTexture> outputTexture;
-@property (nonatomic, assign) BOOL hasComputeShader;
+@property (nonatomic, readonly) BOOL hasComputeShader;
 @end
 
 @implementation MetacoMetalView
 
-- (void)cleanup {
-    // Only cleanup if we have resources
-    if (!self.device) return;
-
-    // Wait for GPU to finish before releasing resources
-    if (self.commandQueue) {
-        @try {
-            id<MTLCommandBuffer> syncBuffer = [self.commandQueue commandBuffer];
-            if (syncBuffer) {
-                [syncBuffer commit];
-                [syncBuffer waitUntilCompleted];
-            }
-        } @catch (NSException *e) {
-            // Ignore exceptions during cleanup
-        }
-    }
-
-    // Clear all Metal resources
-    self.computePipeline = nil;
-    self.uniformBuffer = nil;
-    self.outputTexture = nil;
-    self.texture = nil;
-    self.commandQueue = nil;
-    self.metalLayer = nil;
-    self.device = nil;
-    self.hasComputeShader = NO;
-}
-
-// dealloc is handled automatically by ARC - no manual cleanup needed
-// cocoa_window_destroy handles synchronization with GPU before release
+- (BOOL)hasComputeShader { return self.computePipeline != nil; }
 
 - (instancetype)initWithFrame:(NSRect)frame device:(id<MTLDevice>)device width:(int)w height:(int)h {
     self = [super initWithFrame:frame];
@@ -60,163 +40,155 @@
         self.device = device;
         self.texWidth = w;
         self.texHeight = h;
+        self.commandQueue = [device newCommandQueue];
+        if (!self.commandQueue) return nil;
+
+        // A render pass preserves RGBA channel meaning when writing a BGRA drawable.
+        NSString *source = @"#include <metal_stdlib>\n"
+            "using namespace metal;\n"
+            "vertex float4 metaco_vertex(uint i [[vertex_id]]) {\n"
+            "  const float2 p[] = {float2(-1,-1), float2(3,-1), float2(-1,3)};\n"
+            "  return float4(p[i], 0, 1);\n"
+            "}\n"
+            "fragment float4 metaco_fragment(float4 p [[position]],\n"
+            "  texture2d<float> input [[texture(0)]]) { return input.read(uint2(p.xy)); }\n";
+        id<MTLLibrary> library = [device newLibraryWithSource:source options:nil error:nil];
+        if (!library) return nil;
+        MTLRenderPipelineDescriptor *pipeline = [MTLRenderPipelineDescriptor new];
+        pipeline.vertexFunction = [library newFunctionWithName:@"metaco_vertex"];
+        pipeline.fragmentFunction = [library newFunctionWithName:@"metaco_fragment"];
+        pipeline.colorAttachments[0].pixelFormat = MTLPixelFormatBGRA8Unorm;
+        if (!pipeline.vertexFunction || !pipeline.fragmentFunction) return nil;
+        self.renderPipeline = [device newRenderPipelineStateWithDescriptor:pipeline error:nil];
+        if (!self.renderPipeline) return nil;
+
+        MTLTextureDescriptor *desc = [MTLTextureDescriptor
+            texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA8Unorm width:w height:h mipmapped:NO];
+        desc.usage = MTLTextureUsageShaderRead;
+        desc.storageMode = MTLStorageModeManaged;
+        if (@available(macOS 10.15, *)) {
+            if (device.hasUnifiedMemory) desc.storageMode = MTLStorageModeShared;
+        }
+        self.texture = [device newTextureWithDescriptor:desc];
+        if (!self.texture) return nil;
 
         self.wantsLayer = YES;
         self.metalLayer = [CAMetalLayer layer];
+        if (!self.metalLayer) return nil;
         self.metalLayer.device = device;
         self.metalLayer.pixelFormat = MTLPixelFormatBGRA8Unorm;
-        self.metalLayer.framebufferOnly = NO;
-        self.metalLayer.displaySyncEnabled = NO;  // Disable VSync for max FPS
+        self.metalLayer.framebufferOnly = YES;
+        self.metalLayer.displaySyncEnabled = NO;
         self.metalLayer.frame = frame;
         self.metalLayer.drawableSize = CGSizeMake(w, h);
         self.layer = self.metalLayer;
-
-        self.commandQueue = [device newCommandQueue];
-
-        // Create texture for pixel data
-        MTLTextureDescriptor *texDesc = [MTLTextureDescriptor texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA8Unorm
-                                                                                           width:w
-                                                                                          height:h
-                                                                                       mipmapped:NO];
-        texDesc.usage = MTLTextureUsageShaderRead;
-        self.texture = [device newTextureWithDescriptor:texDesc];
     }
     return self;
 }
 
 - (void)updatePixels:(const uint8_t *)data {
-    MTLRegion region = MTLRegionMake2D(0, 0, self.texWidth, self.texHeight);
-    [self.texture replaceRegion:region mipmapLevel:0 withBytes:data bytesPerRow:self.texWidth * 4];
+    [self.texture replaceRegion:MTLRegionMake2D(0, 0, self.texWidth, self.texHeight)
+                    mipmapLevel:0 withBytes:data bytesPerRow:(size_t)self.texWidth * 4];
 }
 
-- (void)present {
-    id<CAMetalDrawable> drawable = [self.metalLayer nextDrawable];
-    if (!drawable) return;
+- (BOOL)renderTexture:(id<MTLTexture>)source toTexture:(id<MTLTexture>)target
+       commandBuffer:(id<MTLCommandBuffer>)commandBuffer error:(NSError **)error {
+    MTLRenderPassDescriptor *pass = [MTLRenderPassDescriptor renderPassDescriptor];
+    pass.colorAttachments[0].texture = target;
+    pass.colorAttachments[0].loadAction = MTLLoadActionDontCare;
+    pass.colorAttachments[0].storeAction = MTLStoreActionStore;
+    id<MTLRenderCommandEncoder> encoder = [commandBuffer renderCommandEncoderWithDescriptor:pass];
+    if (!encoder) {
+        native_error(error, @"Failed to create render encoder");
+        return NO;
+    }
+    [encoder setRenderPipelineState:self.renderPipeline];
+    [encoder setFragmentTexture:source atIndex:0];
+    [encoder drawPrimitives:MTLPrimitiveTypeTriangle vertexStart:0 vertexCount:3];
+    [encoder endEncoding];
+    return YES;
+}
 
+- (id<MTLCommandBuffer>)presentTexture:(id<MTLTexture>)texture error:(NSError **)error {
+    id<CAMetalDrawable> drawable = [self.metalLayer nextDrawable];
+    if (!drawable) return nil; // An occluded window can temporarily have no drawable.
     id<MTLCommandBuffer> commandBuffer = [self.commandQueue commandBuffer];
-
-    // Blit texture to drawable
-    id<MTLBlitCommandEncoder> blitEncoder = [commandBuffer blitCommandEncoder];
-
-    [blitEncoder copyFromTexture:self.texture
-                     sourceSlice:0
-                     sourceLevel:0
-                    sourceOrigin:MTLOriginMake(0, 0, 0)
-                      sourceSize:MTLSizeMake(self.texWidth, self.texHeight, 1)
-                       toTexture:drawable.texture
-                destinationSlice:0
-                destinationLevel:0
-               destinationOrigin:MTLOriginMake(0, 0, 0)];
-
-    [blitEncoder endEncoding];
-
+    if (!commandBuffer) {
+        native_error(error, @"Failed to create render command buffer");
+        return nil;
+    }
+    if (![self renderTexture:texture toTexture:drawable.texture commandBuffer:commandBuffer error:error]) return nil;
     [commandBuffer presentDrawable:drawable];
-    [commandBuffer commit];
+    return commandBuffer;
 }
 
-#pragma mark - Compute Shader Support
-
 - (BOOL)compileComputeShader:(NSString *)mslSource error:(NSError **)error {
-    // Compile MSL source to library
-    id<MTLLibrary> library = [self.device newLibraryWithSource:mslSource
-                                                       options:nil
-                                                         error:error];
+    id<MTLLibrary> library = [self.device newLibraryWithSource:mslSource options:nil error:error];
     if (!library) return NO;
-
-    // Get compute function
-    id<MTLFunction> computeFunc = [library newFunctionWithName:@"compute_shader"];
-    if (!computeFunc) {
-        if (error) *error = [NSError errorWithDomain:@"Metaco" code:1
-                                            userInfo:@{NSLocalizedDescriptionKey: @"compute_shader function not found"}];
+    id<MTLFunction> function = [library newFunctionWithName:@"compute_shader"];
+    if (!function) {
+        native_error(error, @"compute_shader function not found");
         return NO;
     }
+    id<MTLComputePipelineState> pipeline = [self.device newComputePipelineStateWithFunction:function error:error];
+    if (!pipeline) return NO;
 
-    // Create compute pipeline
-    self.computePipeline = [self.device newComputePipelineStateWithFunction:computeFunc error:error];
-    if (!self.computePipeline) return NO;
-
-    // Create output texture (writable)
-    MTLTextureDescriptor *texDesc = [MTLTextureDescriptor
+    MTLTextureDescriptor *desc = [MTLTextureDescriptor
         texture2DDescriptorWithPixelFormat:MTLPixelFormatRGBA8Unorm
-                                     width:self.texWidth
-                                    height:self.texHeight
-                                 mipmapped:NO];
-    texDesc.usage = MTLTextureUsageShaderWrite | MTLTextureUsageShaderRead;
-    self.outputTexture = [self.device newTextureWithDescriptor:texDesc];
-
-    // Create uniform buffer (256 bytes should be enough for most shaders)
-    self.uniformBuffer = [self.device newBufferWithLength:256
-                                                  options:MTLResourceStorageModeShared];
+                                     width:self.texWidth height:self.texHeight mipmapped:NO];
+    desc.usage = MTLTextureUsageShaderWrite | MTLTextureUsageShaderRead;
+    desc.storageMode = MTLStorageModePrivate;
+    id<MTLTexture> output = [self.device newTextureWithDescriptor:desc];
+    id<MTLBuffer> uniforms = [self.device newBufferWithLength:256 options:MTLResourceStorageModeShared];
+    if (!output || !uniforms || !uniforms.contents) {
+        native_error(error, @"Failed to allocate compute resources");
+        return NO;
+    }
 
-    self.hasComputeShader = YES;
+    // Publish the new state only after every resource has been created.
+    self.computePipeline = pipeline;
+    self.outputTexture = output;
+    self.uniformBuffer = uniforms;
     return YES;
 }
 
-- (void)dispatchComputeWithUniforms:(const void *)uniformData length:(NSUInteger)length {
-    if (!self.hasComputeShader) return;
-
-    // Update uniform buffer
-    memcpy(self.uniformBuffer.contents, uniformData, MIN(length, 256));
-
-    id<MTLCommandBuffer> commandBuffer = [self.commandQueue commandBuffer];
-    id<MTLComputeCommandEncoder> computeEncoder = [commandBuffer computeCommandEncoder];
-
-    [computeEncoder setComputePipelineState:self.computePipeline];
-    [computeEncoder setTexture:self.outputTexture atIndex:0];
-    [computeEncoder setBuffer:self.uniformBuffer offset:0 atIndex:0];
-
-    // Calculate optimal thread group size
-    NSUInteger threadGroupSize = self.computePipeline.maxTotalThreadsPerThreadgroup;
-    NSUInteger threadGroupWidth = 16;
-    NSUInteger threadGroupHeight = 16;
-
-    if (threadGroupWidth * threadGroupHeight > threadGroupSize) {
-        threadGroupWidth = 8;
-        threadGroupHeight = 8;
+- (id<MTLCommandBuffer>)dispatchComputeWithUniforms:(const void *)data length:(NSUInteger)length
+                                            error:(NSError **)error {
+    if (!self.hasComputeShader || length > 256) {
+        native_error(error, @"Invalid compute state or uniform size");
+        return nil;
     }
-
-    MTLSize threadsPerGroup = MTLSizeMake(threadGroupWidth, threadGroupHeight, 1);
-    MTLSize threadGroups = MTLSizeMake(
-        (self.texWidth + threadGroupWidth - 1) / threadGroupWidth,
-        (self.texHeight + threadGroupHeight - 1) / threadGroupHeight,
-        1
-    );
-
-    [computeEncoder dispatchThreadgroups:threadGroups threadsPerThreadgroup:threadsPerGroup];
-    [computeEncoder endEncoding];
-
-    [commandBuffer commit];
-    [commandBuffer waitUntilCompleted];
-}
-
-- (void)presentCompute {
-    if (!self.hasComputeShader) return;
-
-    id<CAMetalDrawable> drawable = [self.metalLayer nextDrawable];
-    if (!drawable) return;
-
+    memset(self.uniformBuffer.contents, 0, 256);
+    memcpy(self.uniformBuffer.contents, data, length);
     id<MTLCommandBuffer> commandBuffer = [self.commandQueue commandBuffer];
-    id<MTLBlitCommandEncoder> blitEncoder = [commandBuffer blitCommandEncoder];
-
-    // Blit from compute output to drawable
-    [blitEncoder copyFromTexture:self.outputTexture
-                     sourceSlice:0
-                     sourceLevel:0
-                    sourceOrigin:MTLOriginMake(0, 0, 0)
-                      sourceSize:MTLSizeMake(self.texWidth, self.texHeight, 1)
-                       toTexture:drawable.texture
-                destinationSlice:0
-                destinationLevel:0
-               destinationOrigin:MTLOriginMake(0, 0, 0)];
-
-    [blitEncoder endEncoding];
-    [commandBuffer presentDrawable:drawable];
-    [commandBuffer commit];
+    id<MTLComputeCommandEncoder> encoder = [commandBuffer computeCommandEncoder];
+    if (!commandBuffer || !encoder) {
+        native_error(error, @"Failed to create compute command buffer or encoder");
+        return nil;
+    }
+    [encoder setComputePipelineState:self.computePipeline];
+    [encoder setTexture:self.outputTexture atIndex:0];
+    [encoder setBuffer:self.uniformBuffer offset:0 atIndex:0];
+
+    NSUInteger limit = MIN(self.computePipeline.maxTotalThreadsPerThreadgroup,
+                           self.device.maxThreadsPerThreadgroup.width);
+    if (!limit) {
+        [encoder endEncoding];
+        native_error(error, @"Compute pipeline has no supported threadgroup size");
+        return nil;
+    }
+    NSUInteger width = MAX((NSUInteger)1, MIN(self.computePipeline.threadExecutionWidth, limit));
+    // Use complete rows that divide the image, so even older GPUs dispatch no extra pixels.
+    while ((NSUInteger)self.texWidth % width != 0) width--;
+    [encoder dispatchThreadgroups:MTLSizeMake(self.texWidth / width, self.texHeight, 1)
+           threadsPerThreadgroup:MTLSizeMake(width, 1, 1)];
+    [encoder endEncoding];
+    return commandBuffer;
 }
 
 @end
 
-@interface MetacoWindow : NSWindow
+@interface MetacoWindow : NSWindow <NSWindowDelegate>
 @property (nonatomic, assign) BOOL shouldClose;
 @property (nonatomic, strong) NSMutableArray *pendingEvents;
 @property (nonatomic, strong) MetacoMetalView *metalView;
@@ -237,23 +209,25 @@
                               backing:NSBackingStoreBuffered
                                 defer:NO];
     if (self) {
+        self.releasedWhenClosed = NO;
         self.shouldClose = NO;
         self.pendingEvents = [NSMutableArray array];
         [self setTitle:title];
-        [self setDelegate:(id<NSWindowDelegate>)self];
+        [self setDelegate:self];
 
         // Try to use Metal
         id<MTLDevice> device = MTLCreateSystemDefaultDevice();
         if (device) {
-            self.useMetal = YES;
             self.metalView = [[MetacoMetalView alloc] initWithFrame:NSMakeRect(0, 0, width, height)
                                                            device:device
                                                             width:width
                                                            height:height];
+        }
+        self.useMetal = self.metalView != nil;
+        if (self.useMetal) {
             [self setContentView:self.metalView];
         } else {
-            // Fallback to bitmap
-            self.useMetal = NO;
+            // Device or rendering resource creation failed: use the bitmap path.
             self.bitmapRep = [[NSBitmapImageRep alloc]
                 initWithBitmapDataPlanes:NULL
                               pixelsWide:width
@@ -263,13 +237,22 @@
                                 hasAlpha:YES
                                 isPlanar:NO
                           colorSpaceName:NSDeviceRGBColorSpace
-                             bytesPerRow:width * 4
+                            bitmapFormat:NSBitmapFormatAlphaNonpremultiplied
+                             bytesPerRow:(size_t)width * 4
                             bitsPerPixel:32];
 
+            if (!self.bitmapRep || !self.bitmapRep.bitmapData) {
+                [self close];
+                return nil;
+            }
             NSImage *image = [[NSImage alloc] initWithSize:NSMakeSize(width, height)];
             [image addRepresentation:self.bitmapRep];
 
             self.imageView = [[NSImageView alloc] initWithFrame:NSMakeRect(0, 0, width, height)];
+            if (!image || !self.imageView) {
+                [self close];
+                return nil;
+            }
             [self.imageView setImage:image];
             [self.imageView setImageScaling:NSImageScaleAxesIndependently];
             [self setContentView:self.imageView];
@@ -335,11 +318,79 @@
     [self.pendingEvents addObject:eventDict];
 }
 
+- (void)rightMouseDown:(NSEvent *)event { [self mouseDown:event]; }
+- (void)rightMouseUp:(NSEvent *)event { [self mouseUp:event]; }
+- (void)otherMouseDown:(NSEvent *)event { [self mouseDown:event]; }
+- (void)otherMouseUp:(NSEvent *)event { [self mouseUp:event]; }
+- (void)mouseDragged:(NSEvent *)event { [self mouseMoved:event]; }
+- (void)rightMouseDragged:(NSEvent *)event { [self mouseMoved:event]; }
+- (void)otherMouseDragged:(NSEvent *)event { [self mouseMoved:event]; }
+
 - (BOOL)canBecomeKeyWindow { return YES; }
 - (BOOL)acceptsFirstResponder { return YES; }
 @end
 
+typedef struct {
+    void *window;
+    int width;
+    int height;
+    size_t byte_length;
+    BOOL busy;
+} MetacoHandle;
+
+static VALUE cMetacoWindow;
+
+static void require_main_thread(void) {
+    if (!pthread_main_np()) rb_raise(rb_eThreadError, "Metaco must be called on the main thread");
+}
+
+static size_t pixel_byte_length(int width, int height) {
+    if (width <= 0 || height <= 0 || width > 16384 || height > 16384) {
+        rb_raise(rb_eArgError, "Width and height must be between 1 and 16384");
+    }
+    if ((size_t)width > SIZE_MAX / 4 / (size_t)height ||
+        (size_t)width * 4 * (size_t)height > LONG_MAX) {
+        rb_raise(rb_eArgError, "Pixel buffer size is too large");
+    }
+    return (size_t)width * (size_t)height * 4;
+}
+
+static void release_window(void *ptr) {
+    @autoreleasepool {
+        MetacoWindow *window = (__bridge_transfer MetacoWindow *)ptr;
+        window.delegate = nil;
+        [window close];
+    }
+}
+
+static void handle_free(void *ptr) {
+    MetacoHandle *handle = ptr;
+    if (handle->window) {
+        if (pthread_main_np()) release_window(handle->window);
+        else dispatch_async_f(dispatch_get_main_queue(), handle->window, release_window);
+    }
+    ruby_xfree(handle);
+}
+
+static size_t handle_size(const void *ptr) { return sizeof(MetacoHandle); }
+
+static const rb_data_type_t handle_type = {
+    .wrap_struct_name = "Metaco::Window",
+    .function = {.dfree = handle_free, .dsize = handle_size},
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static MetacoHandle *get_handle(VALUE value, BOOL allow_closed) {
+    require_main_thread();
+    MetacoHandle *handle;
+    TypedData_Get_Struct(value, MetacoHandle, &handle_type, handle);
+    if (!allow_closed && !handle->window) rb_raise(rb_eArgError, "Window is closed");
+    if (handle->busy) rb_raise(rb_eRuntimeError, "Window is busy");
+    return handle;
+}
+
 static VALUE cocoa_init(VALUE self) {
+    require_main_thread();
     @autoreleasepool {
         [NSApplication sharedApplication];
         [NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
@@ -349,95 +400,171 @@ static VALUE cocoa_init(VALUE self) {
 }
 
 static VALUE cocoa_window_create(VALUE self, VALUE width, VALUE height, VALUE title) {
+    require_main_thread();
+    int w = NUM2INT(width);
+    int h = NUM2INT(height);
+    size_t length = pixel_byte_length(w, h);
+    Check_Type(title, T_STRING);
+    if (!NSApp) rb_raise(rb_eRuntimeError, "Call Metaco.init before creating a window");
+
+    MetacoHandle *handle;
+    VALUE result = TypedData_Make_Struct(cMetacoWindow, MetacoHandle, &handle_type, handle);
+    handle->width = w;
+    handle->height = h;
+    handle->byte_length = length;
+    BOOL valid_title;
     @autoreleasepool {
-        int w = NUM2INT(width);
-        int h = NUM2INT(height);
-        NSString *t = [NSString stringWithUTF8String:StringValueCStr(title)];
-
-        MetacoWindow *window = [[MetacoWindow alloc] initWithWidth:w height:h title:t];
-        return ULONG2NUM((unsigned long)(__bridge_retained void *)window);
-    }
-}
-
-static VALUE cocoa_window_destroy(VALUE self, VALUE window_ptr) {
-    void *ptr = (void *)NUM2ULONG(window_ptr);
-    if (!ptr) return Qnil;
-
-    // Get window reference without transferring ownership yet
-    MetacoWindow *window = (__bridge MetacoWindow *)ptr;
-
-    // Synchronize GPU before cleanup (outside autoreleasepool)
-    if (window && window.useMetal && window.metalView) {
-        MetacoMetalView *metalView = window.metalView;
-        if (metalView.commandQueue) {
-            @try {
-                id<MTLCommandBuffer> syncBuffer = [metalView.commandQueue commandBuffer];
-                if (syncBuffer) {
-                    [syncBuffer commit];
-                    [syncBuffer waitUntilCompleted];
-                }
-            } @catch (NSException *e) {
-                // Ignore - GPU may already be done
-            }
+        NSString *text = [[NSString alloc] initWithBytes:RSTRING_PTR(title)
+                                                length:RSTRING_LEN(title)
+                                              encoding:NSUTF8StringEncoding];
+        valid_title = text != nil;
+        if (valid_title) {
+            MetacoWindow *window = [[MetacoWindow alloc] initWithWidth:w height:h title:text];
+            handle->window = (__bridge_retained void *)window;
         }
-        // Mark that we've cleaned up the compute shader
-        metalView.hasComputeShader = NO;
     }
+    RB_GC_GUARD(title);
+    if (!valid_title) rb_raise(rb_eArgError, "Title must contain valid UTF-8");
+    if (!handle->window) rb_raise(rb_eRuntimeError, "Failed to create window resources");
+    return result;
+}
 
-    // Close the window
-    if (window) {
-        [window close];
-    }
-
-    // Now transfer ownership to ARC - this will release the object
-    // Do this outside autoreleasepool to avoid double-release issues
-    (void)(__bridge_transfer id)ptr;
-
+static VALUE cocoa_window_destroy(VALUE self, VALUE value) {
+    MetacoHandle *handle = get_handle(value, YES);
+    void *ptr = handle->window;
+    handle->window = NULL;
+    if (ptr) release_window(ptr);
+    RB_GC_GUARD(value);
     return Qnil;
 }
 
-static VALUE cocoa_set_pixels(VALUE self, VALUE window_ptr, VALUE buffer, VALUE width, VALUE height) {
-    @autoreleasepool {
-        MetacoWindow *window = (__bridge MetacoWindow *)(void *)NUM2ULONG(window_ptr);
-        int w = NUM2INT(width);
-        int h = NUM2INT(height);
-
-        Check_Type(buffer, T_STRING);
-        const unsigned char *data = (const unsigned char *)RSTRING_PTR(buffer);
-        long len = RSTRING_LEN(buffer);
-
-        if (len < w * h * 4) {
-            rb_raise(rb_eArgError, "Buffer too small");
-        }
+static VALUE cocoa_set_pixels(VALUE self, VALUE value, VALUE buffer, VALUE width, VALUE height) {
+    require_main_thread();
+    int w = NUM2INT(width);
+    int h = NUM2INT(height);
+    size_t length = pixel_byte_length(w, h);
+    Check_Type(buffer, T_STRING);
+    MetacoHandle *handle = get_handle(value, NO);
+    if (w != handle->width || h != handle->height) {
+        rb_raise(rb_eArgError, "Pixel dimensions must match the window");
+    }
+    if ((size_t)RSTRING_LEN(buffer) < length) rb_raise(rb_eArgError, "Buffer too small");
 
+    @autoreleasepool {
+        MetacoWindow *window = (__bridge MetacoWindow *)handle->window;
         if (window.useMetal) {
-            [window.metalView updatePixels:data];
+            [window.metalView updatePixels:(const uint8_t *)RSTRING_PTR(buffer)];
         } else {
-            unsigned char *bitmapData = [window.bitmapRep bitmapData];
-            memcpy(bitmapData, data, w * h * 4);
+            memcpy(window.bitmapRep.bitmapData, RSTRING_PTR(buffer), handle->byte_length);
         }
     }
+    RB_GC_GUARD(buffer);
+    RB_GC_GUARD(value);
     return Qnil;
 }
 
-static VALUE cocoa_present(VALUE self, VALUE window_ptr) {
+static void *submit_command(void *ptr) {
     @autoreleasepool {
-        MetacoWindow *window = (__bridge MetacoWindow *)(void *)NUM2ULONG(window_ptr);
+        id<MTLCommandBuffer> command = (__bridge id<MTLCommandBuffer>)ptr;
+        [command commit];
+        [command waitUntilCompleted];
+    }
+    return NULL;
+}
 
-        if (window.useMetal) {
-            [window.metalView present];
+static VALUE submit_without_gvl(VALUE ptr) {
+    rb_thread_call_without_gvl(submit_command, (void *)ptr, NULL, NULL);
+    return Qnil;
+}
+
+static void finish_command(id<MTLCommandBuffer> command, int *state, NSError **error) {
+    if (!command) return;
+    // ponytail: one frame in flight; add buffering only if synchronous presentation limits throughput.
+    // rb_protect also catches interrupts while the GVL is released/reacquired.
+    rb_protect(submit_without_gvl, (VALUE)(__bridge void *)command, state);
+    if (!*state && command.status != MTLCommandBufferStatusCompleted) {
+        if (command.error) *error = command.error;
+        else native_error(error, @"GPU command failed");
+    }
+}
+
+// Only call inside rb_protect (directly or through events_to_ruby).
+static VALUE string_to_ruby(VALUE ptr) {
+    __unsafe_unretained NSString *text = (__bridge NSString *)(void *)ptr;
+    return rb_utf8_str_new(text.UTF8String, [text lengthOfBytesUsingEncoding:NSUTF8StringEncoding]);
+}
+
+static VALUE cocoa_present_frame(VALUE value, BOOL compute) {
+    MetacoHandle *handle = get_handle(value, NO);
+    VALUE message = Qnil;
+    int state = 0;
+    handle->busy = YES;
+    @autoreleasepool {
+        MetacoWindow *window = (__bridge MetacoWindow *)handle->window;
+        NSError *error = nil;
+        if (compute && (!window.useMetal || !window.metalView.hasComputeShader)) {
+            native_error(&error, @"Compute shader not compiled");
+        } else if (window.useMetal) {
+            id<MTLTexture> texture = compute ? window.metalView.outputTexture : window.metalView.texture;
+            id<MTLCommandBuffer> command = [window.metalView presentTexture:texture error:&error];
+            finish_command(command, &state, &error);
         } else {
             [window.imageView setNeedsDisplay:YES];
             [window displayIfNeeded];
         }
+        if (error && !state) {
+            message = rb_protect(string_to_ruby, (VALUE)(__bridge void *)error.localizedDescription, &state);
+        }
     }
+    handle->busy = NO;
+    RB_GC_GUARD(value);
+    if (state) rb_jump_tag(state);
+    if (!NIL_P(message)) rb_exc_raise(rb_exc_new_str(rb_eRuntimeError, message));
     return Qnil;
 }
 
-static VALUE cocoa_poll_events(VALUE self, VALUE window_ptr) {
-    @autoreleasepool {
-        MetacoWindow *window = (__bridge MetacoWindow *)(void *)NUM2ULONG(window_ptr);
+static VALUE cocoa_present(VALUE self, VALUE value) { return cocoa_present_frame(value, NO); }
+static VALUE cocoa_present_compute(VALUE self, VALUE value) { return cocoa_present_frame(value, YES); }
+
+// Called only via rb_protect: no owning Objective-C locals or autorelease pools
+// may live in a frame that Ruby's longjmp can bypass.
+static VALUE events_to_ruby(VALUE ptr) {
+    __unsafe_unretained NSArray *pending = (__bridge NSArray *)(void *)ptr;
+    VALUE events = rb_ary_new();
+    for (NSUInteger i = 0; i < pending.count; i++) {
+        __unsafe_unretained NSDictionary *dict = pending[i];
+        VALUE hash = rb_hash_new();
+        rb_hash_aset(hash, ID2SYM(rb_intern("type")),
+                     ID2SYM(rb_intern([dict[@"type"] UTF8String])));
+        if (dict[@"key"]) {
+            rb_hash_aset(hash, ID2SYM(rb_intern("key")), INT2NUM([dict[@"key"] intValue]));
+        }
+        if (dict[@"char"]) {
+            __unsafe_unretained NSString *characters = dict[@"char"];
+            rb_hash_aset(hash, ID2SYM(rb_intern("char")),
+                         string_to_ruby((VALUE)(__bridge void *)characters));
+        }
+        if (dict[@"x"]) {
+            rb_hash_aset(hash, ID2SYM(rb_intern("x")), DBL2NUM([dict[@"x"] doubleValue]));
+        }
+        if (dict[@"y"]) {
+            rb_hash_aset(hash, ID2SYM(rb_intern("y")), DBL2NUM([dict[@"y"] doubleValue]));
+        }
+        if (dict[@"button"]) {
+            rb_hash_aset(hash, ID2SYM(rb_intern("button")), INT2NUM([dict[@"button"] intValue]));
+        }
+        rb_ary_push(events, hash);
+    }
+    return events;
+}
 
+static VALUE cocoa_poll_events(VALUE self, VALUE value) {
+    MetacoHandle *handle = get_handle(value, NO);
+    int state = 0;
+    VALUE events;
+    handle->busy = YES;
+    @autoreleasepool {
+        MetacoWindow *window = (__bridge MetacoWindow *)handle->window;
         NSEvent *event;
         while ((event = [NSApp nextEventMatchingMask:NSEventMaskAny
                                            untilDate:nil
@@ -445,108 +572,117 @@ static VALUE cocoa_poll_events(VALUE self, VALUE window_ptr) {
                                              dequeue:YES])) {
             [NSApp sendEvent:event];
         }
-
         [[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode
                                  beforeDate:[NSDate dateWithTimeIntervalSinceNow:0.001]];
         [NSApp updateWindows];
-
-        VALUE events = rb_ary_new();
-        for (NSDictionary *dict in window.pendingEvents) {
-            VALUE hash = rb_hash_new();
-
-            NSString *type = dict[@"type"];
-            rb_hash_aset(hash, ID2SYM(rb_intern("type")),
-                        ID2SYM(rb_intern([type UTF8String])));
-
-            if (dict[@"key"]) {
-                rb_hash_aset(hash, ID2SYM(rb_intern("key")), INT2NUM([dict[@"key"] intValue]));
-            }
-            if (dict[@"char"]) {
-                rb_hash_aset(hash, ID2SYM(rb_intern("char")),
-                           rb_str_new_cstr([dict[@"char"] UTF8String]));
-            }
-            if (dict[@"x"]) {
-                rb_hash_aset(hash, ID2SYM(rb_intern("x")), DBL2NUM([dict[@"x"] doubleValue]));
-            }
-            if (dict[@"y"]) {
-                rb_hash_aset(hash, ID2SYM(rb_intern("y")), DBL2NUM([dict[@"y"] doubleValue]));
-            }
-            if (dict[@"button"]) {
-                rb_hash_aset(hash, ID2SYM(rb_intern("button")), INT2NUM([dict[@"button"] intValue]));
-            }
-
-            rb_ary_push(events, hash);
-        }
-
-        [window.pendingEvents removeAllObjects];
-        return events;
+        events = rb_protect(events_to_ruby, (VALUE)(__bridge void *)window.pendingEvents, &state);
+        if (!state) [window.pendingEvents removeAllObjects];
     }
+    handle->busy = NO;
+    RB_GC_GUARD(value);
+    if (state) rb_jump_tag(state);
+    return events;
 }
 
-static VALUE cocoa_should_close(VALUE self, VALUE window_ptr) {
-    MetacoWindow *window = (__bridge MetacoWindow *)(void *)NUM2ULONG(window_ptr);
-    return window.shouldClose ? Qtrue : Qfalse;
+static VALUE cocoa_should_close(VALUE self, VALUE value) {
+    MetacoHandle *handle = get_handle(value, NO);
+    BOOL result;
+    @autoreleasepool {
+        MetacoWindow *window = (__bridge MetacoWindow *)handle->window;
+        result = window.shouldClose;
+    }
+    RB_GC_GUARD(value);
+    return result ? Qtrue : Qfalse;
 }
 
-// ========== Compute Shader Bridge Functions ==========
-
-static VALUE cocoa_metal_compute_available(VALUE self, VALUE window_ptr) {
-    MetacoWindow *window = (__bridge MetacoWindow *)(void *)NUM2ULONG(window_ptr);
-    return (window.useMetal && window.metalView.device) ? Qtrue : Qfalse;
+static VALUE cocoa_metal_compute_available(VALUE self, VALUE value) {
+    MetacoHandle *handle = get_handle(value, NO);
+    BOOL result;
+    @autoreleasepool {
+        MetacoWindow *window = (__bridge MetacoWindow *)handle->window;
+        result = window.useMetal;
+    }
+    RB_GC_GUARD(value);
+    return result ? Qtrue : Qfalse;
 }
 
-static VALUE cocoa_compile_compute_shader(VALUE self, VALUE window_ptr, VALUE msl_source) {
+static VALUE cocoa_compile_compute_shader(VALUE self, VALUE value, VALUE msl_source) {
+    Check_Type(msl_source, T_STRING);
+    MetacoHandle *handle = get_handle(value, NO);
+    VALUE message = Qnil;
+    int state = 0;
+    handle->busy = YES;
     @autoreleasepool {
-        MetacoWindow *window = (__bridge MetacoWindow *)(void *)NUM2ULONG(window_ptr);
+        MetacoWindow *window = (__bridge MetacoWindow *)handle->window;
+        NSString *source = [[NSString alloc] initWithBytes:RSTRING_PTR(msl_source)
+                                                  length:RSTRING_LEN(msl_source)
+                                                encoding:NSUTF8StringEncoding];
+        NSError *error = nil;
         if (!window.useMetal) {
-            rb_raise(rb_eRuntimeError, "Metal not available");
+            native_error(&error, @"Metal not available");
+        } else if (!source) {
+            native_error(&error, @"Shader source must contain valid UTF-8");
+        } else if (![window.metalView compileComputeShader:source error:&error] && !error) {
+            native_error(&error, @"Failed to compile shader");
         }
-
-        Check_Type(msl_source, T_STRING);
-        NSString *source = [NSString stringWithUTF8String:StringValueCStr(msl_source)];
-        NSError *error = nil;
-
-        if (![window.metalView compileComputeShader:source error:&error]) {
-            rb_raise(rb_eRuntimeError, "Failed to compile shader: %s",
-                     [[error localizedDescription] UTF8String]);
+        if (error) {
+            message = rb_protect(string_to_ruby, (VALUE)(__bridge void *)error.localizedDescription, &state);
         }
     }
+    handle->busy = NO;
+    RB_GC_GUARD(msl_source);
+    RB_GC_GUARD(value);
+    if (state) rb_jump_tag(state);
+    if (!NIL_P(message)) rb_exc_raise(rb_exc_new_str(rb_eRuntimeError, message));
     return Qtrue;
 }
 
-static VALUE cocoa_dispatch_compute(VALUE self, VALUE window_ptr, VALUE uniform_data) {
+static VALUE cocoa_dispatch_compute(VALUE self, VALUE value, VALUE uniform_data) {
+    Check_Type(uniform_data, T_STRING);
+    if (RSTRING_LEN(uniform_data) > 256) rb_raise(rb_eArgError, "Uniform data must be at most 256 bytes");
+    MetacoHandle *handle = get_handle(value, NO);
+    VALUE message = Qnil;
+    int state = 0;
+    handle->busy = YES;
     @autoreleasepool {
-        MetacoWindow *window = (__bridge MetacoWindow *)(void *)NUM2ULONG(window_ptr);
+        MetacoWindow *window = (__bridge MetacoWindow *)handle->window;
+        NSError *error = nil;
         if (!window.useMetal || !window.metalView.hasComputeShader) {
-            rb_raise(rb_eRuntimeError, "Compute shader not compiled");
+            native_error(&error, @"Compute shader not compiled");
+        } else {
+            id<MTLCommandBuffer> command = [window.metalView dispatchComputeWithUniforms:RSTRING_PTR(uniform_data)
+                                                                                length:RSTRING_LEN(uniform_data)
+                                                                                 error:&error];
+            finish_command(command, &state, &error);
+        }
+        if (error && !state) {
+            message = rb_protect(string_to_ruby, (VALUE)(__bridge void *)error.localizedDescription, &state);
         }
-
-        Check_Type(uniform_data, T_STRING);
-        const void *data = RSTRING_PTR(uniform_data);
-        long length = RSTRING_LEN(uniform_data);
-
-        [window.metalView dispatchComputeWithUniforms:data length:length];
     }
+    handle->busy = NO;
+    RB_GC_GUARD(uniform_data);
+    RB_GC_GUARD(value);
+    if (state) rb_jump_tag(state);
+    if (!NIL_P(message)) rb_exc_raise(rb_exc_new_str(rb_eRuntimeError, message));
     return Qnil;
 }
 
-static VALUE cocoa_present_compute(VALUE self, VALUE window_ptr) {
+static VALUE cocoa_has_compute_shader(VALUE self, VALUE value) {
+    MetacoHandle *handle = get_handle(value, NO);
+    BOOL result;
     @autoreleasepool {
-        MetacoWindow *window = (__bridge MetacoWindow *)(void *)NUM2ULONG(window_ptr);
-        if (window.useMetal && window.metalView.hasComputeShader) {
-            [window.metalView presentCompute];
-        }
+        MetacoWindow *window = (__bridge MetacoWindow *)handle->window;
+        result = window.useMetal && window.metalView.hasComputeShader;
     }
-    return Qnil;
-}
-
-static VALUE cocoa_has_compute_shader(VALUE self, VALUE window_ptr) {
-    MetacoWindow *window = (__bridge MetacoWindow *)(void *)NUM2ULONG(window_ptr);
-    return (window.useMetal && window.metalView.hasComputeShader) ? Qtrue : Qfalse;
+    RB_GC_GUARD(value);
+    return result ? Qtrue : Qfalse;
 }
 
 void Init_metaco(void) {
     VALUE mMetaco = rb_define_module("Metaco");
+    cMetacoWindow = rb_define_class_under(mMetaco, "Window", rb_cObject);
+    rb_global_variable(&cMetacoWindow);
+    rb_undef_alloc_func(cMetacoWindow);
 
     rb_define_module_function(mMetaco, "init", cocoa_init, 0);
     rb_define_module_function(mMetaco, "window_create", cocoa_window_create, 3);

data/lib/metaco/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Metaco
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/metaco.rb

@@ -2,10 +2,9 @@
 
 require_relative "metaco/version"
 
-begin
+if RUBY_PLATFORM.include?("darwin")
   require "metaco/metaco"
-rescue LoadError
-  # Extension not compiled - this is expected on non-macOS platforms
+else
   module Metaco
     def self.init
       raise LoadError, "Metaco is only available on macOS"
@@ -34,5 +33,25 @@ rescue LoadError
     def self.should_close?(_handle)
       raise LoadError, "Metaco is only available on macOS"
     end
+
+    def self.metal_compute_available?(_handle)
+      false
+    end
+
+    def self.has_compute_shader?(_handle)
+      false
+    end
+
+    def self.compile_compute_shader(_handle, _source)
+      raise LoadError, "Metaco is only available on macOS"
+    end
+
+    def self.dispatch_compute(_handle, _uniforms)
+      raise LoadError, "Metaco is only available on macOS"
+    end
+
+    def self.present_compute(_handle)
+      raise LoadError, "Metaco is only available on macOS"
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: metaco
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Yudai Takada
@@ -26,13 +26,12 @@ files:
 - ext/metaco/metaco.m
 - lib/metaco.rb
 - lib/metaco/version.rb
-- metaco.gemspec
-homepage: https://github.com/ydah/metaco
+homepage: https://github.com/rbgfx/metaco
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/ydah/metaco
-  changelog_uri: https://github.com/ydah/metaco/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/rbgfx/metaco
+  changelog_uri: https://github.com/rbgfx/metaco/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -47,7 +46,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.19
 specification_version: 4
 summary: Native macOS Cocoa/Metal bridge for Ruby graphics applications
 test_files: []

data/metaco.gemspec

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "lib/metaco/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "metaco"
-  spec.version = Metaco::VERSION
-  spec.authors = ["Yudai Takada"]
-  spec.email = ["t.yudai92@gmail.com"]
-
-  spec.summary = "Native macOS Cocoa/Metal bridge for Ruby graphics applications"
-  spec.description = "A Ruby C extension providing native macOS window management and Metal GPU acceleration for graphics applications."
-  spec.homepage = "https://github.com/ydah/metaco"
-  spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.0.0"
-
-  spec.metadata["source_code_uri"] = spec.homepage
-  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
-
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) ||
-        f.start_with?(*%w[bin/ test/ spec/ features/ .git .github appveyor Gemfile])
-    end
-  end
-  spec.require_paths = ["lib"]
-  spec.extensions = ["ext/metaco/extconf.rb"]
-end