diff --git a/src/bundles/graphics_metal/Makefile b/src/bundles/graphics_metal/Makefile
new file mode 100644
index 0000000000..0ea4ab1cc7
--- /dev/null
+++ b/src/bundles/graphics_metal/Makefile
@@ -0,0 +1,64 @@
+# Makefile for ChimeraX-GraphicsMetal bundle
+
+PYTHON = python3
+CHIMERAX = chimerax
+BUNDLE_NAME = ChimeraX-GraphicsMetal
+BUNDLE_VERSION = 0.1
+
+.PHONY: clean build install test wheel debug develop lint
+
+# Default target
+all: build
+
+# Build the bundle
+build:
+	$(PYTHON) -m pip install -e .
+
+# Create a wheel package
+wheel:
+	$(PYTHON) -m build --wheel
+
+# Install the bundle in the current ChimeraX environment
+install:
+	$(PYTHON) -m pip install .
+
+# Install in development mode
+develop:
+	$(PYTHON) -m pip install -e .
+
+# Install the bundle in ChimeraX
+install-chimerax: wheel
+	$(CHIMERAX) --nogui --exit --cmd "toolshed install dist/$(BUNDLE_NAME)-$(BUNDLE_VERSION)-*.whl"
+
+# Run tests
+test:
+	$(PYTHON) -m pytest tests
+
+# Clean build artifacts
+clean:
+	rm -rf build/
+	rm -rf dist/
+	rm -rf *.egg-info/
+	rm -rf src/chimerax/graphics_metal/__pycache__/
+	rm -rf tests/__pycache__/
+	rm -f src/cython/*.c
+	rm -f src/cython/*.cpp
+	rm -f src/cython/*.html
+	rm -f src/chimerax/graphics_metal/_metal*.so
+
+# Build with debug info
+debug:
+	CFLAGS="-O0 -g" $(PYTHON) -m pip install -e .
+
+# Compile Metal shaders
+shaders:
+	@echo "Compiling Metal shaders..."
+	@mkdir -p build/metallib
+	for file in metal/shaders/*.metal; do \
+		xcrun -sdk macosx metal -c $$file -o build/metallib/$$(basename $$file .metal).air; \
+	done
+	xcrun -sdk macosx metallib build/metallib/*.air -o src/chimerax/graphics_metal/metal_shaders/default.metallib
+
+# Run linter
+lint:
+	flake8 src tests
diff --git a/src/bundles/graphics_metal/metal/metal.pyx b/src/bundles/graphics_metal/metal/metal.pyx
new file mode 100644
index 0000000000..508454a5ea
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal.pyx
@@ -0,0 +1,444 @@
+"""
+Cython wrapper for Metal C++ classes
+"""
+
+# distutils: language = c++
+# cython: embedsignature = True
+# cython: language_level = 3
+
+import numpy as np
+cimport numpy as np
+from libcpp cimport bool
+from libcpp.string cimport string
+from libcpp.vector cimport vector
+from libcpp.memory cimport shared_ptr, unique_ptr
+
+# Define Metal exception class
+class MetalError(Exception):
+    """Exception raised for Metal-related errors."""
+    pass
+
+# Forward declarations of C++ classes
+cdef extern from "metal_context.hpp" namespace "chimerax::graphics_metal":
+    cdef cppclass MetalContext:
+        MetalContext() except +
+        bool initialize() except +
+        bool isInitialized() except +
+        string deviceName() except +
+        string deviceVendor() except +
+        bool supportsUnifiedMemory() except +
+        bool supportsRayTracing() except +
+        bool supportsMeshShaders() except +
+        void beginCapture() except +
+        void endCapture() except +
+
+cdef extern from "metal_scene.hpp" namespace "chimerax::graphics_metal":
+    cdef cppclass MetalCamera:
+        MetalCamera() except +
+        void setPosition(float, float, float) except +
+        void setTarget(float, float, float) except +
+        void setUp(float, float, float) except +
+        void setFov(float) except +
+        void setAspectRatio(float) except +
+        void setNearPlane(float) except +
+        void setFarPlane(float) except +
+
+    cdef cppclass MetalScene:
+        MetalScene(MetalContext*) except +
+        bool initialize() except +
+        MetalCamera* camera() except +
+        void setBackgroundColor(float, float, float, float) except +
+        void setAmbientColor(float, float, float) except +
+        void setAmbientIntensity(float) except +
+
+cdef extern from "metal_argbuffer_manager.hpp" namespace "chimerax::graphics_metal":
+    cdef cppclass MetalArgBuffer:
+        MetalArgBuffer() except +
+        string name() except +
+
+cdef extern from "metal_multi_gpu.hpp" namespace "chimerax::graphics_metal":
+    cdef enum MultiGPUStrategy:
+        SplitFrame "chimerax::graphics_metal::MultiGPUStrategy::SplitFrame"
+        TaskBased "chimerax::graphics_metal::MultiGPUStrategy::TaskBased"
+        Alternating "chimerax::graphics_metal::MultiGPUStrategy::Alternating"
+        ComputeOffload "chimerax::graphics_metal::MultiGPUStrategy::ComputeOffload"
+        
+    cdef struct GPUDeviceInfo:
+        string name
+        bool isPrimary
+        bool isActive
+        bool unifiedMemory
+        unsigned long long memorySize
+    
+    cdef cppclass MetalMultiGPU:
+        MetalMultiGPU() except +
+        bool initialize(MetalContext*) except +
+        vector[GPUDeviceInfo] getDeviceInfo() except +
+        bool enable(bool, MultiGPUStrategy) except +
+        bool isEnabled() except +
+        MultiGPUStrategy getStrategy() except +
+
+cdef extern from "metal_renderer.hpp" namespace "chimerax::graphics_metal":
+    cdef cppclass MetalRenderer:
+        MetalRenderer(MetalContext*) except +
+        bool initialize() except +
+        void setScene(MetalScene*) except +
+        void beginFrame() except +
+        void endFrame() except +
+        void setMultiGPUMode(bool, int) except +
+
+cdef extern from "metal_resources.hpp" namespace "chimerax::graphics_metal":
+    cdef cppclass MetalResources:
+        MetalResources(MetalContext*) except +
+        bool initialize() except +
+
+# PyMetalContext - Wrapper for MetalContext
+cdef class PyMetalContext:
+    cdef MetalContext* _context
+    
+    def __cinit__(self):
+        self._context = new MetalContext()
+        if self._context == NULL:
+            raise MemoryError("Failed to allocate MetalContext")
+    
+    def __dealloc__(self):
+        if self._context != NULL:
+            del self._context
+            self._context = NULL
+    
+    def initialize(self):
+        """Initialize the Metal context"""
+        if not self._context.initialize():
+            raise MetalError("Failed to initialize Metal context")
+        return True
+        
+    def isInitialized(self):
+        """Check if the Metal context is initialized"""
+        return self._context.isInitialized()
+        
+    def deviceName(self):
+        """Get the name of the Metal device"""
+        return self._context.deviceName().decode('utf-8')
+        
+    def deviceVendor(self):
+        """Get the vendor of the Metal device"""
+        return self._context.deviceVendor().decode('utf-8')
+        
+    def supportsUnifiedMemory(self):
+        """Check if the device supports unified memory (Apple Silicon)"""
+        return self._context.supportsUnifiedMemory()
+        
+    def supportsRayTracing(self):
+        """Check if the device supports ray tracing"""
+        return self._context.supportsRayTracing()
+        
+    def supportsMeshShaders(self):
+        """Check if the device supports mesh shaders"""
+        return self._context.supportsMeshShaders()
+        
+    def beginCapture(self):
+        """Begin Metal frame capture for debugging"""
+        self._context.beginCapture()
+        
+    def endCapture(self):
+        """End Metal frame capture"""
+        self._context.endCapture()
+
+# PyMetalScene - Wrapper for MetalScene
+cdef class PyMetalScene:
+    cdef MetalScene* _scene
+    cdef PyMetalContext _context
+    
+    def __cinit__(self, PyMetalContext context):
+        self._context = context
+        self._scene = new MetalScene(context._context)
+        if self._scene == NULL:
+            raise MemoryError("Failed to allocate MetalScene")
+    
+    def __dealloc__(self):
+        if self._scene != NULL:
+            del self._scene
+            self._scene = NULL
+    
+    def initialize(self):
+        """Initialize the Metal scene"""
+        if not self._scene.initialize():
+            raise MetalError("Failed to initialize Metal scene")
+        return True
+        
+    def camera(self):
+        """Get the camera for the scene"""
+        cdef MetalCamera* camera = self._scene.camera()
+        if camera == NULL:
+            return None
+            
+        cdef PyMetalCamera pyCamera = PyMetalCamera.__new__(PyMetalCamera)
+        pyCamera._camera = camera
+        pyCamera._ownsCamera = False
+        return pyCamera
+        
+    def setBackgroundColor(self, float r, float g, float b, float a=1.0):
+        """Set the background color of the scene"""
+        self._scene.setBackgroundColor(r, g, b, a)
+        
+    def setAmbientColor(self, float r, float g, float b):
+        """Set the ambient light color"""
+        self._scene.setAmbientColor(r, g, b)
+        
+    def setAmbientIntensity(self, float intensity):
+        """Set the ambient light intensity"""
+        self._scene.setAmbientIntensity(intensity)
+
+# PyMetalCamera - Wrapper for MetalCamera
+cdef class PyMetalCamera:
+    cdef MetalCamera* _camera
+    cdef bool _ownsCamera
+    
+    def __cinit__(self):
+        self._camera = new MetalCamera()
+        if self._camera == NULL:
+            raise MemoryError("Failed to allocate MetalCamera")
+        self._ownsCamera = True
+    
+    def __dealloc__(self):
+        if self._ownsCamera and self._camera != NULL:
+            del self._camera
+            self._camera = NULL
+    
+    def setPosition(self, float x, float y, float z):
+        """Set the camera position"""
+        self._camera.setPosition(x, y, z)
+        
+    def setTarget(self, float x, float y, float z):
+        """Set the camera target (look-at point)"""
+        self._camera.setTarget(x, y, z)
+        
+    def setUp(self, float x, float y, float z):
+        """Set the camera up vector"""
+        self._camera.setUp(x, y, z)
+        
+    def setFov(self, float fov):
+        """Set the camera field of view (in degrees)"""
+        self._camera.setFov(fov)
+        
+    def setAspectRatio(self, float aspectRatio):
+        """Set the camera aspect ratio (width/height)"""
+        self._camera.setAspectRatio(aspectRatio)
+        
+    def setNearPlane(self, float nearPlane):
+        """Set the camera near clip plane distance"""
+        self._camera.setNearPlane(nearPlane)
+        
+    def setFarPlane(self, float farPlane):
+        """Set the camera far clip plane distance"""
+        self._camera.setFarPlane(farPlane)
+
+# PyMetalRenderer - Wrapper for MetalRenderer
+cdef class PyMetalRenderer:
+    cdef MetalRenderer* _renderer
+    cdef PyMetalContext _context
+    
+    def __cinit__(self, PyMetalContext context):
+        self._context = context
+        self._renderer = new MetalRenderer(context._context)
+        if self._renderer == NULL:
+            raise MemoryError("Failed to allocate MetalRenderer")
+    
+    def __dealloc__(self):
+        if self._renderer != NULL:
+            del self._renderer
+            self._renderer = NULL
+    
+    def initialize(self):
+        """Initialize the Metal renderer"""
+        if not self._renderer.initialize():
+            raise MetalError("Failed to initialize Metal renderer")
+        return True
+        
+    def setScene(self, PyMetalScene scene):
+        """Set the scene to render"""
+        self._renderer.setScene(scene._scene)
+        
+    def beginFrame(self):
+        """Begin a new frame for rendering"""
+        self._renderer.beginFrame()
+        
+    def endFrame(self):
+        """End the current frame rendering"""
+        self._renderer.endFrame()
+        
+    def setMultiGPUMode(self, bool enabled, int strategy=0):
+        """Enable or disable multi-GPU rendering"""
+        self._renderer.setMultiGPUMode(enabled, strategy)
+
+# PyMetalMultiGPU - Wrapper for MetalMultiGPU
+cdef class PyMetalMultiGPU:
+    cdef MetalMultiGPU* _multiGpu
+    
+    def __cinit__(self):
+        self._multiGpu = new MetalMultiGPU()
+        if self._multiGpu == NULL:
+            raise MemoryError("Failed to allocate MetalMultiGPU")
+    
+    def __dealloc__(self):
+        if self._multiGpu != NULL:
+            del self._multiGpu
+            self._multiGpu = NULL
+    
+    def initialize(self, PyMetalContext context):
+        """Initialize multi-GPU support"""
+        if not self._multiGpu.initialize(context._context):
+            raise MetalError("Failed to initialize multi-GPU support")
+        return True
+        
+    def getDeviceInfo(self):
+        """Get information about available Metal GPU devices"""
+        cdef vector[GPUDeviceInfo] info = self._multiGpu.getDeviceInfo()
+        result = []
+        
+        for i in range(info.size()):
+            device = {
+                "name": info[i].name.decode('utf-8'),
+                "is_primary": info[i].isPrimary,
+                "is_active": info[i].isActive,
+                "unified_memory": info[i].unifiedMemory,
+                "memory_size": info[i].memorySize
+            }
+            result.append(device)
+            
+        return result
+        
+    def enable(self, bool enabled, int strategy=0):
+        """Enable or disable multi-GPU rendering"""
+        cdef MultiGPUStrategy strat
+        
+        if strategy == 0:
+            strat = SplitFrame
+        elif strategy == 1:
+            strat = TaskBased
+        elif strategy == 2:
+            strat = Alternating
+        elif strategy == 3:
+            strat = ComputeOffload
+        else:
+            strat = SplitFrame
+            
+        return self._multiGpu.enable(enabled, strat)
+        
+    def isEnabled(self):
+        """Check if multi-GPU rendering is enabled"""
+        return self._multiGpu.isEnabled()
+        
+    def getStrategy(self):
+        """Get the current multi-GPU strategy"""
+        cdef MultiGPUStrategy strat = self._multiGpu.getStrategy()
+        
+        if strat == SplitFrame:
+            return 0
+        elif strat == TaskBased:
+            return 1
+        elif strat == Alternating:
+            return 2
+        elif strat == ComputeOffload:
+            return 3
+        else:
+            return 0
+
+# PyMetalArgBuffer - Wrapper for MetalArgBuffer
+cdef class PyMetalArgBuffer:
+    cdef shared_ptr[MetalArgBuffer] _argBuffer
+    
+    def name(self):
+        """Get the name of the argument buffer"""
+        if not self._argBuffer:
+            return ""
+        return self._argBuffer.get().name().decode('utf-8')
+
+# Dummy view class for now - in a real implementation, this would wrap the MTKView
+cdef class PyMetalView:
+    cdef PyMetalContext _context
+    cdef PyMetalRenderer _renderer
+    cdef PyMetalScene _scene
+    
+    def __cinit__(self):
+        self._context = PyMetalContext()
+        self._renderer = None
+        self._scene = None
+    
+    def initialize(self, long window_id, int width, int height):
+        """Initialize the Metal view"""
+        # Initialize the context
+        if not self._context.initialize():
+            return False
+            
+        # Create scene
+        self._scene = PyMetalScene(self._context)
+        if not self._scene.initialize():
+            return False
+            
+        # Create renderer
+        self._renderer = PyMetalRenderer(self._context)
+        if not self._renderer.initialize():
+            return False
+            
+        # Set scene in renderer
+        self._renderer.setScene(self._scene)
+        
+        # In a real implementation, we would create an MTKView
+        # and attach it to the window_id
+        # For now, just return success
+        return True
+        
+    def context(self):
+        """Get the Metal context"""
+        return self._context
+        
+    def renderer(self):
+        """Get the Metal renderer"""
+        return self._renderer
+        
+    def scene(self):
+        """Get the Metal scene"""
+        return self._scene
+        
+    def resize(self, int width, int height):
+        """Resize the Metal view"""
+        # In a real implementation, we would resize the MTKView
+        # For now, just update the camera aspect ratio
+        if self._scene and self._scene.camera():
+            aspect = float(width) / float(height)
+            self._scene.camera().setAspectRatio(aspect)
+            
+    def render(self):
+        """Render the current frame"""
+        if self._renderer:
+            self._renderer.beginFrame()
+            # In a real implementation, the actual rendering would happen here
+            # through the MTKView delegate
+            self._renderer.endFrame()
+            
+    def beginCapture(self):
+        """Begin Metal frame capture for debugging"""
+        if self._context:
+            self._context.beginCapture()
+            
+    def endCapture(self):
+        """End Metal frame capture"""
+        if self._context:
+            self._context.endCapture()
+
+# Module-level functions to check Metal availability
+def is_metal_available():
+    """Check if Metal is available on the current system"""
+    import platform
+    if platform.system() != "Darwin":
+        return False
+        
+    # Check macOS version - Metal requires 10.14+ for all features we need
+    mac_ver = platform.mac_ver()[0]
+    if mac_ver:
+        major, minor = map(int, mac_ver.split('.')[:2])
+        if (major < 10) or (major == 10 and minor < 14):
+            return False
+            
+    return True
diff --git a/src/bundles/graphics_metal/metal/metal_argbuffer_manager.cpp b/src/bundles/graphics_metal/metal/metal_argbuffer_manager.cpp
new file mode 100644
index 0000000000..4a8e10683a
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_argbuffer_manager.cpp
@@ -0,0 +1,249 @@
+// metal_argbuffer_manager.cpp
+// Implementation of argument buffers for efficient resource binding in Metal
+
+#include "metal_argbuffer_manager.hpp"
+#include "metal_context.hpp"
+#include "metal_resources.hpp"
+#include <iostream>
+
+namespace chimerax {
+namespace graphics_metal {
+
+// MetalArgBuffer implementation
+MetalArgBuffer::MetalArgBuffer(id<MTLDevice> device, id<MTLArgumentEncoder> encoder, const std::string& name)
+    : _device(device)
+    , _encoder(encoder)
+    , _buffer(nil)
+    , _name(name)
+{
+    if (_encoder) {
+        // Retain encoder
+        [_encoder retain];
+        
+        // Create buffer to hold argument data
+        NSUInteger length = [_encoder encodedLength];
+        _buffer = [_device newBufferWithLength:length options:MTLResourceStorageModeShared];
+        
+        if (_buffer) {
+            [_buffer setLabel:[NSString stringWithFormat:@"ArgBuffer: %s", name.c_str()]];
+            
+            // Initialize the buffer with the encoder
+            [_encoder setArgumentBuffer:_buffer offset:0];
+        }
+    }
+}
+
+MetalArgBuffer::~MetalArgBuffer()
+{
+    if (_buffer) {
+        [_buffer release];
+        _buffer = nil;
+    }
+    
+    if (_encoder) {
+        [_encoder release];
+        _encoder = nil;
+    }
+}
+
+void MetalArgBuffer::setBuffer(uint32_t index, id<MTLBuffer> buffer, uint32_t offset)
+{
+    if (_encoder && _buffer) {
+        [_encoder setBuffer:buffer offset:offset atIndex:index];
+    }
+}
+
+void MetalArgBuffer::setTexture(uint32_t index, id<MTLTexture> texture)
+{
+    if (_encoder && _buffer) {
+        [_encoder setTexture:texture atIndex:index];
+    }
+}
+
+void MetalArgBuffer::setSamplerState(uint32_t index, id<MTLSamplerState> sampler)
+{
+    if (_encoder && _buffer) {
+        [_encoder setSamplerState:sampler atIndex:index];
+    }
+}
+
+void MetalArgBuffer::setAccelerationStructure(uint32_t index, id<MTLAccelerationStructure> accelStructure)
+{
+    if (_encoder && _buffer) {
+        if (@available(macOS 12.0, *)) {
+            [_encoder setAccelerationStructure:accelStructure atIndex:index];
+        } else {
+            std::cerr << "Warning: Acceleration structures are only available on macOS 12.0 and later" << std::endl;
+        }
+    }
+}
+
+NSUInteger MetalArgBuffer::encodedLength() const
+{
+    if (_encoder) {
+        return [_encoder encodedLength];
+    }
+    return 0;
+}
+
+// MetalArgBufferManager implementation
+MetalArgBufferManager::MetalArgBufferManager(MetalContext* context)
+    : _context(context)
+{
+}
+
+MetalArgBufferManager::~MetalArgBufferManager()
+{
+    clearArgBuffers();
+}
+
+bool MetalArgBufferManager::initialize()
+{
+    if (!_context) {
+        return false;
+    }
+    
+    // Check if device supports argument buffers
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return false;
+    }
+    
+    // Make sure the device supports argument buffers
+    if ([device argumentBuffersSupport] < MTLArgumentBuffersTier1) {
+        std::cerr << "Warning: Device does not support argument buffers, some features will be disabled" << std::endl;
+    }
+    
+    return true;
+}
+
+std::shared_ptr<MetalArgBuffer> MetalArgBufferManager::createArgBuffer(
+    const std::string& functionName, 
+    ArgBufferType type,
+    id<MTLLibrary> library)
+{
+    // Check if we already have this argument buffer
+    auto it = _argBuffers.find(functionName);
+    if (it != _argBuffers.end()) {
+        return it->second;
+    }
+    
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return nullptr;
+    }
+    
+    // Get the function from the library
+    if (!library) {
+        library = _context->resources()->defaultLibrary();
+    }
+    
+    if (!library) {
+        std::cerr << "MetalArgBufferManager::createArgBuffer: No library available" << std::endl;
+        return nullptr;
+    }
+    
+    NSString* nsFunctionName = [NSString stringWithUTF8String:functionName.c_str()];
+    id<MTLFunction> function = [library newFunctionWithName:nsFunctionName];
+    
+    if (!function) {
+        std::cerr << "MetalArgBufferManager::createArgBuffer: Function not found: " << functionName << std::endl;
+        return nullptr;
+    }
+    
+    // Create the argument encoder from the function
+    MTLFunctionConstantValues* constants = nil; // No constants for now
+    NSError* error = nil;
+    id<MTLArgumentEncoder> encoder = nil;
+    
+    switch (type) {
+        case ArgBufferType::Vertex:
+            encoder = [function newArgumentEncoderWithBufferIndex:0];
+            break;
+        case ArgBufferType::Fragment:
+            encoder = [function newArgumentEncoderWithBufferIndex:0];
+            break;
+        case ArgBufferType::Compute:
+            encoder = [function newArgumentEncoderWithBufferIndex:0];
+            break;
+        case ArgBufferType::RayData:
+            if (@available(macOS 12.0, *)) {
+                encoder = [function newArgumentEncoderWithBufferIndex:0];
+            } else {
+                std::cerr << "MetalArgBufferManager::createArgBuffer: Ray tracing is only available on macOS 12.0 and later" << std::endl;
+            }
+            break;
+    }
+    
+    [function release];
+    
+    if (!encoder) {
+        std::cerr << "MetalArgBufferManager::createArgBuffer: Failed to create argument encoder for: " << functionName << std::endl;
+        return nullptr;
+    }
+    
+    // Create the argument buffer
+    auto argBuffer = std::make_shared<MetalArgBuffer>(device, encoder, functionName);
+    [encoder release]; // argBuffer retained the encoder
+    
+    // Cache the argument buffer
+    _argBuffers[functionName] = argBuffer;
+    
+    return argBuffer;
+}
+
+std::shared_ptr<MetalArgBuffer> MetalArgBufferManager::createArgBufferFromLayout(
+    const std::vector<MTLArgumentDescriptor*>& descriptors,
+    const std::string& name)
+{
+    // Check if we already have this argument buffer
+    auto it = _argBuffers.find(name);
+    if (it != _argBuffers.end()) {
+        return it->second;
+    }
+    
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return nullptr;
+    }
+    
+    // Convert vector to NSArray
+    NSMutableArray* descriptorArray = [NSMutableArray arrayWithCapacity:descriptors.size()];
+    for (MTLArgumentDescriptor* descriptor : descriptors) {
+        [descriptorArray addObject:descriptor];
+    }
+    
+    // Create the argument encoder from the descriptors
+    id<MTLArgumentEncoder> encoder = [device newArgumentEncoderWithArguments:descriptorArray];
+    
+    if (!encoder) {
+        std::cerr << "MetalArgBufferManager::createArgBufferFromLayout: Failed to create argument encoder for: " << name << std::endl;
+        return nullptr;
+    }
+    
+    // Create the argument buffer
+    auto argBuffer = std::make_shared<MetalArgBuffer>(device, encoder, name);
+    [encoder release]; // argBuffer retained the encoder
+    
+    // Cache the argument buffer
+    _argBuffers[name] = argBuffer;
+    
+    return argBuffer;
+}
+
+std::shared_ptr<MetalArgBuffer> MetalArgBufferManager::getArgBuffer(const std::string& name) const
+{
+    auto it = _argBuffers.find(name);
+    if (it != _argBuffers.end()) {
+        return it->second;
+    }
+    return nullptr;
+}
+
+void MetalArgBufferManager::clearArgBuffers()
+{
+    _argBuffers.clear();
+}
+
+} // namespace graphics_metal
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_argbuffer_manager.hpp b/src/bundles/graphics_metal/metal/metal_argbuffer_manager.hpp
new file mode 100644
index 0000000000..e712fb19dd
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_argbuffer_manager.hpp
@@ -0,0 +1,95 @@
+// metal_argbuffer_manager.hpp
+// Manages argument buffers for efficient resource binding in Metal
+
+#pragma once
+
+#import <Metal/Metal.h>
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include <memory>
+
+namespace chimerax {
+namespace graphics_metal {
+
+// Forward declarations
+class MetalContext;
+
+/**
+ * Type of argument buffer encoder
+ */
+enum class ArgBufferType {
+    Vertex,
+    Fragment,
+    Compute,
+    RayData
+};
+
+/**
+ * Represents a single argument buffer layout and associated encoder
+ */
+class MetalArgBuffer {
+public:
+    MetalArgBuffer(id<MTLDevice> device, id<MTLArgumentEncoder> encoder, const std::string& name);
+    ~MetalArgBuffer();
+    
+    // Buffer access
+    id<MTLBuffer> buffer() const { return _buffer; }
+    id<MTLArgumentEncoder> encoder() const { return _encoder; }
+    
+    // Set resources into the argument buffer
+    void setBuffer(uint32_t index, id<MTLBuffer> buffer, uint32_t offset = 0);
+    void setTexture(uint32_t index, id<MTLTexture> texture);
+    void setSamplerState(uint32_t index, id<MTLSamplerState> sampler);
+    void setAccelerationStructure(uint32_t index, id<MTLAccelerationStructure> accelStructure);
+    
+    // Get the size of the argument buffer
+    NSUInteger encodedLength() const;
+    
+    // Get the name of the argument buffer
+    const std::string& name() const { return _name; }
+    
+private:
+    id<MTLDevice> _device;
+    id<MTLArgumentEncoder> _encoder;
+    id<MTLBuffer> _buffer;
+    std::string _name;
+};
+
+/**
+ * Manages argument buffers for efficient resource binding
+ */
+class MetalArgBufferManager {
+public:
+    MetalArgBufferManager(MetalContext* context);
+    ~MetalArgBufferManager();
+    
+    // Initialization
+    bool initialize();
+    
+    // Create argument buffer from shader function
+    std::shared_ptr<MetalArgBuffer> createArgBuffer(
+        const std::string& functionName, 
+        ArgBufferType type,
+        id<MTLLibrary> library = nil);
+    
+    // Create argument buffer from buffer structure (manual encoding)
+    std::shared_ptr<MetalArgBuffer> createArgBufferFromLayout(
+        const std::vector<MTLArgumentDescriptor*>& descriptors,
+        const std::string& name);
+    
+    // Get existing argument buffer by name
+    std::shared_ptr<MetalArgBuffer> getArgBuffer(const std::string& name) const;
+    
+    // Clear all argument buffers (useful when context is lost)
+    void clearArgBuffers();
+    
+private:
+    MetalContext* _context;
+    
+    // Cache of argument buffers
+    std::unordered_map<std::string, std::shared_ptr<MetalArgBuffer>> _argBuffers;
+};
+
+} // namespace graphics_metal
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_context.cpp b/src/bundles/graphics_metal/metal/metal_context.cpp
new file mode 100644
index 0000000000..9616d5bcc4
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_context.cpp
@@ -0,0 +1,370 @@
+// metal_context.cpp
+// Optimized implementation of Metal context management for ChimeraX
+
+#include "metal_context.hpp"
+#include "metal_resources.hpp"
+#include "metal_heap_manager.hpp"
+#include "metal_argbuffer_manager.hpp"
+#include "metal_event_manager.hpp"
+#include <iostream>
+#include <algorithm>
+
+namespace chimerax {
+namespace graphics_metal {
+
+MetalContext::MetalContext()
+    : _device(nil)
+    , _commandQueue(nil)
+    , _mtkView(nil)
+    , _resources(nullptr)
+    , _heapManager(nullptr)
+    , _argBufferManager(nullptr)
+    , _eventManager(nullptr)
+    , _initialized(false)
+    , _drawableSize(CGSizeMake(0, 0))
+{
+    // Initialize capabilities to false
+    memset(&_capabilities, 0, sizeof(DeviceCapabilities));
+}
+
+MetalContext::~MetalContext()
+{
+    // Resources and managers must be released before devices
+    _resources.reset();
+    _heapManager.reset();
+    _argBufferManager.reset();
+    _eventManager.reset();
+    
+    // Release command queues
+    for (auto& pair : _deviceCommandQueues) {
+        if (pair.second) {
+            [pair.second release];
+        }
+    }
+    _deviceCommandQueues.clear();
+    
+    // Release devices
+    for (auto& device : _allDevices) {
+        if (device && device != _device) { // Don't double-release _device
+            [device release];
+        }
+    }
+    _allDevices.clear();
+    
+    // Release primary device and queue
+    if (_commandQueue) {
+        [_commandQueue release];
+        _commandQueue = nil;
+    }
+    
+    if (_device) {
+        [_device release];
+        _device = nil;
+    }
+    
+    // Note: We don't own the MTKView, so we don't release it
+}
+
+bool MetalContext::initialize()
+{
+    if (_initialized) {
+        return true;
+    }
+    
+    // Discover available Metal devices
+    if (!discoverDevices()) {
+        return false;
+    }
+    
+    // Create command queues for all devices
+    if (!createDeviceCommandQueues()) {
+        return false;
+    }
+    
+    // Detect device capabilities
+    detectDeviceCapabilities();
+    
+    // Initialize resource managers
+    if (!initializeResourceManagers()) {
+        return false;
+    }
+    
+    _initialized = true;
+    return true;
+}
+
+bool MetalContext::discoverDevices()
+{
+    // Get all available Metal devices
+    NSArray<id<MTLDevice>>* devices = MTLCopyAllDevices();
+    if ([devices count] == 0) {
+        _errorMessage = "No Metal devices found";
+        [devices release];
+        return false;
+    }
+    
+    // Find the most suitable device for primary
+    // Prefer discrete GPUs if available
+    id<MTLDevice> discreteGPU = nil;
+    id<MTLDevice> integratedGPU = nil;
+    
+    for (id<MTLDevice> device in devices) {
+        if ([device isLowPower]) {
+            if (!integratedGPU) {
+                integratedGPU = device;
+            }
+        } else {
+            if (!discreteGPU) {
+                discreteGPU = device;
+            }
+        }
+        
+        // Add to all devices list
+        [device retain];
+        _allDevices.push_back(device);
+    }
+    
+    // Select primary device - prefer discrete GPU if available
+    if (discreteGPU) {
+        _device = discreteGPU;
+    } else if (integratedGPU) {
+        _device = integratedGPU;
+    } else {
+        // Default to first device
+        _device = [devices objectAtIndex:0];
+    }
+    
+    // Retain primary device
+    [_device retain];
+    
+    [devices release];
+    return true;
+}
+
+bool MetalContext::createDeviceCommandQueues()
+{
+    // Create primary command queue
+    _commandQueue = [_device newCommandQueue];
+    if (!_commandQueue) {
+        _errorMessage = "Failed to create primary Metal command queue";
+        return false;
+    }
+    
+    [_commandQueue setLabel:@"ChimeraX Primary Command Queue"];
+    _deviceCommandQueues[_device] = _commandQueue;
+    
+    // Create command queues for all other devices
+    for (auto& device : _allDevices) {
+        if (device != _device) {
+            id<MTLCommandQueue> queue = [device newCommandQueue];
+            if (!queue) {
+                std::cerr << "Warning: Failed to create command queue for secondary device" << std::endl;
+                continue;
+            }
+            
+            [queue setLabel:@"ChimeraX Secondary Command Queue"];
+            _deviceCommandQueues[device] = queue;
+        }
+    }
+    
+    return true;
+}
+
+bool MetalContext::initializeResourceManagers()
+{
+    // Create resource manager
+    _resources = std::make_unique<MetalResources>(this);
+    if (!_resources->initialize()) {
+        _errorMessage = "Failed to initialize Metal resources";
+        return false;
+    }
+    
+    // Create heap manager (for efficient memory allocation)
+    _heapManager = std::make_unique<MetalHeapManager>(this);
+    if (!_heapManager->initialize()) {
+        _errorMessage = "Failed to initialize Metal heap manager";
+        return false;
+    }
+    
+    // Create argument buffer manager
+    _argBufferManager = std::make_unique<MetalArgBufferManager>(this);
+    if (!_argBufferManager->initialize()) {
+        _errorMessage = "Failed to initialize Metal argument buffer manager";
+        return false;
+    }
+    
+    // Create event manager for multi-GPU synchronization
+    _eventManager = std::make_unique<MetalEventManager>(this);
+    if (!_eventManager->initialize()) {
+        _errorMessage = "Failed to initialize Metal event manager";
+        return false;
+    }
+    
+    return true;
+}
+
+void MetalContext::detectDeviceCapabilities()
+{
+    if (!_device) {
+        return;
+    }
+    
+    // Check for unified memory (Apple Silicon)
+    _capabilities.unifiedMemory = [_device hasUnifiedMemory];
+    
+    // Check for ray tracing support (Metal 3)
+    if (@available(macOS 12.0, *)) {
+        _capabilities.rayTracing = [_device supportsRaytracing];
+    } else {
+        _capabilities.rayTracing = false;
+    }
+    
+    // Check for mesh shader support (Metal 3)
+    if (@available(macOS 13.0, *)) {
+        _capabilities.meshShaders = [_device supportsFamilyMac2] || 
+                                     [_device supportsFamilyApple7];
+    } else {
+        _capabilities.meshShaders = false;
+    }
+    
+    // Check for advanced argument buffer support
+    _capabilities.argumentBuffers = [_device argumentBuffersSupport] >= MTLArgumentBuffersTier2;
+    
+    // Check for indirect command buffer support
+    if (@available(macOS 11.0, *)) {
+        _capabilities.indirectCommandBuffers = [_device supportsFeatureSet:MTLFeatureSet_macOS_GPUFamily2_v1];
+    } else {
+        _capabilities.indirectCommandBuffers = false;
+    }
+    
+    // Check for raster order groups (important for deferred rendering)
+    _capabilities.rasterOrderGroups = [_device supportsRasterizationRateMapWithLayerCount:1];
+    
+    // GPU Family support
+    _capabilities.familyApple1 = [_device supportsFamily:MTLGPUFamilyApple1];
+    _capabilities.familyApple2 = [_device supportsFamily:MTLGPUFamilyApple2];
+    _capabilities.familyApple3 = [_device supportsFamily:MTLGPUFamilyApple3];
+    _capabilities.familyApple4 = [_device supportsFamily:MTLGPUFamilyApple4];
+    _capabilities.familyApple5 = [_device supportsFamily:MTLGPUFamilyApple5];
+    
+    // Check for Apple6 and Apple7 (newer families)
+    if (@available(macOS 12.0, *)) {
+        _capabilities.familyApple6 = [_device supportsFamily:MTLGPUFamilyApple6];
+    } else {
+        _capabilities.familyApple6 = false;
+    }
+    
+    if (@available(macOS 13.0, *)) {
+        _capabilities.familyApple7 = [_device supportsFamily:MTLGPUFamilyApple7];
+    } else {
+        _capabilities.familyApple7 = false;
+    }
+    
+    // Mac GPU families
+    _capabilities.familyMac1 = [_device supportsFamily:MTLGPUFamilyMac1];
+    _capabilities.familyMac2 = [_device supportsFamily:MTLGPUFamilyMac2];
+}
+
+void MetalContext::setMTKView(MTKView* view)
+{
+    _mtkView = view;
+    
+    if (_mtkView) {
+        // Configure the view to use our device
+        [_mtkView setDevice:_device];
+        [_mtkView setColorPixelFormat:MTLPixelFormatBGRA8Unorm];
+        [_mtkView setDepthStencilPixelFormat:MTLPixelFormatDepth32Float];
+        [_mtkView setSampleCount:1]; // Start with no MSAA, can be adjusted later
+        
+        // Update drawable size
+        setDrawableSize([_mtkView drawableSize]);
+    }
+}
+
+void MetalContext::setDrawableSize(CGSize size)
+{
+    _drawableSize = size;
+}
+
+std::vector<id<MTLDevice>> MetalContext::activeDevices() const
+{
+    return _allDevices;
+}
+
+id<MTLDevice> MetalContext::deviceAtIndex(size_t index) const
+{
+    if (index < _allDevices.size()) {
+        return _allDevices[index];
+    }
+    return nil;
+}
+
+id<MTLCommandQueue> MetalContext::commandQueueForDevice(id<MTLDevice> device) const
+{
+    auto it = _deviceCommandQueues.find(device);
+    if (it != _deviceCommandQueues.end()) {
+        return it->second;
+    }
+    return nil;
+}
+
+std::string MetalContext::deviceName() const
+{
+    if (!_device) {
+        return "Unknown";
+    }
+    
+    return [[_device name] UTF8String];
+}
+
+std::string MetalContext::deviceVendor() const
+{
+    if (!_device) {
+        return "Unknown";
+    }
+    
+    // There's no direct vendor info in Metal, so infer from device name
+    std::string name = [[_device name] UTF8String];
+    if (name.find("AMD") != std::string::npos) {
+        return "AMD";
+    } else if (name.find("NVIDIA") != std::string::npos) {
+        return "NVIDIA";
+    } else if (name.find("Intel") != std::string::npos) {
+        return "Intel";
+    } else if (name.find("Apple") != std::string::npos) {
+        return "Apple";
+    }
+    
+    return "Unknown";
+}
+
+void MetalContext::setLabel(id<MTLResource> resource, const std::string& label)
+{
+    if (resource) {
+        NSString* nsLabel = [NSString stringWithUTF8String:label.c_str()];
+        [resource setLabel:nsLabel];
+    }
+}
+
+void MetalContext::beginCapture()
+{
+    MTLCaptureManager* captureManager = [MTLCaptureManager sharedCaptureManager];
+    MTLCaptureDescriptor* captureDescriptor = [[MTLCaptureDescriptor alloc] init];
+    captureDescriptor.captureObject = _device;
+    
+    NSError* error = nil;
+    if (![captureManager startCaptureWithDescriptor:captureDescriptor error:&error]) {
+        std::cerr << "Failed to start Metal capture: " << [[error localizedDescription] UTF8String] << std::endl;
+    }
+    
+    [captureDescriptor release];
+}
+
+void MetalContext::endCapture()
+{
+    MTLCaptureManager* captureManager = [MTLCaptureManager sharedCaptureManager];
+    [captureManager stopCapture];
+}
+
+} // namespace graphics_metal
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_context.hpp b/src/bundles/graphics_metal/metal/metal_context.hpp
new file mode 100644
index 0000000000..1f225ab6e5
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_context.hpp
@@ -0,0 +1,132 @@
+// metal_context.hpp
+// Optimized Metal context management for ChimeraX with multi-GPU support
+
+#pragma once
+
+#import <Metal/Metal.h>
+#import <MetalKit/MetalKit.h>
+#include <memory>
+#include <string>
+#include <vector>
+#include <unordered_map>
+#include <optional>
+
+namespace chimerax {
+namespace graphics_metal {
+
+// Forward declarations
+class MetalResources;
+class MetalHeapManager;
+class MetalArgBufferManager;
+class MetalEventManager;
+
+/**
+ * Device capability structure to track feature support
+ */
+struct DeviceCapabilities {
+    bool unifiedMemory;
+    bool rayTracing;
+    bool rasterOrderGroups;
+    bool meshShaders;
+    bool argumentBuffers;
+    bool indirectCommandBuffers;
+    bool familyApple1;
+    bool familyApple2;
+    bool familyApple3;
+    bool familyApple4;
+    bool familyApple5;
+    bool familyApple6;
+    bool familyApple7;
+    bool familyMac1;
+    bool familyMac2;
+};
+
+/**
+ * Manages Metal device and context for ChimeraX graphics rendering
+ * Enhanced with multi-GPU support and advanced Metal features
+ */
+class MetalContext {
+public:
+    MetalContext();
+    ~MetalContext();
+
+    // Initialization
+    bool initialize();
+    bool isInitialized() const { return _initialized; }
+    std::string getErrorMessage() const { return _errorMessage; }
+    
+    // Device access
+    id<MTLDevice> device() const { return _device; }
+    id<MTLCommandQueue> commandQueue() const { return _commandQueue; }
+    
+    // Multiple device support
+    bool hasMultipleDevices() const { return _allDevices.size() > 1; }
+    std::vector<id<MTLDevice>> allDevices() const { return _allDevices; }
+    std::vector<id<MTLDevice>> activeDevices() const;
+    id<MTLDevice> deviceAtIndex(size_t index) const;
+    id<MTLCommandQueue> commandQueueForDevice(id<MTLDevice> device) const;
+    
+    // Device info
+    std::string deviceName() const;
+    std::string deviceVendor() const;
+    DeviceCapabilities deviceCapabilities() const { return _capabilities; }
+    
+    // Resource management
+    MetalResources* resources() const { return _resources.get(); }
+    MetalHeapManager* heapManager() const { return _heapManager.get(); }
+    MetalArgBufferManager* argBufferManager() const { return _argBufferManager.get(); }
+    MetalEventManager* eventManager() const { return _eventManager.get(); }
+    
+    // View management
+    void setDrawableSize(CGSize size);
+    CGSize drawableSize() const { return _drawableSize; }
+    
+    // Render target
+    MTKView* mtkView() const { return _mtkView; }
+    void setMTKView(MTKView* view);
+    
+    // Device capabilities
+    bool supportsUnifiedMemory() const { return _capabilities.unifiedMemory; }
+    bool supportsRayTracing() const { return _capabilities.rayTracing; }
+    bool supportsMeshShaders() const { return _capabilities.meshShaders; }
+    bool supportsArgumentBuffers() const { return _capabilities.argumentBuffers; }
+    bool supportsIndirectCommandBuffers() const { return _capabilities.indirectCommandBuffers; }
+    
+    // Label setting for debugging
+    void setLabel(id<MTLResource> resource, const std::string& label);
+    
+    // Debug capture
+    void beginCapture();
+    void endCapture();
+    
+private:
+    // Core Metal objects
+    id<MTLDevice> _device;
+    id<MTLCommandQueue> _commandQueue;
+    MTKView* _mtkView;
+    
+    // Multi-GPU support
+    std::vector<id<MTLDevice>> _allDevices;
+    std::unordered_map<id<MTLDevice>, id<MTLCommandQueue>> _deviceCommandQueues;
+    
+    // Resource managers
+    std::unique_ptr<MetalResources> _resources;
+    std::unique_ptr<MetalHeapManager> _heapManager;
+    std::unique_ptr<MetalArgBufferManager> _argBufferManager;
+    std::unique_ptr<MetalEventManager> _eventManager;
+    
+    // State tracking
+    bool _initialized;
+    std::string _errorMessage;
+    CGSize _drawableSize;
+    DeviceCapabilities _capabilities;
+    
+    // Internal methods
+    bool discoverDevices();
+    bool createDeviceCommandQueues();
+    bool initializeResourceManagers();
+    void detectDeviceCapabilities();
+};
+
+} // namespace graphics_metal
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_event_manager.cpp b/src/bundles/graphics_metal/metal/metal_event_manager.cpp
new file mode 100644
index 0000000000..70f3d6f85a
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_event_manager.cpp
@@ -0,0 +1,332 @@
+// metal_event_manager.cpp
+// Implementation of event synchronization for multi-GPU rendering
+
+#include "metal_event_manager.hpp"
+#include "metal_context.hpp"
+#include <iostream>
+
+namespace chimerax {
+namespace graphics_metal {
+
+MetalEventManager::MetalEventManager(MetalContext* context)
+    : _context(context)
+    , _frameStartEvent(nil)
+    , _frameEndEvent(nil)
+{
+}
+
+MetalEventManager::~MetalEventManager()
+{
+    releaseEvents();
+}
+
+bool MetalEventManager::initialize()
+{
+    if (!_context) {
+        return false;
+    }
+    
+    // Check if Metal device supports shared events
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return false;
+    }
+    
+    // Create special events for frame synchronization
+    _frameStartEvent = createEventForDevice(device);
+    if (!_frameStartEvent) {
+        std::cerr << "MetalEventManager::initialize: Failed to create frame start event" << std::endl;
+        return false;
+    }
+    
+    _frameEndEvent = createEventForDevice(device);
+    if (!_frameEndEvent) {
+        std::cerr << "MetalEventManager::initialize: Failed to create frame end event" << std::endl;
+        [_frameStartEvent release];
+        _frameStartEvent = nil;
+        return false;
+    }
+    
+    // Set initial values
+    _eventValues[_frameStartEvent] = 0;
+    _eventValues[_frameEndEvent] = 0;
+    
+    // Label events for debugging
+    [_frameStartEvent setLabel:@"Frame Start Event"];
+    [_frameEndEvent setLabel:@"Frame End Event"];
+    
+    return true;
+}
+
+id<MTLEvent> MetalEventManager::createEvent(const std::string& name)
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    
+    // If name is provided, check if it already exists
+    if (!name.empty()) {
+        auto it = _namedEvents.find(name);
+        if (it != _namedEvents.end()) {
+            return it->second;
+        }
+    }
+    
+    // Create new event
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return nil;
+    }
+    
+    id<MTLEvent> event = createEventForDevice(device);
+    if (!event) {
+        return nil;
+    }
+    
+    // Set initial value
+    _eventValues[event] = 0;
+    
+    // Add to named events if name provided
+    if (!name.empty()) {
+        [event setLabel:[NSString stringWithUTF8String:name.c_str()]];
+        _namedEvents[name] = event;
+    }
+    
+    return event;
+}
+
+id<MTLEvent> MetalEventManager::getEvent(const std::string& name) const
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    
+    auto it = _namedEvents.find(name);
+    if (it != _namedEvents.end()) {
+        return it->second;
+    }
+    
+    return nil;
+}
+
+id<MTLEvent> MetalEventManager::signalEvent(id<MTLCommandBuffer> commandBuffer, id<MTLDevice> targetDevice)
+{
+    if (!commandBuffer) {
+        return nil;
+    }
+    
+    // Determine which event to use
+    id<MTLEvent> event = nil;
+    
+    if (targetDevice) {
+        // Create a new event for the specific target device
+        event = createEventForDevice(targetDevice);
+        if (!event) {
+            std::cerr << "MetalEventManager::signalEvent: Failed to create event for target device" << std::endl;
+            return nil;
+        }
+        
+        // Initialize event value
+        std::lock_guard<std::mutex> lock(_mutex);
+        _eventValues[event] = 0;
+    } else {
+        // Use frame end event
+        event = _frameEndEvent;
+    }
+    
+    if (!event) {
+        return nil;
+    }
+    
+    // Get the next value for this event
+    uint64_t value;
+    {
+        std::lock_guard<std::mutex> lock(_mutex);
+        value = ++_eventValues[event];
+    }
+    
+    // Signal the event at the end of the command buffer
+    [commandBuffer encodeSignalEvent:event value:value];
+    
+    return event;
+}
+
+void MetalEventManager::waitForEvent(id<MTLCommandBuffer> commandBuffer, id<MTLEvent> event, uint64_t value)
+{
+    if (!commandBuffer || !event) {
+        return;
+    }
+    
+    // Encode a wait for the event
+    [commandBuffer encodeWaitForEvent:event value:value];
+}
+
+void MetalEventManager::syncAllDevices()
+{
+    if (!_context) {
+        return;
+    }
+    
+    // Get all active devices
+    std::vector<id<MTLDevice>> devices = _context->allDevices();
+    if (devices.empty()) {
+        return;
+    }
+    
+    // Signal an event on each device and have all other devices wait for it
+    for (id<MTLDevice> device : devices) {
+        id<MTLCommandQueue> queue = _context->commandQueueForDevice(device);
+        if (!queue) {
+            continue;
+        }
+        
+        // Create a command buffer
+        id<MTLCommandBuffer> cmdBuffer = [queue commandBuffer];
+        if (!cmdBuffer) {
+            continue;
+        }
+        
+        // Signal an event
+        id<MTLEvent> event = createEventForDevice(device);
+        if (!event) {
+            [cmdBuffer release];
+            continue;
+        }
+        
+        uint64_t value;
+        {
+            std::lock_guard<std::mutex> lock(_mutex);
+            value = ++_eventValues[event];
+        }
+        
+        [cmdBuffer encodeSignalEvent:event value:value];
+        [cmdBuffer commit];
+        
+        // Have all other devices wait for this event
+        for (id<MTLDevice> waitDevice : devices) {
+            if (waitDevice == device) {
+                continue;
+            }
+            
+            id<MTLCommandQueue> waitQueue = _context->commandQueueForDevice(waitDevice);
+            if (!waitQueue) {
+                continue;
+            }
+            
+            id<MTLCommandBuffer> waitCmdBuffer = [waitQueue commandBuffer];
+            if (!waitCmdBuffer) {
+                continue;
+            }
+            
+            [waitCmdBuffer encodeWaitForEvent:event value:value];
+            [waitCmdBuffer commit];
+            [waitCmdBuffer waitUntilCompleted];
+            [waitCmdBuffer release];
+        }
+        
+        [cmdBuffer waitUntilCompleted];
+        [cmdBuffer release];
+        [event release];
+    }
+}
+
+void MetalEventManager::beginFrameBarrier()
+{
+    if (!_context || !_frameStartEvent) {
+        return;
+    }
+    
+    // Get the command queue for the primary device
+    id<MTLCommandQueue> queue = _context->commandQueue();
+    if (!queue) {
+        return;
+    }
+    
+    // Create a command buffer
+    id<MTLCommandBuffer> cmdBuffer = [queue commandBuffer];
+    if (!cmdBuffer) {
+        return;
+    }
+    
+    // Signal the frame start event
+    uint64_t value;
+    {
+        std::lock_guard<std::mutex> lock(_mutex);
+        value = ++_eventValues[_frameStartEvent];
+    }
+    
+    [cmdBuffer encodeSignalEvent:_frameStartEvent value:value];
+    [cmdBuffer commit];
+    [cmdBuffer waitUntilCompleted];
+    [cmdBuffer release];
+}
+
+void MetalEventManager::endFrameBarrier()
+{
+    if (!_context || !_frameEndEvent) {
+        return;
+    }
+    
+    // Get the command queue for the primary device
+    id<MTLCommandQueue> queue = _context->commandQueue();
+    if (!queue) {
+        return;
+    }
+    
+    // Create a command buffer
+    id<MTLCommandBuffer> cmdBuffer = [queue commandBuffer];
+    if (!cmdBuffer) {
+        return;
+    }
+    
+    // Signal the frame end event
+    uint64_t value;
+    {
+        std::lock_guard<std::mutex> lock(_mutex);
+        value = ++_eventValues[_frameEndEvent];
+    }
+    
+    [cmdBuffer encodeSignalEvent:_frameEndEvent value:value];
+    [cmdBuffer commit];
+    [cmdBuffer waitUntilCompleted];
+    [cmdBuffer release];
+}
+
+void MetalEventManager::releaseEvents()
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    
+    // Release special events
+    if (_frameStartEvent) {
+        [_frameStartEvent release];
+        _frameStartEvent = nil;
+    }
+    
+    if (_frameEndEvent) {
+        [_frameEndEvent release];
+        _frameEndEvent = nil;
+    }
+    
+    // Release named events
+    for (auto& pair : _namedEvents) {
+        [pair.second release];
+    }
+    _namedEvents.clear();
+    
+    // Clear event values
+    _eventValues.clear();
+}
+
+id<MTLEvent> MetalEventManager::createEventForDevice(id<MTLDevice> device)
+{
+    if (!device) {
+        return nil;
+    }
+    
+    // Create a new event
+    id<MTLEvent> event = [device newEvent];
+    if (!event) {
+        std::cerr << "MetalEventManager::createEventForDevice: Failed to create event" << std::endl;
+    }
+    
+    return event;
+}
+
+} // namespace graphics_metal
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_event_manager.hpp b/src/bundles/graphics_metal/metal/metal_event_manager.hpp
new file mode 100644
index 0000000000..8b73abeaae
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_event_manager.hpp
@@ -0,0 +1,74 @@
+// metal_event_manager.hpp
+// Manages event synchronization for multi-GPU rendering
+
+#pragma once
+
+#import <Metal/Metal.h>
+#include <unordered_map>
+#include <string>
+#include <memory>
+#include <vector>
+#include <mutex>
+
+namespace chimerax {
+namespace graphics_metal {
+
+// Forward declarations
+class MetalContext;
+
+/**
+ * Manages events for GPU synchronization
+ * 
+ * Events are used to coordinate work between multiple GPUs, ensuring
+ * that resources are accessed safely and work is properly sequenced.
+ */
+class MetalEventManager {
+public:
+    MetalEventManager(MetalContext* context);
+    ~MetalEventManager();
+    
+    // Initialization
+    bool initialize();
+    
+    // Create a new named event
+    id<MTLEvent> createEvent(const std::string& name = "");
+    
+    // Get an existing event by name
+    id<MTLEvent> getEvent(const std::string& name) const;
+    
+    // Signal an event at the end of a command buffer
+    id<MTLEvent> signalEvent(id<MTLCommandBuffer> commandBuffer, id<MTLDevice> targetDevice = nil);
+    
+    // Wait for an event to reach a specific value
+    void waitForEvent(id<MTLCommandBuffer> commandBuffer, id<MTLEvent> event, uint64_t value);
+    
+    // Event barriers - ensure all devices have completed work
+    void syncAllDevices();
+    void beginFrameBarrier();
+    void endFrameBarrier();
+    
+    // Cleanup
+    void releaseEvents();
+    
+private:
+    MetalContext* _context;
+    
+    // Named events
+    std::unordered_map<std::string, id<MTLEvent>> _namedEvents;
+    
+    // Special events for common synchronization points
+    id<MTLEvent> _frameStartEvent;
+    id<MTLEvent> _frameEndEvent;
+    
+    // Current event values
+    std::unordered_map<id<MTLEvent>, uint64_t> _eventValues;
+    
+    // Mutex for thread safety
+    mutable std::mutex _mutex;
+    
+    // Internal methods
+    id<MTLEvent> createEventForDevice(id<MTLDevice> device);
+};
+
+} // namespace graphics_metal
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_heap_manager.cpp b/src/bundles/graphics_metal/metal/metal_heap_manager.cpp
new file mode 100644
index 0000000000..6e80a6a0fc
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_heap_manager.cpp
@@ -0,0 +1,470 @@
+// metal_heap_manager.cpp
+// Implementation of Metal heaps for efficient resource allocation
+
+#include "metal_heap_manager.hpp"
+#include "metal_context.hpp"
+#include <iostream>
+
+namespace chimerax {
+namespace graphics_metal {
+
+MetalHeapManager::MetalHeapManager(MetalContext* context)
+    : _context(context)
+{
+}
+
+MetalHeapManager::~MetalHeapManager()
+{
+    purgeHeaps();
+}
+
+bool MetalHeapManager::initialize()
+{
+    if (!_context) {
+        return false;
+    }
+    
+    // Check if device supports heaps
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return false;
+    }
+    
+    return true;
+}
+
+id<MTLBuffer> MetalHeapManager::createBuffer(
+    size_t length,
+    MTLResourceOptions options,
+    const std::string& label)
+{
+    if (!_context) {
+        return nil;
+    }
+    
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return nil;
+    }
+    
+    // For very small allocations, use device directly
+    if (length < 4 * 1024) { // Less than 4KB
+        id<MTLBuffer> buffer = [device newBufferWithLength:length options:options];
+        
+        if (buffer && !label.empty()) {
+            NSString* nsLabel = [NSString stringWithUTF8String:label.c_str()];
+            [buffer setLabel:nsLabel];
+        }
+        
+        return buffer;
+    }
+    
+    // For larger allocations, try to use a heap
+    std::lock_guard<std::mutex> lock(_mutex);
+    
+    HeapSizeCategory category = getCategoryForSize(length);
+    id<MTLHeap> heap = findOrCreateHeap(category, HeapType::Buffer, options);
+    
+    if (heap) {
+        // Try to allocate from the heap
+        MTLSizeAndAlign sizeAndAlign = [device heapBufferSizeAndAlignWithLength:length
+                                                                        options:options];
+        
+        if (canAllocateFromHeap(heap, sizeAndAlign.size, options)) {
+            id<MTLBuffer> buffer = [heap newBufferWithLength:length
+                                                     options:options
+                                                      offset:0];
+            
+            if (buffer) {
+                if (!label.empty()) {
+                    NSString* nsLabel = [NSString stringWithUTF8String:label.c_str()];
+                    [buffer setLabel:nsLabel];
+                }
+                return buffer;
+            }
+        }
+        
+        // If we couldn't allocate from this heap, try to create a new one
+        heap = findOrCreateHeap(category, HeapType::Buffer, options);
+        
+        if (heap) {
+            id<MTLBuffer> buffer = [heap newBufferWithLength:length
+                                                     options:options
+                                                      offset:0];
+            
+            if (buffer) {
+                if (!label.empty()) {
+                    NSString* nsLabel = [NSString stringWithUTF8String:label.c_str()];
+                    [buffer setLabel:nsLabel];
+                }
+                return buffer;
+            }
+        }
+    }
+    
+    // If heap allocation failed, fall back to device allocation
+    id<MTLBuffer> buffer = [device newBufferWithLength:length options:options];
+    
+    if (buffer && !label.empty()) {
+        NSString* nsLabel = [NSString stringWithUTF8String:label.c_str()];
+        [buffer setLabel:nsLabel];
+    }
+    
+    return buffer;
+}
+
+id<MTLTexture> MetalHeapManager::createTexture(
+    MTLTextureDescriptor* descriptor,
+    const std::string& label)
+{
+    if (!_context || !descriptor) {
+        return nil;
+    }
+    
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return nil;
+    }
+    
+    // Calculate the texture size
+    MTLSizeAndAlign sizeAndAlign = [device heapTextureSizeAndAlignWithDescriptor:descriptor];
+    
+    // For small textures, use device directly
+    if (sizeAndAlign.size < 256 * 1024) { // Less than 256KB
+        id<MTLTexture> texture = [device newTextureWithDescriptor:descriptor];
+        
+        if (texture && !label.empty()) {
+            NSString* nsLabel = [NSString stringWithUTF8String:label.c_str()];
+            [texture setLabel:nsLabel];
+        }
+        
+        return texture;
+    }
+    
+    // For larger textures, try to use a heap
+    std::lock_guard<std::mutex> lock(_mutex);
+    
+    HeapSizeCategory category = getCategoryForSize(sizeAndAlign.size);
+    MTLResourceOptions options = descriptor.storageMode << MTLResourceStorageModeShift;
+    id<MTLHeap> heap = findOrCreateHeap(category, HeapType::Texture, options);
+    
+    if (heap) {
+        // Try to allocate from the heap
+        if (canAllocateFromHeap(heap, sizeAndAlign.size, options)) {
+            id<MTLTexture> texture = [heap newTextureWithDescriptor:descriptor
+                                                             offset:0];
+            
+            if (texture) {
+                if (!label.empty()) {
+                    NSString* nsLabel = [NSString stringWithUTF8String:label.c_str()];
+                    [texture setLabel:nsLabel];
+                }
+                return texture;
+            }
+        }
+        
+        // If we couldn't allocate from this heap, try to create a new one
+        heap = findOrCreateHeap(category, HeapType::Texture, options);
+        
+        if (heap) {
+            id<MTLTexture> texture = [heap newTextureWithDescriptor:descriptor
+                                                             offset:0];
+            
+            if (texture) {
+                if (!label.empty()) {
+                    NSString* nsLabel = [NSString stringWithUTF8String:label.c_str()];
+                    [texture setLabel:nsLabel];
+                }
+                return texture;
+            }
+        }
+    }
+    
+    // If heap allocation failed, fall back to device allocation
+    id<MTLTexture> texture = [device newTextureWithDescriptor:descriptor];
+    
+    if (texture && !label.empty()) {
+        NSString* nsLabel = [NSString stringWithUTF8String:label.c_str()];
+        [texture setLabel:nsLabel];
+    }
+    
+    return texture;
+}
+
+id<MTLHeap> MetalHeapManager::createHeap(
+    const HeapDescriptor& descriptor,
+    size_t size)
+{
+    if (!_context) {
+        return nil;
+    }
+    
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return nil;
+    }
+    
+    // Create heap descriptor
+    MTLHeapDescriptor* heapDesc = [[MTLHeapDescriptor alloc] init];
+    heapDesc.size = size;
+    heapDesc.storageMode = descriptor.storageMode;
+    heapDesc.cpuCacheMode = descriptor.cacheMode;
+    
+    if (@available(macOS 10.15, *)) {
+        heapDesc.hazardTrackingMode = descriptor.hazardTrackingEnabled ? 
+            MTLHazardTrackingModeTracked : MTLHazardTrackingModeUntracked;
+    }
+    
+    // Create the heap
+    id<MTLHeap> heap = [device newHeapWithDescriptor:heapDesc];
+    [heapDesc release];
+    
+    if (!heap) {
+        std::cerr << "MetalHeapManager::createHeap: Failed to create heap of size " 
+                  << size << std::endl;
+        return nil;
+    }
+    
+    // Set label if provided
+    if (!descriptor.name.empty()) {
+        NSString* nsLabel = [NSString stringWithUTF8String:descriptor.name.c_str()];
+        [heap setLabel:nsLabel];
+    }
+    
+    // Store the heap
+    std::lock_guard<std::mutex> lock(_mutex);
+    _customHeaps.push_back(heap);
+    
+    return heap;
+}
+
+id<MTLBuffer> MetalHeapManager::createBufferFromHeap(
+    id<MTLHeap> heap,
+    size_t length,
+    const std::string& label)
+{
+    if (!heap) {
+        return nil;
+    }
+    
+    // Create buffer from heap
+    id<MTLBuffer> buffer = [heap newBufferWithLength:length
+                                             options:[heap resourceOptions]
+                                              offset:0];
+    
+    if (!buffer) {
+        std::cerr << "MetalHeapManager::createBufferFromHeap: Failed to create buffer of size " 
+                  << length << std::endl;
+        return nil;
+    }
+    
+    // Set label if provided
+    if (!label.empty()) {
+        NSString* nsLabel = [NSString stringWithUTF8String:label.c_str()];
+        [buffer setLabel:nsLabel];
+    }
+    
+    return buffer;
+}
+
+id<MTLTexture> MetalHeapManager::createTextureFromHeap(
+    id<MTLHeap> heap,
+    MTLTextureDescriptor* descriptor,
+    const std::string& label)
+{
+    if (!heap || !descriptor) {
+        return nil;
+    }
+    
+    // Create texture from heap
+    id<MTLTexture> texture = [heap newTextureWithDescriptor:descriptor offset:0];
+    
+    if (!texture) {
+        std::cerr << "MetalHeapManager::createTextureFromHeap: Failed to create texture" << std::endl;
+        return nil;
+    }
+    
+    // Set label if provided
+    if (!label.empty()) {
+        NSString* nsLabel = [NSString stringWithUTF8String:label.c_str()];
+        [texture setLabel:nsLabel];
+    }
+    
+    return texture;
+}
+
+void MetalHeapManager::purgeHeaps()
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    
+    // Release buffer heaps
+    for (auto& pair : _bufferHeaps) {
+        for (id<MTLHeap> heap : pair.second) {
+            [heap release];
+        }
+        pair.second.clear();
+    }
+    
+    // Release texture heaps
+    for (auto& pair : _textureHeaps) {
+        for (id<MTLHeap> heap : pair.second) {
+            [heap release];
+        }
+        pair.second.clear();
+    }
+    
+    // Release custom heaps
+    for (id<MTLHeap> heap : _customHeaps) {
+        [heap release];
+    }
+    _customHeaps.clear();
+}
+
+HeapSizeCategory MetalHeapManager::getCategoryForSize(size_t size)
+{
+    if (size < SMALL_RESOURCE_THRESHOLD) {
+        return HeapSizeCategory::Small;
+    } else if (size < MEDIUM_RESOURCE_THRESHOLD) {
+        return HeapSizeCategory::Medium;
+    } else if (size < LARGE_RESOURCE_THRESHOLD) {
+        return HeapSizeCategory::Large;
+    } else {
+        return HeapSizeCategory::Huge;
+    }
+}
+
+id<MTLHeap> MetalHeapManager::findOrCreateHeap(
+    HeapSizeCategory category,
+    HeapType type,
+    MTLResourceOptions options)
+{
+    if (!_context) {
+        return nil;
+    }
+    
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return nil;
+    }
+    
+    // Determine which heap map to use
+    std::unordered_map<HeapSizeCategory, std::vector<id<MTLHeap>>>& heapMap =
+        (type == HeapType::Buffer) ? _bufferHeaps : _textureHeaps;
+    
+    // Find a compatible heap with enough space
+    auto it = heapMap.find(category);
+    if (it != heapMap.end()) {
+        for (id<MTLHeap> heap : it->second) {
+            MTLStorageMode heapStorageMode = ([heap storageMode] & MTLStorageModeShared);
+            MTLStorageMode requestedStorageMode = ((options >> MTLResourceStorageModeShift) & 0x3);
+            
+            // Check if storage modes are compatible
+            if (heapStorageMode == requestedStorageMode) {
+                // Check if the heap has enough space
+                if (canAllocateFromHeap(heap, 0, options)) {
+                    return heap;
+                }
+            }
+        }
+    }
+    
+    // Create a new heap
+    size_t heapSize;
+    switch (category) {
+        case HeapSizeCategory::Small:
+            heapSize = SMALL_HEAP_SIZE;
+            break;
+        case HeapSizeCategory::Medium:
+            heapSize = MEDIUM_HEAP_SIZE;
+            break;
+        case HeapSizeCategory::Large:
+            heapSize = LARGE_HEAP_SIZE;
+            break;
+        case HeapSizeCategory::Huge:
+            // For huge resources, we create a dedicated heap
+            return nil;
+    }
+    
+    // Create heap descriptor
+    MTLHeapDescriptor* heapDesc = [[MTLHeapDescriptor alloc] init];
+    heapDesc.size = heapSize;
+    heapDesc.storageMode = (MTLStorageMode)((options >> MTLResourceStorageModeShift) & 0x3);
+    heapDesc.cpuCacheMode = (MTLCPUCacheMode)((options >> MTLResourceCPUCacheModeShift) & 0x3);
+    
+    if (@available(macOS 10.15, *)) {
+        heapDesc.hazardTrackingMode = MTLHazardTrackingModeTracked;
+    }
+    
+    // Set the resource options based on type
+    if (type == HeapType::Texture) {
+        heapDesc.type = MTLHeapTypeTexture;
+    } else {
+        heapDesc.type = MTLHeapTypeAutomatic;
+    }
+    
+    // Create the heap
+    id<MTLHeap> heap = [device newHeapWithDescriptor:heapDesc];
+    [heapDesc release];
+    
+    if (!heap) {
+        std::cerr << "MetalHeapManager::findOrCreateHeap: Failed to create heap of size " 
+                  << heapSize << std::endl;
+        return nil;
+    }
+    
+    // Set a label for the heap
+    std::string heapTypeStr = (type == HeapType::Buffer) ? "Buffer" : "Texture";
+    std::string categorySizeStr;
+    switch (category) {
+        case HeapSizeCategory::Small:
+            categorySizeStr = "Small";
+            break;
+        case HeapSizeCategory::Medium:
+            categorySizeStr = "Medium";
+            break;
+        case HeapSizeCategory::Large:
+            categorySizeStr = "Large";
+            break;
+        case HeapSizeCategory::Huge:
+            categorySizeStr = "Huge";
+            break;
+    }
+    
+    std::string heapLabel = heapTypeStr + " " + categorySizeStr + " Heap";
+    NSString* nsLabel = [NSString stringWithUTF8String:heapLabel.c_str()];
+    [heap setLabel:nsLabel];
+    
+    // Store the heap
+    heapMap[category].push_back(heap);
+    
+    return heap;
+}
+
+bool MetalHeapManager::canAllocateFromHeap(id<MTLHeap> heap, size_t size, MTLResourceOptions options)
+{
+    if (!heap) {
+        return false;
+    }
+    
+    // Check if storage modes are compatible
+    MTLStorageMode heapStorageMode = [heap storageMode];
+    MTLStorageMode requestedStorageMode = (MTLStorageMode)((options >> MTLResourceStorageModeShift) & 0x3);
+    
+    if (heapStorageMode != requestedStorageMode) {
+        return false;
+    }
+    
+    // Check if there's enough space
+    size_t currentAllocatedSize = [heap usedSize];
+    size_t heapSize = [heap size];
+    
+    if (size > 0) {
+        return (currentAllocatedSize + size <= heapSize);
+    }
+    
+    // If size is 0, just check if the heap is not completely full
+    return (currentAllocatedSize < heapSize);
+}
+
+} // namespace graphics_metal
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_heap_manager.hpp b/src/bundles/graphics_metal/metal/metal_heap_manager.hpp
new file mode 100644
index 0000000000..696dd5d6b0
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_heap_manager.hpp
@@ -0,0 +1,120 @@
+// metal_heap_manager.hpp
+// Manages Metal heaps for efficient resource allocation
+
+#pragma once
+
+#import <Metal/Metal.h>
+#include <unordered_map>
+#include <memory>
+#include <vector>
+#include <mutex>
+#include <string>
+
+namespace chimerax {
+namespace graphics_metal {
+
+// Forward declarations
+class MetalContext;
+
+/**
+ * Size categories for different heaps
+ */
+enum class HeapSizeCategory {
+    Small,   // For small resources (< 1 MB)
+    Medium,  // For medium resources (1-32 MB)
+    Large,   // For large resources (32-256 MB)
+    Huge     // For huge resources (> 256 MB)
+};
+
+/**
+ * Types of heaps for different resource uses
+ */
+enum class HeapType {
+    Buffer,  // For buffers
+    Texture  // For textures
+};
+
+/**
+ * Heap descriptor for resource allocation
+ */
+struct HeapDescriptor {
+    HeapSizeCategory sizeCategory;
+    HeapType type;
+    MTLStorageMode storageMode;
+    MTLCPUCacheMode cacheMode;
+    bool hazardTrackingEnabled;
+    std::string name;
+};
+
+/**
+ * Manages Metal heaps for efficient resource allocation
+ */
+class MetalHeapManager {
+public:
+    MetalHeapManager(MetalContext* context);
+    ~MetalHeapManager();
+    
+    // Initialization
+    bool initialize();
+    
+    // Create a buffer from heap
+    id<MTLBuffer> createBuffer(
+        size_t length,
+        MTLResourceOptions options = MTLResourceStorageModeShared,
+        const std::string& label = "");
+    
+    // Create a texture from heap
+    id<MTLTexture> createTexture(
+        MTLTextureDescriptor* descriptor,
+        const std::string& label = "");
+    
+    // Create a heap with custom parameters
+    id<MTLHeap> createHeap(
+        const HeapDescriptor& descriptor,
+        size_t size);
+    
+    // Allocate a resource from a specific heap
+    id<MTLBuffer> createBufferFromHeap(
+        id<MTLHeap> heap,
+        size_t length,
+        const std::string& label = "");
+        
+    id<MTLTexture> createTextureFromHeap(
+        id<MTLHeap> heap,
+        MTLTextureDescriptor* descriptor,
+        const std::string& label = "");
+    
+    // Purge all heaps
+    void purgeHeaps();
+    
+private:
+    MetalContext* _context;
+    
+    // Maps of heaps for different size categories and types
+    std::unordered_map<HeapSizeCategory, std::vector<id<MTLHeap>>> _bufferHeaps;
+    std::unordered_map<HeapSizeCategory, std::vector<id<MTLHeap>>> _textureHeaps;
+    
+    // Custom heaps
+    std::vector<id<MTLHeap>> _customHeaps;
+    
+    // Heap size thresholds
+    static const size_t SMALL_HEAP_SIZE = 16 * 1024 * 1024;  // 16 MB
+    static const size_t MEDIUM_HEAP_SIZE = 64 * 1024 * 1024; // 64 MB
+    static const size_t LARGE_HEAP_SIZE = 256 * 1024 * 1024; // 256 MB
+    
+    // Resource size thresholds
+    static const size_t SMALL_RESOURCE_THRESHOLD = 1 * 1024 * 1024;    // 1 MB
+    static const size_t MEDIUM_RESOURCE_THRESHOLD = 32 * 1024 * 1024;  // 32 MB
+    static const size_t LARGE_RESOURCE_THRESHOLD = 256 * 1024 * 1024;  // 256 MB
+    
+    // Mutex for thread safety
+    std::mutex _mutex;
+    
+    // Helper methods
+    HeapSizeCategory getCategoryForSize(size_t size);
+    id<MTLHeap> findOrCreateHeap(HeapSizeCategory category, HeapType type, MTLResourceOptions options);
+    bool canAllocateFromHeap(id<MTLHeap> heap, size_t size, MTLResourceOptions options);
+};
+
+} // namespace graphics_metal
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_multi_gpu.cpp b/src/bundles/graphics_metal/metal/metal_multi_gpu.cpp
new file mode 100644
index 0000000000..230b36112e
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_multi_gpu.cpp
@@ -0,0 +1,361 @@
+// metal_multi_gpu.cpp
+// Implementation of multi-GPU coordination for Metal rendering in ChimeraX
+
+#include "metal_multi_gpu.hpp"
+#include "metal_context.hpp"
+#include "metal_event_manager.hpp"
+#include <iostream>
+#include <algorithm>
+
+namespace chimerax {
+namespace graphics_metal {
+
+MetalMultiGPU::MetalMultiGPU()
+    : _context(nullptr)
+    , _enabled(false)
+    , _strategy(MultiGPUStrategy::SplitFrame)
+    , _frameCounter(0)
+    , _eventManager(nullptr)
+{
+}
+
+MetalMultiGPU::~MetalMultiGPU()
+{
+    // We don't own _context or _eventManager, so no need to delete them
+}
+
+bool MetalMultiGPU::initialize(MetalContext* context)
+{
+    if (!context) {
+        return false;
+    }
+    
+    _context = context;
+    
+    // Get event manager from context
+    _eventManager = _context->eventManager();
+    if (!_eventManager) {
+        std::cerr << "MetalMultiGPU::initialize: No event manager available" << std::endl;
+        return false;
+    }
+    
+    // Check if multiple devices are available
+    std::vector<id<MTLDevice>> devices = _context->allDevices();
+    if (devices.size() <= 1) {
+        std::cerr << "MetalMultiGPU::initialize: Only one device available, multi-GPU disabled" << std::endl;
+        return true; // Not an error, just no multi-GPU
+    }
+    
+    // Initialize device activity map - start with all devices active
+    for (id<MTLDevice> device : devices) {
+        _deviceActivityMap[device] = true;
+        _activeDevices.push_back(device);
+    }
+    
+    return true;
+}
+
+std::vector<GPUDeviceInfo> MetalMultiGPU::getDeviceInfo() const
+{
+    std::vector<GPUDeviceInfo> deviceInfos;
+    
+    if (!_context) {
+        return deviceInfos;
+    }
+    
+    // Get all devices from context
+    std::vector<id<MTLDevice>> devices = _context->allDevices();
+    id<MTLDevice> primaryDevice = _context->device();
+    
+    for (id<MTLDevice> device : devices) {
+        GPUDeviceInfo info;
+        info.name = [[device name] UTF8String];
+        info.isPrimary = (device == primaryDevice);
+        info.isActive = isDeviceActive(device);
+        info.unifiedMemory = [device hasUnifiedMemory];
+        
+        // Get memory size if available
+        if (@available(macOS 10.13, *)) {
+            info.memorySize = [device recommendedMaxWorkingSetSize];
+        } else {
+            info.memorySize = 0;
+        }
+        
+        deviceInfos.push_back(info);
+    }
+    
+    return deviceInfos;
+}
+
+bool MetalMultiGPU::enable(bool enabled, MultiGPUStrategy strategy)
+{
+    if (!_context) {
+        return false;
+    }
+    
+    // Check if multiple devices are available
+    if (_context->allDevices().size() <= 1) {
+        _enabled = false;
+        return false;
+    }
+    
+    _enabled = enabled;
+    
+    if (enabled) {
+        _strategy = strategy;
+        
+        // Update active devices based on strategy
+        _activeDevices.clear();
+        for (const auto& pair : _deviceActivityMap) {
+            if (pair.second) {
+                _activeDevices.push_back(pair.first);
+            }
+        }
+        
+        // Log the strategy
+        std::string strategyName;
+        switch (_strategy) {
+            case MultiGPUStrategy::SplitFrame:
+                strategyName = "Split Frame";
+                break;
+            case MultiGPUStrategy::TaskBased:
+                strategyName = "Task Based";
+                break;
+            case MultiGPUStrategy::Alternating:
+                strategyName = "Alternating Frames";
+                break;
+            case MultiGPUStrategy::ComputeOffload:
+                strategyName = "Compute Offload";
+                break;
+        }
+        
+        std::cout << "Multi-GPU enabled with strategy: " << strategyName << std::endl;
+        std::cout << "Active GPUs: " << _activeDevices.size() << std::endl;
+    }
+    
+    return true;
+}
+
+bool MetalMultiGPU::setDeviceActive(id<MTLDevice> device, bool active)
+{
+    if (!_context) {
+        return false;
+    }
+    
+    // Check if device is valid
+    std::vector<id<MTLDevice>> allDevices = _context->allDevices();
+    auto it = std::find(allDevices.begin(), allDevices.end(), device);
+    if (it == allDevices.end()) {
+        std::cerr << "MetalMultiGPU::setDeviceActive: Invalid device" << std::endl;
+        return false;
+    }
+    
+    // Don't allow deactivating the primary device
+    if (device == _context->device() && !active) {
+        std::cerr << "MetalMultiGPU::setDeviceActive: Cannot deactivate primary device" << std::endl;
+        return false;
+    }
+    
+    // Update device activity map
+    _deviceActivityMap[device] = active;
+    
+    // Update active devices list if enabled
+    if (_enabled) {
+        _activeDevices.clear();
+        for (const auto& pair : _deviceActivityMap) {
+            if (pair.second) {
+                _activeDevices.push_back(pair.first);
+            }
+        }
+    }
+    
+    return true;
+}
+
+bool MetalMultiGPU::isDeviceActive(id<MTLDevice> device) const
+{
+    if (!_context) {
+        return false;
+    }
+    
+    auto it = _deviceActivityMap.find(device);
+    if (it != _deviceActivityMap.end()) {
+        return it->second;
+    }
+    
+    return false;
+}
+
+std::vector<id<MTLDevice>> MetalMultiGPU::getActiveDevices() const
+{
+    if (!_enabled) {
+        // If multi-GPU is disabled, only return the primary device
+        std::vector<id<MTLDevice>> result;
+        if (_context) {
+            result.push_back(_context->device());
+        }
+        return result;
+    }
+    
+    return _activeDevices;
+}
+
+void MetalMultiGPU::computeSplitFrameRegions(uint32_t width, uint32_t height, std::vector<MTLRegion>& regions)
+{
+    regions.clear();
+    
+    if (!_enabled || _activeDevices.empty()) {
+        // If multi-GPU is disabled, return full frame region
+        MTLRegion fullRegion = MTLRegionMake2D(0, 0, width, height);
+        regions.push_back(fullRegion);
+        return;
+    }
+    
+    // Get workload ratios for active devices
+    std::vector<float> ratios = calculateDeviceWorkloadRatios();
+    
+    // Calculate regions based on strategy
+    switch (_strategy) {
+        case MultiGPUStrategy::SplitFrame: {
+            // Split the frame horizontally based on device ratios
+            float totalHeight = static_cast<float>(height);
+            float currentY = 0.0f;
+            
+            for (size_t i = 0; i < _activeDevices.size(); ++i) {
+                float deviceRatio = ratios[i];
+                uint32_t regionHeight = static_cast<uint32_t>(totalHeight * deviceRatio);
+                
+                // Ensure the last region covers the rest of the frame
+                if (i == _activeDevices.size() - 1) {
+                    regionHeight = height - static_cast<uint32_t>(currentY);
+                }
+                
+                MTLRegion region = MTLRegionMake2D(
+                    0, static_cast<uint32_t>(currentY),
+                    width, regionHeight
+                );
+                
+                regions.push_back(region);
+                currentY += regionHeight;
+            }
+            break;
+        }
+        
+        case MultiGPUStrategy::TaskBased:
+        case MultiGPUStrategy::Alternating:
+        case MultiGPUStrategy::ComputeOffload:
+            // These strategies don't split the frame, so return full frame region
+            MTLRegion fullRegion = MTLRegionMake2D(0, 0, width, height);
+            regions.push_back(fullRegion);
+            break;
+    }
+}
+
+id<MTLEvent> MetalMultiGPU::signalEvent(id<MTLCommandBuffer> commandBuffer, id<MTLDevice> waitingDevice)
+{
+    if (!_enabled || !_eventManager || !commandBuffer) {
+        return nil;
+    }
+    
+    return _eventManager->signalEvent(commandBuffer, waitingDevice);
+}
+
+void MetalMultiGPU::waitForEvent(id<MTLCommandBuffer> commandBuffer, id<MTLEvent> event, uint64_t value)
+{
+    if (!_enabled || !_eventManager || !commandBuffer || !event) {
+        return;
+    }
+    
+    _eventManager->waitForEvent(commandBuffer, event, value);
+}
+
+bool MetalMultiGPU::shareResource(id<MTLResource> resource, id<MTLDevice> sourceDevice, id<MTLDevice> targetDevice)
+{
+    if (!_enabled || !resource || !sourceDevice || !targetDevice) {
+        return false;
+    }
+    
+    // Check if the resource is shareable
+    if (!([resource storageMode] == MTLStorageModeShared ||
+          [resource storageMode] == MTLStorageModeManaged)) {
+        std::cerr << "MetalMultiGPU::shareResource: Resource must be in Shared or Managed storage mode" << std::endl;
+        return false;
+    }
+    
+    // Create a shared event to synchronize access
+    id<MTLEvent> event = [sourceDevice newEvent];
+    if (!event) {
+        std::cerr << "MetalMultiGPU::shareResource: Failed to create synchronization event" << std::endl;
+        return false;
+    }
+    
+    // In a real implementation, we would use the MTLSharedEvent to synchronize
+    // access to the resource between the devices. This would involve:
+    // 1. Signaling the event on the source device when done with the resource
+    // 2. Waiting for the event on the target device before accessing the resource
+    
+    // For now, we'll just simulate successful sharing
+    [event release];
+    return true;
+}
+
+void MetalMultiGPU::beginFrame()
+{
+    if (!_enabled) {
+        return;
+    }
+    
+    // For alternating strategy, increment frame counter
+    if (_strategy == MultiGPUStrategy::Alternating) {
+        _frameCounter++;
+    }
+}
+
+void MetalMultiGPU::endFrame()
+{
+    // Nothing special to do at end of frame yet
+}
+
+id<MTLDevice> MetalMultiGPU::getCurrentFrameDevice() const
+{
+    if (!_enabled || _activeDevices.empty()) {
+        if (_context) {
+            return _context->device();
+        }
+        return nil;
+    }
+    
+    // For alternating strategy, select device based on frame counter
+    if (_strategy == MultiGPUStrategy::Alternating) {
+        size_t deviceIndex = _frameCounter % _activeDevices.size();
+        return _activeDevices[deviceIndex];
+    }
+    
+    // For other strategies, return primary device
+    return _context->device();
+}
+
+std::vector<float> MetalMultiGPU::calculateDeviceWorkloadRatios() const
+{
+    std::vector<float> ratios;
+    
+    if (_activeDevices.empty()) {
+        return ratios;
+    }
+    
+    // For now, simply divide work equally among devices
+    float equalRatio = 1.0f / static_cast<float>(_activeDevices.size());
+    for (size_t i = 0; i < _activeDevices.size(); ++i) {
+        ratios.push_back(equalRatio);
+    }
+    
+    // In a more advanced implementation, we could assign workload based on:
+    // - Device performance (compute units, memory bandwidth)
+    // - Device type (integrated vs discrete)
+    // - Historical performance data
+    
+    return ratios;
+}
+
+} // namespace graphics_metal
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_multi_gpu.hpp b/src/bundles/graphics_metal/metal/metal_multi_gpu.hpp
new file mode 100644
index 0000000000..a4352498c4
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_multi_gpu.hpp
@@ -0,0 +1,99 @@
+// metal_multi_gpu.hpp
+// Multi-GPU coordination for Metal rendering in ChimeraX
+
+#pragma once
+
+#import <Metal/Metal.h>
+#include <memory>
+#include <vector>
+#include <unordered_map>
+#include <string>
+
+namespace chimerax {
+namespace graphics_metal {
+
+// Forward declarations
+class MetalContext;
+class MetalEventManager;
+
+/**
+ * Multi-GPU rendering strategies
+ */
+enum class MultiGPUStrategy {
+    SplitFrame = 0,    // Each GPU renders a portion of the screen
+    TaskBased = 1,     // Distribute rendering tasks across GPUs
+    Alternating = 2,   // Alternate frames between GPUs
+    ComputeOffload = 3 // Main GPU renders, other GPUs handle compute tasks
+};
+
+/**
+ * Information about a GPU device
+ */
+struct GPUDeviceInfo {
+    std::string name;
+    bool isPrimary;
+    bool isActive;
+    bool unifiedMemory;
+    uint64_t memorySize;
+};
+
+/**
+ * Manages synchronization between multiple GPUs
+ */
+class MetalMultiGPU {
+public:
+    MetalMultiGPU();
+    ~MetalMultiGPU();
+    
+    // Initialize with Metal context
+    bool initialize(MetalContext* context);
+    
+    // Get available devices
+    std::vector<GPUDeviceInfo> getDeviceInfo() const;
+    
+    // Enable/disable multi-GPU and set strategy
+    bool enable(bool enabled, MultiGPUStrategy strategy = MultiGPUStrategy::SplitFrame);
+    bool isEnabled() const { return _enabled; }
+    
+    // Get current strategy
+    MultiGPUStrategy getStrategy() const { return _strategy; }
+    
+    // Active device management
+    bool setDeviceActive(id<MTLDevice> device, bool active);
+    bool isDeviceActive(id<MTLDevice> device) const;
+    std::vector<id<MTLDevice>> getActiveDevices() const;
+    
+    // Workload distribution
+    void computeSplitFrameRegions(uint32_t width, uint32_t height, std::vector<MTLRegion>& regions);
+    
+    // Synchronization
+    id<MTLEvent> signalEvent(id<MTLCommandBuffer> commandBuffer, id<MTLDevice> waitingDevice);
+    void waitForEvent(id<MTLCommandBuffer> commandBuffer, id<MTLEvent> event, uint64_t value);
+    
+    // Resource sharing
+    bool shareResource(id<MTLResource> resource, id<MTLDevice> sourceDevice, id<MTLDevice> targetDevice);
+    
+    // Frame pacing for alternating strategy
+    void beginFrame();
+    void endFrame();
+    id<MTLDevice> getCurrentFrameDevice() const;
+    
+private:
+    MetalContext* _context;
+    bool _enabled;
+    MultiGPUStrategy _strategy;
+    std::vector<id<MTLDevice>> _activeDevices;
+    std::unordered_map<id<MTLDevice>, bool> _deviceActivityMap;
+    
+    // Frame counter for alternating strategy
+    uint64_t _frameCounter;
+    
+    // Cached event manager for synchronization
+    MetalEventManager* _eventManager;
+    
+    // Helper method to calculate device workload ratios
+    std::vector<float> calculateDeviceWorkloadRatios() const;
+};
+
+} // namespace graphics_metal
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_renderer.cpp b/src/bundles/graphics_metal/metal/metal_renderer.cpp
new file mode 100644
index 0000000000..748d625440
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_renderer.cpp
@@ -0,0 +1,309 @@
+// metal_renderer.cpp
+// Implementation of Metal rendering for ChimeraX
+
+#include "metal_renderer.hpp"
+#include "metal_context.hpp"
+#include "metal_resources.hpp"
+#include "metal_scene.hpp"
+#include <iostream>
+
+namespace chimerax {
+namespace graphics {
+
+MetalRenderer::MetalRenderer(MetalContext* context)
+    : _context(context)
+    , _scene(nullptr)
+    , _spherePipelineState(nil)
+    , _cylinderPipelineState(nil)
+    , _trianglePipelineState(nil)
+    , _defaultDepthState(nil)
+    , _uniformBuffer(nil)
+{
+}
+
+MetalRenderer::~MetalRenderer()
+{
+    if (_uniformBuffer) {
+        [_uniformBuffer release];
+    }
+    
+    // Pipeline states are owned by the resources manager
+}
+
+bool MetalRenderer::initialize()
+{
+    // Check context
+    if (!_context || !_context->isInitialized()) {
+        std::cerr << "MetalRenderer::initialize: No valid Metal context" << std::endl;
+        return false;
+    }
+
+    // Create uniform buffer
+    _uniformBuffer = _context->resources()->createBuffer(
+        nullptr, sizeof(Uniforms), MTLResourceStorageModeShared);
+        
+    if (!_uniformBuffer) {
+        std::cerr << "MetalRenderer::initialize: Failed to create uniform buffer" << std::endl;
+        return false;
+    }
+
+    // Create render pipelines
+    if (!createPipelines()) {
+        std::cerr << "MetalRenderer::initialize: Failed to create render pipelines" << std::endl;
+        return false;
+    }
+
+    return true;
+}
+
+bool MetalRenderer::createPipelines()
+{
+    MetalResources* resources = _context->resources();
+    
+    // Create default depth state
+    _defaultDepthState = resources->createDepthStencilState(
+        true, true, MTLCompareFunctionLess);
+    
+    if (!_defaultDepthState) {
+        return false;
+    }
+    
+    // Create sphere pipeline
+    _spherePipelineState = resources->createRenderPipelineState(
+        "vertexSphere", "fragmentSphere",
+        MTLPixelFormatBGRA8Unorm, MTLPixelFormatDepth32Float, true);
+    
+    if (!_spherePipelineState) {
+        return false;
+    }
+    
+    // Create cylinder pipeline
+    _cylinderPipelineState = resources->createRenderPipelineState(
+        "vertexCylinder", "fragmentCylinder",
+        MTLPixelFormatBGRA8Unorm, MTLPixelFormatDepth32Float, true);
+    
+    if (!_cylinderPipelineState) {
+        return false;
+    }
+    
+    // Create triangle pipeline
+    _trianglePipelineState = resources->createRenderPipelineState(
+        "vertexTriangle", "fragmentTriangle",
+        MTLPixelFormatBGRA8Unorm, MTLPixelFormatDepth32Float, true);
+    
+    if (!_trianglePipelineState) {
+        return false;
+    }
+    
+    return true;
+}
+
+void MetalRenderer::beginFrame()
+{
+    // Clear the uniform buffer data
+    Uniforms* uniforms = static_cast<Uniforms*>([_uniformBuffer contents]);
+    if (uniforms) {
+        // Initialize with default values
+        uniforms->modelMatrix = simd::float4x4(1.0f);
+        uniforms->viewMatrix = simd::float4x4(1.0f);
+        uniforms->projectionMatrix = simd::float4x4(1.0f);
+        uniforms->normalMatrix = simd::float4x4(1.0f);
+        
+        uniforms->cameraPosition = simd::float3(0.0f, 0.0f, 5.0f);
+        
+        uniforms->lightPosition = simd::float3(0.0f, 5.0f, 5.0f);
+        uniforms->lightRadius = 50.0f;
+        uniforms->lightColor = simd::float3(1.0f, 1.0f, 1.0f);
+        uniforms->lightIntensity = 1.0f;
+        uniforms->ambientColor = simd::float3(0.1f, 0.1f, 0.1f);
+        uniforms->ambientIntensity = 1.0f;
+        
+        // If we have a scene, update with scene values
+        if (_scene) {
+            // TODO: Get actual values from scene
+        }
+    }
+}
+
+void MetalRenderer::endFrame()
+{
+    // Nothing to do here yet
+}
+
+void MetalRenderer::updateUniforms(id<MTLCommandBuffer> commandBuffer)
+{
+    // In a real implementation, this would update uniform values
+    // from the current scene/camera state. For now, this is just a placeholder.
+}
+
+void MetalRenderer::renderSpheres(
+    id<MTLBuffer> positionBuffer,
+    id<MTLBuffer> colorBuffer,
+    id<MTLBuffer> radiusBuffer,
+    uint32_t count)
+{
+    if (!_context || !positionBuffer || count == 0) {
+        return;
+    }
+    
+    MTKView* view = _context->mtkView();
+    if (!view) {
+        return;
+    }
+    
+    id<MTLCommandQueue> commandQueue = _context->commandQueue();
+    id<CAMetalDrawable> drawable = [view currentDrawable];
+    MTLRenderPassDescriptor* renderPassDescriptor = [view currentRenderPassDescriptor];
+    
+    if (!commandQueue || !drawable || !renderPassDescriptor) {
+        return;
+    }
+    
+    // Create command buffer
+    id<MTLCommandBuffer> commandBuffer = [commandQueue commandBuffer];
+    [commandBuffer setLabel:@"Sphere Render Command Buffer"];
+    
+    // Update uniforms
+    updateUniforms(commandBuffer);
+    
+    // Create render command encoder
+    id<MTLRenderCommandEncoder> renderEncoder = [commandBuffer renderCommandEncoderWithDescriptor:renderPassDescriptor];
+    [renderEncoder setLabel:@"Sphere Render Encoder"];
+    
+    // Set render pipeline
+    [renderEncoder setRenderPipelineState:_spherePipelineState];
+    [renderEncoder setDepthStencilState:_defaultDepthState];
+    
+    // Set buffers
+    [renderEncoder setVertexBuffer:positionBuffer offset:0 atIndex:0];
+    [renderEncoder setVertexBuffer:colorBuffer offset:0 atIndex:1];
+    [renderEncoder setVertexBuffer:radiusBuffer offset:0 atIndex:2];
+    [renderEncoder setVertexBuffer:_uniformBuffer offset:0 atIndex:3];
+    [renderEncoder setFragmentBuffer:_uniformBuffer offset:0 atIndex:0];
+    
+    // Draw spheres
+    [renderEncoder drawPrimitives:MTLPrimitiveTypePoint vertexStart:0 vertexCount:count];
+    
+    // End encoding and submit
+    [renderEncoder endEncoding];
+    [commandBuffer presentDrawable:drawable];
+    [commandBuffer commit];
+}
+
+void MetalRenderer::renderCylinders(
+    id<MTLBuffer> startPositionBuffer,
+    id<MTLBuffer> endPositionBuffer,
+    id<MTLBuffer> colorBuffer,
+    id<MTLBuffer> radiusBuffer,
+    uint32_t count)
+{
+    if (!_context || !startPositionBuffer || !endPositionBuffer || count == 0) {
+        return;
+    }
+    
+    MTKView* view = _context->mtkView();
+    if (!view) {
+        return;
+    }
+    
+    id<MTLCommandQueue> commandQueue = _context->commandQueue();
+    id<CAMetalDrawable> drawable = [view currentDrawable];
+    MTLRenderPassDescriptor* renderPassDescriptor = [view currentRenderPassDescriptor];
+    
+    if (!commandQueue || !drawable || !renderPassDescriptor) {
+        return;
+    }
+    
+    // Create command buffer
+    id<MTLCommandBuffer> commandBuffer = [commandQueue commandBuffer];
+    [commandBuffer setLabel:@"Cylinder Render Command Buffer"];
+    
+    // Update uniforms
+    updateUniforms(commandBuffer);
+    
+    // Create render command encoder
+    id<MTLRenderCommandEncoder> renderEncoder = [commandBuffer renderCommandEncoderWithDescriptor:renderPassDescriptor];
+    [renderEncoder setLabel:@"Cylinder Render Encoder"];
+    
+    // Set render pipeline
+    [renderEncoder setRenderPipelineState:_cylinderPipelineState];
+    [renderEncoder setDepthStencilState:_defaultDepthState];
+    
+    // Set buffers
+    [renderEncoder setVertexBuffer:startPositionBuffer offset:0 atIndex:0];
+    [renderEncoder setVertexBuffer:endPositionBuffer offset:0 atIndex:1];
+    [renderEncoder setVertexBuffer:colorBuffer offset:0 atIndex:2];
+    [renderEncoder setVertexBuffer:radiusBuffer offset:0 atIndex:3];
+    [renderEncoder setVertexBuffer:_uniformBuffer offset:0 atIndex:4];
+    [renderEncoder setFragmentBuffer:_uniformBuffer offset:0 atIndex:0];
+    
+    // Draw cylinders (as lines with geometry shader)
+    [renderEncoder drawPrimitives:MTLPrimitiveTypeLine vertexStart:0 vertexCount:count * 2];
+    
+    // End encoding and submit
+    [renderEncoder endEncoding];
+    [commandBuffer presentDrawable:drawable];
+    [commandBuffer commit];
+}
+
+void MetalRenderer::renderTriangles(
+    id<MTLBuffer> vertexBuffer,
+    id<MTLBuffer> colorBuffer,
+    id<MTLBuffer> normalBuffer,
+    id<MTLBuffer> indexBuffer,
+    uint32_t indexCount)
+{
+    if (!_context || !vertexBuffer || !indexBuffer || indexCount == 0) {
+        return;
+    }
+    
+    MTKView* view = _context->mtkView();
+    if (!view) {
+        return;
+    }
+    
+    id<MTLCommandQueue> commandQueue = _context->commandQueue();
+    id<CAMetalDrawable> drawable = [view currentDrawable];
+    MTLRenderPassDescriptor* renderPassDescriptor = [view currentRenderPassDescriptor];
+    
+    if (!commandQueue || !drawable || !renderPassDescriptor) {
+        return;
+    }
+    
+    // Create command buffer
+    id<MTLCommandBuffer> commandBuffer = [commandQueue commandBuffer];
+    [commandBuffer setLabel:@"Triangle Render Command Buffer"];
+    
+    // Update uniforms
+    updateUniforms(commandBuffer);
+    
+    // Create render command encoder
+    id<MTLRenderCommandEncoder> renderEncoder = [commandBuffer renderCommandEncoderWithDescriptor:renderPassDescriptor];
+    [renderEncoder setLabel:@"Triangle Render Encoder"];
+    
+    // Set render pipeline
+    [renderEncoder setRenderPipelineState:_trianglePipelineState];
+    [renderEncoder setDepthStencilState:_defaultDepthState];
+    
+    // Set buffers
+    [renderEncoder setVertexBuffer:vertexBuffer offset:0 atIndex:0];
+    [renderEncoder setVertexBuffer:colorBuffer offset:0 atIndex:1];
+    [renderEncoder setVertexBuffer:normalBuffer offset:0 atIndex:2];
+    [renderEncoder setVertexBuffer:_uniformBuffer offset:0 atIndex:3];
+    [renderEncoder setFragmentBuffer:_uniformBuffer offset:0 atIndex:0];
+    
+    // Draw triangles
+    [renderEncoder drawIndexedPrimitives:MTLPrimitiveTypeTriangle
+                              indexCount:indexCount
+                               indexType:MTLIndexTypeUInt32
+                             indexBuffer:indexBuffer
+                       indexBufferOffset:0];
+    
+    // End encoding and submit
+    [renderEncoder endEncoding];
+    [commandBuffer presentDrawable:drawable];
+    [commandBuffer commit];
+}
+
+} // namespace graphics
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_renderer.hpp b/src/bundles/graphics_metal/metal/metal_renderer.hpp
new file mode 100644
index 0000000000..6782755f31
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_renderer.hpp
@@ -0,0 +1,119 @@
+// metal_renderer.hpp
+// Core Metal rendering functionality for ChimeraX
+
+#pragma once
+
+#import <Metal/Metal.h>
+#import <MetalKit/MetalKit.h>
+#include <memory>
+#include <vector>
+
+namespace chimerax {
+namespace graphics {
+
+// Forward declarations
+class MetalContext;
+class MetalScene;
+
+/**
+ * Common uniforms for all shaders - should match shaders in metal_shaders.metal
+ */
+struct Uniforms {
+    // Matrices
+    simd::float4x4 modelMatrix;
+    simd::float4x4 viewMatrix;
+    simd::float4x4 projectionMatrix;
+    simd::float4x4 normalMatrix;
+    
+    // Camera
+    simd::float3 cameraPosition;
+    float padding1;
+    
+    // Lighting
+    simd::float3 lightPosition;
+    float lightRadius;
+    simd::float3 lightColor;
+    float lightIntensity;
+    simd::float3 ambientColor;
+    float ambientIntensity;
+};
+
+/**
+ * Material properties for various rendering modes
+ */
+struct MaterialProperties {
+    // Basic properties
+    simd::float4 color;
+    float roughness;
+    float metallic;
+    float ambientOcclusion;
+    float padding;
+    
+    // Additional properties for molecular rendering
+    float atomRadius;
+    float bondRadius;
+    float outlineWidth;
+    float outlineStrength;
+};
+
+/**
+ * Core renderer for Metal-based graphics in ChimeraX
+ */
+class MetalRenderer {
+public:
+    // Constructor
+    MetalRenderer(MetalContext* context);
+    ~MetalRenderer();
+    
+    // Initialization
+    bool initialize();
+    
+    // Rendering methods
+    void beginFrame();
+    void endFrame();
+    
+    // Scene management
+    void setScene(MetalScene* scene) { _scene = scene; }
+    MetalScene* scene() const { return _scene; }
+    
+    // Rendering of basic elements
+    void renderSpheres(
+        id<MTLBuffer> positionBuffer,
+        id<MTLBuffer> colorBuffer,
+        id<MTLBuffer> radiusBuffer,
+        uint32_t count);
+        
+    void renderCylinders(
+        id<MTLBuffer> startPositionBuffer,
+        id<MTLBuffer> endPositionBuffer,
+        id<MTLBuffer> colorBuffer,
+        id<MTLBuffer> radiusBuffer,
+        uint32_t count);
+        
+    void renderTriangles(
+        id<MTLBuffer> vertexBuffer,
+        id<MTLBuffer> colorBuffer,
+        id<MTLBuffer> normalBuffer,
+        id<MTLBuffer> indexBuffer,
+        uint32_t indexCount);
+
+private:
+    MetalContext* _context;
+    MetalScene* _scene;
+    
+    // Metal pipeline objects
+    id<MTLRenderPipelineState> _spherePipelineState;
+    id<MTLRenderPipelineState> _cylinderPipelineState;
+    id<MTLRenderPipelineState> _trianglePipelineState;
+    id<MTLDepthStencilState> _defaultDepthState;
+    
+    // Uniform buffers
+    id<MTLBuffer> _uniformBuffer;
+    
+    // Internal methods
+    bool createPipelines();
+    void updateUniforms(id<MTLCommandBuffer> commandBuffer);
+};
+
+} // namespace graphics
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_resources.cpp b/src/bundles/graphics_metal/metal/metal_resources.cpp
new file mode 100644
index 0000000000..fa0a1a4f97
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_resources.cpp
@@ -0,0 +1,435 @@
+// metal_resources.cpp
+// Implementation of Metal resource management for ChimeraX
+
+#include "metal_resources.hpp"
+#include "metal_context.hpp"
+#include <iostream>
+#include <sstream>
+
+namespace chimerax {
+namespace graphics {
+
+MetalResources::MetalResources(MetalContext* context)
+    : _context(context)
+    , _defaultLibrary(nil)
+{
+}
+
+MetalResources::~MetalResources()
+{
+    releaseResources();
+}
+
+bool MetalResources::initialize()
+{
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return false;
+    }
+    
+    // Load default library
+    NSError* error = nil;
+    _defaultLibrary = [device newDefaultLibrary];
+    if (!_defaultLibrary) {
+        std::cerr << "Failed to load default Metal library" << std::endl;
+        return false;
+    }
+    
+    // Add to libraries list
+    ShaderLibraryInfo defaultLib;
+    defaultLib.library = _defaultLibrary;
+    defaultLib.name = "default";
+    defaultLib.isDefault = true;
+    _libraries.push_back(defaultLib);
+    
+    return true;
+}
+
+void MetalResources::releaseResources()
+{
+    // Release all render pipeline states
+    for (auto& pair : _renderPipelineStates) {
+        [pair.second release];
+    }
+    _renderPipelineStates.clear();
+    
+    // Release all depth stencil states
+    for (auto& pair : _depthStencilStates) {
+        [pair.second release];
+    }
+    _depthStencilStates.clear();
+    
+    // Release all sampler states
+    for (auto& pair : _samplerStates) {
+        [pair.second release];
+    }
+    _samplerStates.clear();
+    
+    // Release all shader libraries
+    for (auto& lib : _libraries) {
+        [lib.library release];
+    }
+    _libraries.clear();
+    
+    _defaultLibrary = nil;
+}
+
+id<MTLLibrary> MetalResources::loadLibrary(const std::string& filename)
+{
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return nil;
+    }
+    
+    // Check if library already loaded
+    for (const auto& lib : _libraries) {
+        if (lib.name == filename) {
+            return lib.library;
+        }
+    }
+    
+    // Load library from file
+    NSString* path = [NSString stringWithUTF8String:filename.c_str()];
+    NSError* error = nil;
+    id<MTLLibrary> library = [device newLibraryWithFile:path error:&error];
+    
+    if (!library) {
+        std::cerr << "Failed to load Metal library from file: " << filename << std::endl;
+        if (error) {
+            std::cerr << "Error: " << [[error localizedDescription] UTF8String] << std::endl;
+        }
+        return nil;
+    }
+    
+    // Add to libraries list
+    ShaderLibraryInfo libInfo;
+    libInfo.library = library;
+    libInfo.name = filename;
+    libInfo.isDefault = false;
+    _libraries.push_back(libInfo);
+    
+    return library;
+}
+
+id<MTLLibrary> MetalResources::loadLibraryFromSource(const std::string& source, const std::string& name)
+{
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return nil;
+    }
+    
+    // Check if library already loaded
+    for (const auto& lib : _libraries) {
+        if (lib.name == name) {
+            return lib.library;
+        }
+    }
+    
+    // Load library from source
+    NSString* nsSource = [NSString stringWithUTF8String:source.c_str()];
+    MTLCompileOptions* options = [[MTLCompileOptions alloc] init];
+    [options setLanguageVersion:MTLLanguageVersion2_0];
+    
+    NSError* error = nil;
+    id<MTLLibrary> library = [device newLibraryWithSource:nsSource options:options error:&error];
+    
+    [options release];
+    
+    if (!library) {
+        std::cerr << "Failed to load Metal library from source: " << name << std::endl;
+        if (error) {
+            std::cerr << "Error: " << [[error localizedDescription] UTF8String] << std::endl;
+        }
+        return nil;
+    }
+    
+    // Add to libraries list
+    ShaderLibraryInfo libInfo;
+    libInfo.library = library;
+    libInfo.name = name;
+    libInfo.isDefault = false;
+    _libraries.push_back(libInfo);
+    
+    return library;
+}
+
+id<MTLFunction> MetalResources::loadFunction(const std::string& functionName, id<MTLLibrary> library)
+{
+    if (!library) {
+        library = _defaultLibrary;
+    }
+    
+    if (!library) {
+        return nil;
+    }
+    
+    NSString* nsFunctionName = [NSString stringWithUTF8String:functionName.c_str()];
+    id<MTLFunction> function = [library newFunctionWithName:nsFunctionName];
+    
+    if (!function) {
+        std::cerr << "Failed to load Metal function: " << functionName << std::endl;
+    }
+    
+    return function;
+}
+
+id<MTLRenderPipelineState> MetalResources::createRenderPipelineState(
+    const std::string& vertexFunction,
+    const std::string& fragmentFunction,
+    MTLPixelFormat colorPixelFormat,
+    MTLPixelFormat depthPixelFormat,
+    bool blendingEnabled)
+{
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return nil;
+    }
+    
+    // Generate key for caching
+    std::string key = generatePipelineStateKey(
+        vertexFunction, fragmentFunction, colorPixelFormat, depthPixelFormat, blendingEnabled);
+    
+    // Check if pipeline state already exists
+    auto it = _renderPipelineStates.find(key);
+    if (it != _renderPipelineStates.end()) {
+        return it->second;
+    }
+    
+    // Load shader functions
+    id<MTLFunction> vertexFunc = loadFunction(vertexFunction);
+    id<MTLFunction> fragmentFunc = loadFunction(fragmentFunction);
+    
+    if (!vertexFunc || !fragmentFunc) {
+        return nil;
+    }
+    
+    // Create pipeline descriptor
+    MTLRenderPipelineDescriptor* pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
+    pipelineDescriptor.vertexFunction = vertexFunc;
+    pipelineDescriptor.fragmentFunction = fragmentFunc;
+    pipelineDescriptor.colorAttachments[0].pixelFormat = colorPixelFormat;
+    pipelineDescriptor.depthAttachmentPixelFormat = depthPixelFormat;
+    
+    // Configure blending if enabled
+    if (blendingEnabled) {
+        pipelineDescriptor.colorAttachments[0].blendingEnabled = YES;
+        pipelineDescriptor.colorAttachments[0].sourceRGBBlendFactor = MTLBlendFactorSourceAlpha;
+        pipelineDescriptor.colorAttachments[0].destinationRGBBlendFactor = MTLBlendFactorOneMinusSourceAlpha;
+        pipelineDescriptor.colorAttachments[0].rgbBlendOperation = MTLBlendOperationAdd;
+        pipelineDescriptor.colorAttachments[0].sourceAlphaBlendFactor = MTLBlendFactorSourceAlpha;
+        pipelineDescriptor.colorAttachments[0].destinationAlphaBlendFactor = MTLBlendFactorOneMinusSourceAlpha;
+        pipelineDescriptor.colorAttachments[0].alphaBlendOperation = MTLBlendOperationAdd;
+    }
+    
+    // Create pipeline state
+    NSError* error = nil;
+    id<MTLRenderPipelineState> pipelineState = [device newRenderPipelineStateWithDescriptor:pipelineDescriptor error:&error];
+    
+    [pipelineDescriptor release];
+    [vertexFunc release];
+    [fragmentFunc release];
+    
+    if (!pipelineState) {
+        std::cerr << "Failed to create render pipeline state for vertex: " << vertexFunction
+                  << ", fragment: " << fragmentFunction << std::endl;
+        if (error) {
+            std::cerr << "Error: " << [[error localizedDescription] UTF8String] << std::endl;
+        }
+        return nil;
+    }
+    
+    // Cache pipeline state
+    _renderPipelineStates[key] = pipelineState;
+    
+    return pipelineState;
+}
+
+id<MTLDepthStencilState> MetalResources::createDepthStencilState(
+    bool depthTestEnabled,
+    bool depthWriteEnabled,
+    MTLCompareFunction depthCompareFunction)
+{
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return nil;
+    }
+    
+    // Generate key for caching
+    std::string key = generateDepthStencilStateKey(
+        depthTestEnabled, depthWriteEnabled, depthCompareFunction);
+    
+    // Check if depth stencil state already exists
+    auto it = _depthStencilStates.find(key);
+    if (it != _depthStencilStates.end()) {
+        return it->second;
+    }
+    
+    // Create depth stencil descriptor
+    MTLDepthStencilDescriptor* depthStencilDescriptor = [[MTLDepthStencilDescriptor alloc] init];
+    depthStencilDescriptor.depthCompareFunction = depthTestEnabled ? depthCompareFunction : MTLCompareFunctionAlways;
+    depthStencilDescriptor.depthWriteEnabled = depthWriteEnabled;
+    
+    // Create depth stencil state
+    id<MTLDepthStencilState> depthStencilState = [device newDepthStencilStateWithDescriptor:depthStencilDescriptor];
+    
+    [depthStencilDescriptor release];
+    
+    if (!depthStencilState) {
+        std::cerr << "Failed to create depth stencil state" << std::endl;
+        return nil;
+    }
+    
+    // Cache depth stencil state
+    _depthStencilStates[key] = depthStencilState;
+    
+    return depthStencilState;
+}
+
+id<MTLBuffer> MetalResources::createBuffer(
+    const void* data,
+    size_t length,
+    MTLResourceOptions options)
+{
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return nil;
+    }
+    
+    id<MTLBuffer> buffer = nil;
+    
+    if (data) {
+        buffer = [device newBufferWithBytes:data length:length options:options];
+    } else {
+        buffer = [device newBufferWithLength:length options:options];
+    }
+    
+    if (!buffer) {
+        std::cerr << "Failed to create Metal buffer of size: " << length << std::endl;
+    }
+    
+    return buffer;
+}
+
+id<MTLTexture> MetalResources::createTexture(
+    uint32_t width,
+    uint32_t height,
+    MTLPixelFormat pixelFormat,
+    MTLTextureUsage usage,
+    MTLStorageMode storageMode)
+{
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return nil;
+    }
+    
+    MTLTextureDescriptor* textureDescriptor = [[MTLTextureDescriptor alloc] init];
+    textureDescriptor.textureType = MTLTextureType2D;
+    textureDescriptor.pixelFormat = pixelFormat;
+    textureDescriptor.width = width;
+    textureDescriptor.height = height;
+    textureDescriptor.usage = usage;
+    textureDescriptor.storageMode = storageMode;
+    
+    id<MTLTexture> texture = [device newTextureWithDescriptor:textureDescriptor];
+    
+    [textureDescriptor release];
+    
+    if (!texture) {
+        std::cerr << "Failed to create Metal texture of size: " << width << "x" << height << std::endl;
+    }
+    
+    return texture;
+}
+
+id<MTLTexture> MetalResources::createTextureFromImage(
+    const std::string& filename,
+    MTLTextureUsage usage,
+    bool generateMipmaps)
+{
+    // In a real implementation, this would load an image from disk
+    // and create a texture from it. For simplicity, we'll just create
+    // a placeholder implementation that returns nil.
+    std::cerr << "createTextureFromImage not implemented" << std::endl;
+    return nil;
+}
+
+id<MTLSamplerState> MetalResources::createSamplerState(
+    MTLSamplerMinMagFilter minFilter,
+    MTLSamplerMinMagFilter magFilter,
+    MTLSamplerAddressMode addressMode)
+{
+    id<MTLDevice> device = _context->device();
+    if (!device) {
+        return nil;
+    }
+    
+    // Generate key for caching
+    std::string key = generateSamplerStateKey(minFilter, magFilter, addressMode);
+    
+    // Check if sampler state already exists
+    auto it = _samplerStates.find(key);
+    if (it != _samplerStates.end()) {
+        return it->second;
+    }
+    
+    // Create sampler descriptor
+    MTLSamplerDescriptor* samplerDescriptor = [[MTLSamplerDescriptor alloc] init];
+    samplerDescriptor.minFilter = minFilter;
+    samplerDescriptor.magFilter = magFilter;
+    samplerDescriptor.sAddressMode = addressMode;
+    samplerDescriptor.tAddressMode = addressMode;
+    
+    // Create sampler state
+    id<MTLSamplerState> samplerState = [device newSamplerStateWithDescriptor:samplerDescriptor];
+    
+    [samplerDescriptor release];
+    
+    if (!samplerState) {
+        std::cerr << "Failed to create Metal sampler state" << std::endl;
+        return nil;
+    }
+    
+    // Cache sampler state
+    _samplerStates[key] = samplerState;
+    
+    return samplerState;
+}
+
+std::string MetalResources::generatePipelineStateKey(
+    const std::string& vertexFunction,
+    const std::string& fragmentFunction,
+    MTLPixelFormat colorPixelFormat,
+    MTLPixelFormat depthPixelFormat,
+    bool blendingEnabled)
+{
+    std::stringstream ss;
+    ss << vertexFunction << "_" << fragmentFunction << "_"
+       << colorPixelFormat << "_" << depthPixelFormat << "_"
+       << (blendingEnabled ? "blend" : "noblend");
+    return ss.str();
+}
+
+std::string MetalResources::generateDepthStencilStateKey(
+    bool depthTestEnabled,
+    bool depthWriteEnabled,
+    MTLCompareFunction depthCompareFunction)
+{
+    std::stringstream ss;
+    ss << (depthTestEnabled ? "test" : "notest") << "_"
+       << (depthWriteEnabled ? "write" : "nowrite") << "_"
+       << depthCompareFunction;
+    return ss.str();
+}
+
+std::string MetalResources::generateSamplerStateKey(
+    MTLSamplerMinMagFilter minFilter,
+    MTLSamplerMinMagFilter magFilter,
+    MTLSamplerAddressMode addressMode)
+{
+    std::stringstream ss;
+    ss << minFilter << "_" << magFilter << "_" << addressMode;
+    return ss.str();
+}
+
+} // namespace graphics
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_resources.hpp b/src/bundles/graphics_metal/metal/metal_resources.hpp
new file mode 100644
index 0000000000..a6d02a4f83
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_resources.hpp
@@ -0,0 +1,119 @@
+// metal_resources.hpp
+// Manages Metal resources such as buffers, textures, and pipeline states
+
+#pragma once
+
+#import <Metal/Metal.h>
+#import <MetalKit/MetalKit.h>
+#include <string>
+#include <unordered_map>
+#include <memory>
+#include <vector>
+
+namespace chimerax {
+namespace graphics {
+
+// Forward declarations
+class MetalContext;
+
+/**
+ * Structure containing information about a shader library
+ */
+struct ShaderLibraryInfo {
+    id<MTLLibrary> library;
+    std::string name;
+    bool isDefault;
+};
+
+/**
+ * Manages Metal resources for rendering
+ */
+class MetalResources {
+public:
+    MetalResources(MetalContext* context);
+    ~MetalResources();
+    
+    // Initialization
+    bool initialize();
+    
+    // Shader management
+    id<MTLLibrary> defaultLibrary() const { return _defaultLibrary; }
+    id<MTLLibrary> loadLibrary(const std::string& filename);
+    id<MTLLibrary> loadLibraryFromSource(const std::string& source, const std::string& name);
+    id<MTLFunction> loadFunction(const std::string& functionName, id<MTLLibrary> library = nil);
+    
+    // Pipeline state objects
+    id<MTLRenderPipelineState> createRenderPipelineState(
+        const std::string& vertexFunction,
+        const std::string& fragmentFunction,
+        MTLPixelFormat colorPixelFormat = MTLPixelFormatBGRA8Unorm,
+        MTLPixelFormat depthPixelFormat = MTLPixelFormatDepth32Float,
+        bool blendingEnabled = false);
+    
+    id<MTLDepthStencilState> createDepthStencilState(
+        bool depthTestEnabled = true,
+        bool depthWriteEnabled = true,
+        MTLCompareFunction depthCompareFunction = MTLCompareFunctionLess);
+    
+    // Buffer management
+    id<MTLBuffer> createBuffer(
+        const void* data,
+        size_t length,
+        MTLResourceOptions options = MTLResourceStorageModeShared);
+    
+    // Texture management
+    id<MTLTexture> createTexture(
+        uint32_t width,
+        uint32_t height,
+        MTLPixelFormat pixelFormat = MTLPixelFormatRGBA8Unorm,
+        MTLTextureUsage usage = MTLTextureUsageShaderRead,
+        MTLStorageMode storageMode = MTLStorageModeShared);
+        
+    id<MTLTexture> createTextureFromImage(
+        const std::string& filename,
+        MTLTextureUsage usage = MTLTextureUsageShaderRead,
+        bool generateMipmaps = true);
+
+    id<MTLSamplerState> createSamplerState(
+        MTLSamplerMinMagFilter minFilter = MTLSamplerMinMagFilterLinear,
+        MTLSamplerMinMagFilter magFilter = MTLSamplerMinMagFilterLinear,
+        MTLSamplerAddressMode addressMode = MTLSamplerAddressModeClampToEdge);
+        
+    // Resource cleanup - call when context is lost
+    void releaseResources();
+
+private:
+    MetalContext* _context;
+    
+    // Default shader library
+    id<MTLLibrary> _defaultLibrary;
+    
+    // Cache of loaded libraries
+    std::vector<ShaderLibraryInfo> _libraries;
+    
+    // Cache of pipeline states
+    std::unordered_map<std::string, id<MTLRenderPipelineState>> _renderPipelineStates;
+    std::unordered_map<std::string, id<MTLDepthStencilState>> _depthStencilStates;
+    std::unordered_map<std::string, id<MTLSamplerState>> _samplerStates;
+    
+    // Internal methods
+    std::string generatePipelineStateKey(
+        const std::string& vertexFunction,
+        const std::string& fragmentFunction,
+        MTLPixelFormat colorPixelFormat,
+        MTLPixelFormat depthPixelFormat,
+        bool blendingEnabled);
+        
+    std::string generateDepthStencilStateKey(
+        bool depthTestEnabled,
+        bool depthWriteEnabled,
+        MTLCompareFunction depthCompareFunction);
+        
+    std::string generateSamplerStateKey(
+        MTLSamplerMinMagFilter minFilter,
+        MTLSamplerMinMagFilter magFilter,
+        MTLSamplerAddressMode addressMode);
+};
+
+} // namespace graphics
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_scene.cpp b/src/bundles/graphics_metal/metal/metal_scene.cpp
new file mode 100644
index 0000000000..6bfff1a42f
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_scene.cpp
@@ -0,0 +1,140 @@
+// metal_scene.cpp
+// Implementation of scene management for Metal rendering
+
+#include "metal_scene.hpp"
+#include "metal_context.hpp"
+#include <iostream>
+#include <algorithm>
+
+namespace chimerax {
+namespace graphics {
+
+// MetalLight implementation
+MetalLight::MetalLight()
+    : _type(LightType::Point)
+    , _position(simd::float3(0.0f, 5.0f, 5.0f))
+    , _direction(simd::float3(0.0f, -1.0f, -1.0f))
+    , _color(simd::float3(1.0f, 1.0f, 1.0f))
+    , _intensity(1.0f)
+    , _radius(50.0f)
+{
+}
+
+MetalLight::~MetalLight()
+{
+}
+
+// MetalCamera implementation
+MetalCamera::MetalCamera()
+    : _position(simd::float3(0.0f, 0.0f, 5.0f))
+    , _target(simd::float3(0.0f, 0.0f, 0.0f))
+    , _up(simd::float3(0.0f, 1.0f, 0.0f))
+    , _fov(45.0f)
+    , _aspectRatio(1.0f)
+    , _nearPlane(0.1f)
+    , _farPlane(1000.0f)
+{
+}
+
+MetalCamera::~MetalCamera()
+{
+}
+
+simd::float4x4 MetalCamera::viewMatrix() const
+{
+    // Calculate view matrix (look-at)
+    simd::float3 forward = simd::normalize(_target - _position);
+    simd::float3 right = simd::normalize(simd::cross(forward, _up));
+    simd::float3 upActual = simd::cross(right, forward);
+    
+    simd::float4x4 viewMatrix;
+    
+    // First three columns are the right, up, and forward basis vectors
+    viewMatrix.columns[0] = simd::float4(right.x, upActual.x, -forward.x, 0.0f);
+    viewMatrix.columns[1] = simd::float4(right.y, upActual.y, -forward.y, 0.0f);
+    viewMatrix.columns[2] = simd::float4(right.z, upActual.z, -forward.z, 0.0f);
+    
+    // Fourth column is translation
+    viewMatrix.columns[3] = simd::float4(
+        -simd::dot(right, _position),
+        -simd::dot(upActual, _position),
+        simd::dot(forward, _position),
+        1.0f
+    );
+    
+    return viewMatrix;
+}
+
+simd::float4x4 MetalCamera::projectionMatrix() const
+{
+    // Calculate projection matrix (perspective)
+    float tanHalfFov = tan(_fov * 0.5f * M_PI / 180.0f);
+    float zRange = _farPlane - _nearPlane;
+    
+    simd::float4x4 projMatrix;
+    
+    projMatrix.columns[0] = simd::float4(1.0f / (tanHalfFov * _aspectRatio), 0.0f, 0.0f, 0.0f);
+    projMatrix.columns[1] = simd::float4(0.0f, 1.0f / tanHalfFov, 0.0f, 0.0f);
+    projMatrix.columns[2] = simd::float4(0.0f, 0.0f, -(_farPlane + _nearPlane) / zRange, -1.0f);
+    projMatrix.columns[3] = simd::float4(0.0f, 0.0f, -2.0f * _farPlane * _nearPlane / zRange, 0.0f);
+    
+    return projMatrix;
+}
+
+// MetalScene implementation
+MetalScene::MetalScene(MetalContext* context)
+    : _context(context)
+    , _camera(nullptr)
+    , _backgroundColor(simd::float4(0.2f, 0.2f, 0.2f, 1.0f))
+    , _ambientColor(simd::float3(0.1f, 0.1f, 0.1f))
+    , _ambientIntensity(1.0f)
+{
+}
+
+MetalScene::~MetalScene()
+{
+}
+
+bool MetalScene::initialize()
+{
+    // Create default camera
+    _camera = std::make_unique<MetalCamera>();
+    
+    // Create default light
+    auto defaultLight = std::make_shared<MetalLight>();
+    addLight(defaultLight);
+    
+    return true;
+}
+
+void MetalScene::addLight(std::shared_ptr<MetalLight> light)
+{
+    if (light) {
+        _lights.push_back(light);
+    }
+}
+
+void MetalScene::removeLight(std::shared_ptr<MetalLight> light)
+{
+    auto it = std::find(_lights.begin(), _lights.end(), light);
+    if (it != _lights.end()) {
+        _lights.erase(it);
+    }
+}
+
+void MetalScene::clearLights()
+{
+    _lights.clear();
+}
+
+std::shared_ptr<MetalLight> MetalScene::mainLight() const
+{
+    if (_lights.empty()) {
+        return nullptr;
+    }
+    
+    return _lights[0];
+}
+
+} // namespace graphics
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/metal_scene.hpp b/src/bundles/graphics_metal/metal/metal_scene.hpp
new file mode 100644
index 0000000000..96ec5b650c
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/metal_scene.hpp
@@ -0,0 +1,146 @@
+// metal_scene.hpp
+// Scene management for Metal rendering in ChimeraX
+
+#pragma once
+
+#import <Metal/Metal.h>
+#include <simd/simd.h>
+#include <memory>
+#include <vector>
+#include <string>
+
+namespace chimerax {
+namespace graphics {
+
+// Forward declarations
+class MetalContext;
+class MetalCamera;
+
+/**
+ * Light types supported by the Metal renderer
+ */
+enum class LightType {
+    Directional,
+    Point,
+    Spot
+};
+
+/**
+ * Light source in the scene
+ */
+class MetalLight {
+public:
+    MetalLight();
+    ~MetalLight();
+    
+    LightType type() const { return _type; }
+    void setType(LightType type) { _type = type; }
+    
+    simd::float3 position() const { return _position; }
+    void setPosition(simd::float3 position) { _position = position; }
+    
+    simd::float3 direction() const { return _direction; }
+    void setDirection(simd::float3 direction) { _direction = direction; }
+    
+    simd::float3 color() const { return _color; }
+    void setColor(simd::float3 color) { _color = color; }
+    
+    float intensity() const { return _intensity; }
+    void setIntensity(float intensity) { _intensity = intensity; }
+    
+    float radius() const { return _radius; }
+    void setRadius(float radius) { _radius = radius; }
+    
+private:
+    LightType _type;
+    simd::float3 _position;
+    simd::float3 _direction;
+    simd::float3 _color;
+    float _intensity;
+    float _radius;
+};
+
+/**
+ * Camera for the Metal renderer
+ */
+class MetalCamera {
+public:
+    MetalCamera();
+    ~MetalCamera();
+    
+    simd::float3 position() const { return _position; }
+    void setPosition(simd::float3 position) { _position = position; }
+    
+    simd::float3 target() const { return _target; }
+    void setTarget(simd::float3 target) { _target = target; }
+    
+    simd::float3 up() const { return _up; }
+    void setUp(simd::float3 up) { _up = up; }
+    
+    float fov() const { return _fov; }
+    void setFov(float fov) { _fov = fov; }
+    
+    float aspectRatio() const { return _aspectRatio; }
+    void setAspectRatio(float aspectRatio) { _aspectRatio = aspectRatio; }
+    
+    float nearPlane() const { return _nearPlane; }
+    void setNearPlane(float nearPlane) { _nearPlane = nearPlane; }
+    
+    float farPlane() const { return _farPlane; }
+    void setFarPlane(float farPlane) { _farPlane = farPlane; }
+    
+    simd::float4x4 viewMatrix() const;
+    simd::float4x4 projectionMatrix() const;
+    
+private:
+    simd::float3 _position;
+    simd::float3 _target;
+    simd::float3 _up;
+    float _fov;
+    float _aspectRatio;
+    float _nearPlane;
+    float _farPlane;
+};
+
+/**
+ * Scene management for Metal rendering
+ */
+class MetalScene {
+public:
+    MetalScene(MetalContext* context);
+    ~MetalScene();
+    
+    // Initialization
+    bool initialize();
+    
+    // Camera access
+    MetalCamera* camera() const { return _camera.get(); }
+    
+    // Light management
+    void addLight(std::shared_ptr<MetalLight> light);
+    void removeLight(std::shared_ptr<MetalLight> light);
+    void clearLights();
+    std::shared_ptr<MetalLight> mainLight() const;
+    
+    // Background
+    simd::float4 backgroundColor() const { return _backgroundColor; }
+    void setBackgroundColor(simd::float4 color) { _backgroundColor = color; }
+    
+    // Ambient lighting
+    simd::float3 ambientColor() const { return _ambientColor; }
+    void setAmbientColor(simd::float3 color) { _ambientColor = color; }
+    
+    float ambientIntensity() const { return _ambientIntensity; }
+    void setAmbientIntensity(float intensity) { _ambientIntensity = intensity; }
+    
+private:
+    MetalContext* _context;
+    std::unique_ptr<MetalCamera> _camera;
+    std::vector<std::shared_ptr<MetalLight>> _lights;
+    simd::float4 _backgroundColor;
+    simd::float3 _ambientColor;
+    float _ambientIntensity;
+};
+
+} // namespace graphics
+} // namespace chimerax
diff --git a/src/bundles/graphics_metal/metal/shaders/metal_shaders.metal b/src/bundles/graphics_metal/metal/shaders/metal_shaders.metal
new file mode 100644
index 0000000000..cec41fa954
--- /dev/null
+++ b/src/bundles/graphics_metal/metal/shaders/metal_shaders.metal
@@ -0,0 +1,210 @@
+// metal_shaders.metal
+// Metal shaders for rendering molecular structures in ChimeraX
+
+#include <metal_stdlib>
+using namespace metal;
+
+// Structures that match C++ counterparts
+struct Uniforms {
+    // Matrices
+    float4x4 modelMatrix;
+    float4x4 viewMatrix;
+    float4x4 projectionMatrix;
+    float4x4 normalMatrix;
+    
+    // Camera
+    float3 cameraPosition;
+    float padding1;
+    
+    // Lighting
+    float3 lightPosition;
+    float lightRadius;
+    float3 lightColor;
+    float lightIntensity;
+    float3 ambientColor;
+    float ambientIntensity;
+};
+
+struct MaterialProperties {
+    // Basic properties
+    float4 color;
+    float roughness;
+    float metallic;
+    float ambientOcclusion;
+    float padding;
+    
+    // Additional properties for molecular rendering
+    float atomRadius;
+    float bondRadius;
+    float outlineWidth;
+    float outlineStrength;
+};
+
+// Vertex shader outputs
+struct VertexOut {
+    float4 position [[position]];
+    float3 worldPosition;
+    float3 normal;
+    float4 color;
+    float2 texCoord;
+};
+
+// Utility functions
+float3 calculateNormal(float3 position, float3 center, float radius) {
+    return normalize(position - center);
+}
+
+float3 calculatePhongLighting(float3 worldPos, float3 normal, float3 viewDir, float3 diffuseColor, constant Uniforms& uniforms) {
+    // Calculate light direction and attenuation
+    float3 lightDir = normalize(uniforms.lightPosition - worldPos);
+    float distance = length(uniforms.lightPosition - worldPos);
+    float attenuation = 1.0 / (1.0 + distance * distance / (uniforms.lightRadius * uniforms.lightRadius));
+    
+    // Ambient component
+    float3 ambient = uniforms.ambientColor * uniforms.ambientIntensity * diffuseColor;
+    
+    // Diffuse component
+    float NdotL = max(dot(normal, lightDir), 0.0);
+    float3 diffuse = uniforms.lightColor * NdotL * diffuseColor * uniforms.lightIntensity;
+    
+    // Specular component
+    float3 reflectDir = reflect(-lightDir, normal);
+    float spec = pow(max(dot(viewDir, reflectDir), 0.0), 32.0);
+    float3 specular = uniforms.lightColor * spec * 0.5 * uniforms.lightIntensity;
+    
+    // Combine lighting components with attenuation
+    return ambient + (diffuse + specular) * attenuation;
+}
+
+// Sphere rendering
+vertex VertexOut vertexSphere(uint vertexID [[vertex_id]],
+                              constant float3* positions [[buffer(0)]],
+                              constant float4* colors [[buffer(1)]],
+                              constant float* radii [[buffer(2)]],
+                              constant Uniforms& uniforms [[buffer(3)]]) {
+    // Get sphere data
+    float3 center = positions[vertexID];
+    float4 color = colors[vertexID];
+    float radius = radii[vertexID];
+    
+    // Transform center position
+    float4 worldPos = uniforms.modelMatrix * float4(center, 1.0);
+    
+    // For point sprites, we just pass the center
+    VertexOut out;
+    out.position = uniforms.projectionMatrix * uniforms.viewMatrix * worldPos;
+    out.worldPosition = worldPos.xyz;
+    out.normal = float3(0, 0, 1); // Will be calculated in fragment shader
+    out.color = color;
+    out.texCoord = float2(0, 0);
+    
+    // Adjust point size based on radius and perspective
+    // Note: Metal doesn't support gl_PointSize directly, so this will need
+    // to be implemented differently in a real application
+    
+    return out;
+}
+
+fragment float4 fragmentSphere(VertexOut in [[stage_in]],
+                              constant Uniforms& uniforms [[buffer(0)]]) {
+    // Calculate normal based on sphere equation
+    float3 normal = normalize(in.normal);
+    
+    // Calculate view direction
+    float3 viewDir = normalize(uniforms.cameraPosition - in.worldPosition);
+    
+    // Calculate lighting
+    float3 litColor = calculatePhongLighting(in.worldPosition, normal, viewDir, in.color.rgb, uniforms);
+    
+    return float4(litColor, in.color.a);
+}
+
+// Cylinder rendering
+vertex VertexOut vertexCylinder(uint vertexID [[vertex_id]],
+                               constant float3* startPositions [[buffer(0)]],
+                               constant float3* endPositions [[buffer(1)]],
+                               constant float4* colors [[buffer(2)]],
+                               constant float* radii [[buffer(3)]],
+                               constant Uniforms& uniforms [[buffer(4)]]) {
+    // Calculate which end of the cylinder this vertex represents
+    uint index = vertexID / 2;
+    bool isStart = (vertexID % 2) == 0;
+    
+    // Get cylinder data
+    float3 startPos = startPositions[index];
+    float3 endPos = endPositions[index];
+    float4 color = colors[index];
+    float radius = radii[index];
+    
+    // Position is either start or end
+    float3 position = isStart ? startPos : endPos;
+    
+    // Calculate cylinder direction
+    float3 direction = normalize(endPos - startPos);
+    
+    // Transform position
+    float4 worldPos = uniforms.modelMatrix * float4(position, 1.0);
+    
+    // For line primitives, we just pass the end points
+    // The actual cylinder geometry would be generated in a geometry shader
+    // or by using instanced rendering with a cylinder mesh
+    VertexOut out;
+    out.position = uniforms.projectionMatrix * uniforms.viewMatrix * worldPos;
+    out.worldPosition = worldPos.xyz;
+    out.normal = float3(0, 0, 1); // Placeholder
+    out.color = color;
+    out.texCoord = float2(0, 0);
+    
+    return out;
+}
+
+fragment float4 fragmentCylinder(VertexOut in [[stage_in]],
+                                constant Uniforms& uniforms [[buffer(0)]]) {
+    // This is a simplified version - a real implementation would
+    // calculate normals and lighting for a cylinder
+    
+    // Calculate view direction
+    float3 viewDir = normalize(uniforms.cameraPosition - in.worldPosition);
+    
+    // Calculate lighting
+    float3 litColor = calculatePhongLighting(in.worldPosition, in.normal, viewDir, in.color.rgb, uniforms);
+    
+    return float4(litColor, in.color.a);
+}
+
+// Triangle mesh rendering
+vertex VertexOut vertexTriangle(uint vertexID [[vertex_id]],
+                               constant float3* positions [[buffer(0)]],
+                               constant float4* colors [[buffer(1)]],
+                               constant float3* normals [[buffer(2)]],
+                               constant Uniforms& uniforms [[buffer(3)]]) {
+    float3 position = positions[vertexID];
+    float4 color = colors[vertexID];
+    float3 normal = normals[vertexID];
+    
+    // Transform position to world space
+    float4 worldPos = uniforms.modelMatrix * float4(position, 1.0);
+    
+    // Transform normal to world space
+    float3 worldNormal = (uniforms.normalMatrix * float4(normal, 0.0)).xyz;
+    
+    VertexOut out;
+    out.position = uniforms.projectionMatrix * uniforms.viewMatrix * worldPos;
+    out.worldPosition = worldPos.xyz;
+    out.normal = normalize(worldNormal);
+    out.color = color;
+    out.texCoord = float2(0, 0);
+    
+    return out;
+}
+
+fragment float4 fragmentTriangle(VertexOut in [[stage_in]],
+                                constant Uniforms& uniforms [[buffer(0)]]) {
+    // Calculate view direction
+    float3 viewDir = normalize(uniforms.cameraPosition - in.worldPosition);
+    
+    // Calculate lighting
+    float3 litColor = calculatePhongLighting(in.worldPosition, in.normal, viewDir, in.color.rgb, uniforms);
+    
+    return float4(litColor, in.color.a);
+}
diff --git a/src/bundles/graphics_metal/pyproject.toml b/src/bundles/graphics_metal/pyproject.toml
new file mode 100644
index 0000000000..1225826852
--- /dev/null
+++ b/src/bundles/graphics_metal/pyproject.toml
@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=42", "wheel", "cython>=0.29.24", "numpy"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ChimeraX-GraphicsMetal"
+version = "0.1.0"
+description = "Metal-accelerated multi-GPU graphics for ChimeraX"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "Free for non-commercial use"}
+authors = [
+    {name = "Alpha Tau Biosciences", email = "support@alphataubio.com"}
+]
+classifiers = [
+    "Framework :: ChimeraX",
+    "Development Status :: 4 - Beta",
+    "License :: Free for non-commercial use",
+    "Operating System :: MacOS :: MacOS X",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: C++"
+]
+dependencies = [
+    "numpy"
+]
+
+[project.urls]
+"Homepage" = "https://www.alphataubio.com/"
+"Source" = "https://github.com/alphataubio/ChimeraX-GraphicsMetal"
+
+[tool.chimerax]
+min-session-version = 1
+max-session-version = 1
+categories = ["Graphics"]
+providers.graphics = [
+    {name = "metal", synopsis = "Metal-based multi-GPU accelerated rendering", 
+     service = "chimerax.graphics_metal:MetalGraphics"}
+]
+custom-init = "chimerax.graphics_metal.custom_init"
+data-files = ["metal_shaders"]
diff --git a/src/bundles/graphics_metal/readme.md b/src/bundles/graphics_metal/readme.md
new file mode 100644
index 0000000000..fcbd209e6e
--- /dev/null
+++ b/src/bundles/graphics_metal/readme.md
@@ -0,0 +1,142 @@
+# ChimeraX-GraphicsMetal
+
+Metal-accelerated multi-GPU graphics for UCSF ChimeraX.
+
+## Overview
+
+This bundle provides a high-performance Metal-based graphics renderer for ChimeraX, optimized for macOS systems with Apple Silicon or Intel processors. It leverages Apple's Metal graphics API to deliver improved performance and reduced CPU overhead compared to the default OpenGL renderer.
+
+Key features:
+- **Multi-GPU Acceleration**: Automatically distributes rendering workloads across multiple GPUs when available
+- **Optimized Memory Usage**: Uses Metal's advanced memory management techniques for better performance
+- **Argument Buffers**: Takes advantage of Metal's argument buffers for efficient resource binding
+- **Ray Tracing Support**: Optional ray-traced shadows and ambient occlusion on supported hardware
+- **Mesh Shaders**: Utilizes Metal mesh shaders for more efficient geometry processing
+
+## Requirements
+
+- macOS 10.14 (Mojave) or later
+- ChimeraX 1.5 or later
+- A Metal-compatible GPU
+
+## Installation
+
+From within ChimeraX:
+
+1. Open ChimeraX
+2. Run the following command:
+   ```
+   toolshed install ChimeraX-GraphicsMetal
+   ```
+
+Alternatively, you can download the wheel file from the releases page and install it using:
+```
+chimerax --nogui --exit --cmd "toolshed install /path/to/ChimeraX-GraphicsMetal-0.1-py3-none-any.whl"
+```
+
+## Usage
+
+### Enabling Metal Rendering
+
+Metal rendering can be enabled with:
+```
+graphics metal
+```
+
+To switch back to OpenGL:
+```
+graphics opengl
+```
+
+### Multi-GPU Acceleration
+
+If your system has multiple GPUs, you can enable multi-GPU acceleration:
+```
+graphics multigpu true
+```
+
+You can also choose a specific strategy for multi-GPU rendering:
+```
+set metal multiGPUStrategy split-frame
+```
+
+Available strategies:
+- `split-frame` - Each GPU renders a different portion of the screen
+- `task-based` - Different rendering tasks are distributed across GPUs
+- `alternating` - Frames are alternated between GPUs
+- `compute-offload` - Main GPU handles rendering, other GPUs handle compute tasks
+
+### Preferences
+
+The Metal graphics settings can be configured through the preferences menu:
+
+1. Open ChimeraX
+2. Go to `Tools` → `General` → `Metal Graphics`
+
+Or you can use the command interface:
+```
+set metal useMetal true
+set metal autoDetect true
+set metal multiGPU true
+set metal rayTracing false
+```
+
+## Building from Source
+
+### Prerequisites
+
+- macOS 10.14+
+- Xcode 12.0+
+- Python 3.9+
+- Cython 0.29.24+
+- NumPy
+
+### Build Steps
+
+1. Clone the repository:
+   ```
+   git clone https://github.com/alphataubio/ChimeraX-GraphicsMetal.git
+   cd ChimeraX-GraphicsMetal
+   ```
+
+2. Build the bundle:
+   ```
+   make build
+   ```
+
+3. Install in development mode:
+   ```
+   make develop
+   ```
+
+## Architecture
+
+The bundle implements a Metal-based renderer that integrates with ChimeraX's graphics system:
+
+- `metal_graphics.py` - Python interface to the Metal renderer
+- `metal_context.cpp` - Core Metal device and context management
+- `metal_renderer.cpp` - Main rendering pipeline implementation
+- `metal_scene.cpp` - Scene management for the Metal renderer
+- `metal_argbuffer_manager.cpp` - Argument buffer management for efficient resource binding
+- `metal_heap_manager.cpp` - Memory management with Metal heaps
+- `metal_event_manager.cpp` - Synchronization for multi-GPU rendering
+- `metal_multi_gpu.cpp` - Multi-GPU coordination and management
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed for non-commercial use only. See the LICENSE file for details.
+
+## Acknowledgments
+
+- UCSF ChimeraX team for their excellent molecular visualization platform
+- Apple for the Metal graphics API and development tools
diff --git a/src/bundles/graphics_metal/src/__init__.py b/src/bundles/graphics_metal/src/__init__.py
new file mode 100644
index 0000000000..75ba39a231
--- /dev/null
+++ b/src/bundles/graphics_metal/src/__init__.py
@@ -0,0 +1,6 @@
+"""
+Metal-accelerated multi-GPU graphics for ChimeraX
+"""
+
+# Import from this package to make them available to other modules
+from .metal_graphics import MetalGraphics, is_metal_supported
diff --git a/src/bundles/graphics_metal/src/custom_init.py b/src/bundles/graphics_metal/src/custom_init.py
new file mode 100644
index 0000000000..c6259c345b
--- /dev/null
+++ b/src/bundles/graphics_metal/src/custom_init.py
@@ -0,0 +1,131 @@
+"""
+Custom initialization for ChimeraX-GraphicsMetal bundle.
+This is called when the bundle is loaded through the 'custom-init' entry in pyproject.toml.
+"""
+
+def init(session, bundle_info):
+    """Initialize the Metal graphics bundle"""
+    from . import metal_graphics
+    
+    # Register preferences
+    from . import preferences
+    preferences.register_settings(session)
+    preferences.register_metal_preferences(session)
+    
+    # Check if Metal is supported
+    if metal_graphics.is_metal_supported():
+        session.logger.info("Metal graphics acceleration is available")
+        
+        # Register commands for Metal
+        from chimerax.core.commands import register
+        register('graphics metal', switch_to_metal,
+                 help="Switch to Metal graphics renderer")
+        register('graphics opengl', switch_to_opengl,
+                 help="Switch back to OpenGL graphics renderer")
+        register('graphics multigpu', toggle_multi_gpu,
+                 help="Toggle multi-GPU acceleration for Metal renderer")
+        
+        # Auto-enable Metal if set in preferences
+        prefs = preferences.register_settings(session)
+        if prefs.auto_detect and prefs.use_metal:
+            try:
+                switch_to_metal(session)
+                session.logger.info("Auto-enabled Metal graphics renderer")
+            except Exception as e:
+                session.logger.warning(f"Failed to auto-enable Metal: {str(e)}")
+    else:
+        session.logger.info("Metal graphics acceleration is not available on this system")
+
+def finish(session, bundle_info):
+    """Clean up when bundle is unloaded"""
+    from chimerax.graphics import provider_info
+    
+    # Check if we're using Metal
+    from .metal_graphics import MetalGraphics
+    if isinstance(session.main_view.graphics, MetalGraphics):
+        # Switch back to OpenGL before unloading
+        default_provider = provider_info('opengl')
+        if default_provider:
+            session.main_view.switch_graphics_provider('opengl')
+            session.logger.info("Switched back to OpenGL graphics renderer")
+
+def switch_to_metal(session):
+    """Command to switch to Metal renderer"""
+    from . import metal_graphics
+    if not metal_graphics.is_metal_supported():
+        from chimerax.core.errors import UserError
+        raise UserError("Metal graphics is not supported on this system")
+        
+    if session.main_view.graphics_changed:
+        # Graphics provider already changed, check if it's Metal
+        from .metal_graphics import MetalGraphics
+        if isinstance(session.main_view.graphics, MetalGraphics):
+            session.logger.info("Already using Metal graphics")
+            return
+            
+    # Switch to Metal
+    from chimerax.graphics import provider_info
+    metal_provider = provider_info('metal')
+    if metal_provider:
+        session.main_view.switch_graphics_provider('metal')
+        session.logger.info("Switched to Metal graphics renderer")
+        
+        # Apply multi-GPU setting from preferences
+        from . import preferences
+        prefs = preferences.register_settings(session)
+        if prefs.multi_gpu_enabled:
+            graphics = session.main_view.graphics
+            strategy_map = {
+                "split-frame": 0,
+                "task-based": 1,
+                "alternating": 2,
+                "compute-offload": 3
+            }
+            strategy = strategy_map.get(prefs.multi_gpu_strategy, 0)
+            if hasattr(graphics, 'enable_multi_gpu'):
+                graphics.enable_multi_gpu(True, strategy)
+                session.logger.info(f"Enabled multi-GPU acceleration with strategy: {prefs.multi_gpu_strategy}")
+    else:
+        from chimerax.core.errors import UserError
+        raise UserError("Metal graphics provider not found")
+        
+def switch_to_opengl(session):
+    """Command to switch back to OpenGL renderer"""
+    # Switch to default OpenGL
+    from .metal_graphics import MetalGraphics
+    if isinstance(session.main_view.graphics, MetalGraphics):
+        session.main_view.switch_graphics_provider('opengl')
+        session.logger.info("Switched to OpenGL graphics renderer")
+    else:
+        session.logger.info("Already using OpenGL graphics")
+        
+def toggle_multi_gpu(session, enable=None):
+    """Command to toggle multi-GPU acceleration"""
+    from .metal_graphics import MetalGraphics
+    if not isinstance(session.main_view.graphics, MetalGraphics):
+        from chimerax.core.errors import UserError
+        raise UserError("Multi-GPU acceleration is only available with Metal graphics")
+        
+    graphics = session.main_view.graphics
+    if enable is None:
+        # Toggle current state
+        enable = not graphics.is_multi_gpu_enabled()
+        
+    success = graphics.enable_multi_gpu(enable)
+    if success:
+        session.logger.info(f"Multi-GPU acceleration {'enabled' if enable else 'disabled'}")
+        
+        # Update preference
+        from . import preferences
+        prefs = preferences.register_settings(session)
+        prefs.multi_gpu_enabled = enable
+    else:
+        if enable:
+            session.logger.warning("Failed to enable multi-GPU acceleration")
+        else:
+            session.logger.info("Multi-GPU acceleration disabled")
+            
+            # Update preference
+            from . import preferences
+            prefs = preferences.register_settings(session)
+            prefs.multi_gpu_enabled = False
diff --git a/src/bundles/graphics_metal/src/metal_graphics.py b/src/bundles/graphics_metal/src/metal_graphics.py
new file mode 100644
index 0000000000..6f048d3172
--- /dev/null
+++ b/src/bundles/graphics_metal/src/metal_graphics.py
@@ -0,0 +1,262 @@
+"""
+Metal-based graphics implementation for ChimeraX with multi-GPU acceleration
+"""
+
+import sys
+import os
+import platform
+import numpy
+from chimerax.core.graphics import Graphics
+from chimerax.core.logger import log_error, log_info
+
+# Import C++ extension module for Metal - would be built with Cython
+# We use a try/except here to gracefully handle platforms where Metal is not available
+try:
+    from ._metal import (
+        MetalContext, 
+        MetalRenderer, 
+        MetalScene, 
+        MetalResources,
+        MetalView,
+        MetalArgBuffer,
+        MetalMultiGPU,
+        # Exception type for Metal errors
+        MetalError
+    )
+    _have_metal = True
+except ImportError as e:
+    _have_metal = False
+    log_error(f"Failed to import Metal module: {e}")
+
+# Check if we're on a platform that supports Metal
+def is_metal_supported():
+    """Check if the current platform supports Metal"""
+    if not _have_metal:
+        return False
+    
+    # Metal is only supported on macOS
+    if platform.system() != "Darwin":
+        return False
+    
+    # Check macOS version - Metal requires 10.14+ for all features we use
+    mac_ver = platform.mac_ver()[0]
+    if mac_ver:
+        major, minor = map(int, mac_ver.split('.')[:2])
+        if (major < 10) or (major == 10 and minor < 14):
+            return False
+    
+    return True
+
+# Constants for multi-GPU strategies
+MULTI_GPU_STRATEGY_SPLIT_FRAME = 0
+MULTI_GPU_STRATEGY_TASK_BASED = 1
+MULTI_GPU_STRATEGY_ALTERNATING = 2
+MULTI_GPU_STRATEGY_COMPUTE_OFFLOAD = 3
+
+class MetalGraphics(Graphics):
+    """Metal-based graphics implementation for ChimeraX with multi-GPU support"""
+    
+    def __init__(self, session, **kw):
+        """Initialize Metal graphics"""
+        super().__init__(session, **kw)
+        
+        self._metal_view = None
+        self._multi_gpu = None
+        self._multi_gpu_enabled = False
+        self._multi_gpu_strategy = MULTI_GPU_STRATEGY_SPLIT_FRAME
+        
+        # Create Metal view if supported
+        if is_metal_supported():
+            try:
+                # Create the low-level Metal view
+                self._metal_view = MetalView()
+                
+                # Initialize multi-GPU manager if available
+                self._multi_gpu = MetalMultiGPU()
+                
+                log_info("Using Metal graphics renderer with multi-GPU support")
+            except Exception as e:
+                log_error(f"Failed to create Metal renderer: {e}")
+                self._metal_view = None
+                self._multi_gpu = None
+    
+    def initialize(self, width, height, window_id, make_current=False):
+        """Initialize the Metal rendering context"""
+        if self._metal_view:
+            try:
+                success = self._metal_view.initialize(window_id, width, height)
+                if not success:
+                    log_error("Failed to initialize Metal view")
+                    self._metal_view = None
+                    self._multi_gpu = None
+                    return super().initialize(width, height, window_id, make_current)
+                
+                # Initialize multi-GPU if available
+                if self._multi_gpu:
+                    # Get Metal context from view
+                    metal_context = self._metal_view.context()
+                    if metal_context:
+                        self._multi_gpu.initialize(metal_context)
+                
+                # Successfully initialized Metal
+                return True
+            except Exception as e:
+                log_error(f"Error initializing Metal view: {e}")
+                self._metal_view = None
+                self._multi_gpu = None
+        
+        # Fall back to OpenGL if Metal is not available
+        return super().initialize(width, height, window_id, make_current)
+    
+    def make_current(self):
+        """Make the Metal context current if using Metal, otherwise use OpenGL"""
+        if self._metal_view:
+            # Metal doesn't use the concept of "current context" like OpenGL
+            # so this is a no-op for Metal
+            return True
+        return super().make_current()
+    
+    def done_current(self):
+        """Release the current context if using OpenGL"""
+        if not self._metal_view:
+            return super().done_current()
+    
+    def swap_buffers(self):
+        """Swap buffers or present the Metal drawable"""
+        if self._metal_view:
+            self._metal_view.render()
+        else:
+            super().swap_buffers()
+    
+    def render(self, drawing, camera, render_target=None):
+        """Render the drawing using metal or fall back to OpenGL"""
+        if self._metal_view:
+            # Update scene with camera and drawing
+            metal_scene = self._metal_view.scene()
+            if metal_scene:
+                # Update camera parameters
+                metal_camera = metal_scene.camera()
+                if metal_camera and camera:
+                    # Convert camera position and orientation
+                    eye_pos = camera.position.origin
+                    metal_camera.setPosition((eye_pos[0], eye_pos[1], eye_pos[2]))
+                    
+                    # Set camera target (look-at point)
+                    look_at = eye_pos + camera.view_direction() * 10.0
+                    metal_camera.setTarget((look_at[0], look_at[1], look_at[2]))
+                    
+                    # Set camera up vector
+                    up_vector = camera.position.z_axis
+                    metal_camera.setUp((up_vector[0], up_vector[1], up_vector[2]))
+                    
+                    # Set perspective parameters
+                    metal_camera.setFov(camera.field_of_view)
+                    metal_camera.setNearPlane(camera.near_clip_distance)
+                    metal_camera.setFarPlane(camera.far_clip_distance)
+                
+                # TODO: Convert drawing to Metal representation
+                # This is a complex step that would require translating the
+                # ChimeraX drawing structures into Metal-compatible buffers
+            
+            # Trigger rendering
+            self._metal_view.render()
+        else:
+            super().render(drawing, camera, render_target)
+    
+    def enable_multi_gpu(self, enable=True, strategy=MULTI_GPU_STRATEGY_SPLIT_FRAME):
+        """Enable or disable multi-GPU rendering with Metal"""
+        if not self._metal_view or not self._multi_gpu:
+            log_error("Cannot enable multi-GPU: Metal is not active or multi-GPU not supported")
+            return False
+        
+        # Set the multi-GPU strategy
+        if enable:
+            self._multi_gpu_strategy = strategy
+            success = self._multi_gpu.enable(True, strategy)
+        else:
+            success = self._multi_gpu.enable(False, MULTI_GPU_STRATEGY_SPLIT_FRAME)
+            
+        self._multi_gpu_enabled = enable and success
+        
+        # Update renderer settings if multi-GPU enabled
+        if self._multi_gpu_enabled:
+            # Get Metal renderer from view and configure it for multi-GPU
+            renderer = self._metal_view.renderer()
+            if renderer:
+                renderer.setMultiGPUMode(True, strategy)
+        
+        return success
+    
+    def is_multi_gpu_enabled(self):
+        """Check if multi-GPU rendering is enabled"""
+        return self._metal_view is not None and self._multi_gpu is not None and self._multi_gpu_enabled
+    
+    def get_gpu_devices(self):
+        """Get information about available Metal GPU devices"""
+        if not self._metal_view:
+            return []
+            
+        if self._multi_gpu:
+            return self._multi_gpu.getDeviceInfo()
+        
+        # Fallback if multi-GPU manager is not available
+        metal_context = self._metal_view.context()
+        if metal_context:
+            # Just return primary device info
+            device_name = metal_context.deviceName()
+            return [{"name": device_name, "is_primary": True, "unified_memory": metal_context.supportsUnifiedMemory()}]
+            
+        return []
+    
+    def begin_frame_capture(self):
+        """Begin Metal frame capture for debugging"""
+        if self._metal_view:
+            self._metal_view.beginCapture()
+    
+    def end_frame_capture(self):
+        """End Metal frame capture"""
+        if self._metal_view:
+            self._metal_view.endCapture()
+    
+    def resize(self, width, height):
+        """Resize the rendering view"""
+        if self._metal_view:
+            self._metal_view.resize(width, height)
+        else:
+            super().resize(width, height)
+    
+    def set_background_color(self, color):
+        """Set the background color for rendering"""
+        if self._metal_view:
+            scene = self._metal_view.scene()
+            if scene:
+                # Convert RGBA color (0-1 range)
+                metal_color = (float(color[0]), float(color[1]), float(color[2]), 1.0)
+                scene.setBackgroundColor(metal_color)
+        else:
+            super().set_background_color(color)
+    
+    def get_capabilities(self):
+        """Return dictionary of supported capabilities"""
+        capabilities = super().get_capabilities()
+        
+        if self._metal_view:
+            # Add Metal-specific capabilities
+            metal_capabilities = {
+                "api": "Metal",
+                "multi_gpu": self._multi_gpu is not None,
+                "ray_tracing": True,  # Metal 3 supports ray tracing
+                "mesh_shaders": True, # Metal 3 supports mesh shaders
+                "indirect_drawing": True,
+                "argument_buffers": True,
+                "unified_memory": False
+            }
+            
+            # Check for unified memory (Apple Silicon)
+            metal_context = self._metal_view.context()
+            if metal_context:
+                metal_capabilities["unified_memory"] = metal_context.supportsUnifiedMemory()
+            
+            capabilities.update(metal_capabilities)
+        
+        return capabilities
diff --git a/src/bundles/graphics_metal/src/preferences.py b/src/bundles/graphics_metal/src/preferences.py
new file mode 100644
index 0000000000..1b2a574b9a
--- /dev/null
+++ b/src/bundles/graphics_metal/src/preferences.py
@@ -0,0 +1,331 @@
+"""
+Preferences for ChimeraX Metal graphics acceleration
+"""
+
+from chimerax.core.settings import Settings
+from chimerax.core.commands import BoolArg, EnumOf
+from chimerax.core.commands import register as register_command
+
+# Enum argument for multi-GPU strategy
+MultiGPUStrategyArg = EnumOf(["split-frame", "task-based", "alternating", "compute-offload"])
+
+class _MetalGraphicsSettings(Settings):
+    EXPLICIT_SAVE = {
+        'use_metal': True,
+        'auto_detect': True, 
+        'multi_gpu_enabled': False,
+        'multi_gpu_strategy': 'split-frame',
+        'enable_mesh_shaders': True,
+        'enable_ray_tracing': False,
+        'enable_argument_buffers': True,
+        'prefer_device_local_memory': True,
+    }
+    
+    use_metal = Settings.BoolSetting(
+        "Use Metal for graphics rendering",
+        True,
+        "Whether to use Metal for graphics rendering on macOS",
+    )
+    
+    auto_detect = Settings.BoolSetting(
+        "Auto-detect Metal support",
+        True,
+        "Automatically detect and enable Metal if supported",
+    )
+    
+    multi_gpu_enabled = Settings.BoolSetting(
+        "Enable Multi-GPU acceleration",
+        False, 
+        "Use multiple GPUs for rendering if available",
+    )
+    
+    multi_gpu_strategy = Settings.EnumSetting(
+        "Multi-GPU rendering strategy",
+        "split-frame",
+        ["split-frame", "task-based", "alternating", "compute-offload"],
+        "Strategy to use for multi-GPU rendering",
+    )
+    
+    enable_mesh_shaders = Settings.BoolSetting(
+        "Enable mesh shaders",
+        True,
+        "Use mesh shaders for more efficient geometry rendering",
+    )
+    
+    enable_ray_tracing = Settings.BoolSetting(
+        "Enable ray tracing",
+        False,
+        "Use ray tracing for higher quality lighting and shadows",
+    )
+    
+    enable_argument_buffers = Settings.BoolSetting(
+        "Enable argument buffers",
+        True,
+        "Use argument buffers for more efficient resource binding",
+    )
+    
+    prefer_device_local_memory = Settings.BoolSetting(
+        "Prefer device local memory",
+        True,
+        "Prefer device local memory over shared memory for better performance",
+    )
+
+# Singleton instance of settings
+settings = None
+
+def register_settings(session):
+    """Register Metal graphics settings with ChimeraX"""
+    global settings
+    if settings is None:
+        settings = _MetalGraphicsSettings(session, "metal_graphics")
+    return settings
+
+def register_metal_preferences(session):
+    """Register Metal preferences UI with ChimeraX"""
+    from chimerax.ui.gui import MainToolWindow
+    from chimerax.core.commands import run
+    
+    # Get settings
+    prefs = register_settings(session)
+    
+    # Register preference commands
+    register_command(
+        session,
+        "set metal",
+        set_metal_settings,
+        help="Set Metal rendering preferences"
+    )
+    
+    # Function to register preferences UI
+    def _register_ui():
+        from Qt.QtWidgets import QWidget, QVBoxLayout, QFormLayout, QCheckBox, QComboBox, QLabel
+        
+        class _MetalPrefsUI(MainToolWindow):
+            SESSION_ENDURING = True
+            SESSION_SAVE = True
+            help = "help:user/tools/metalgraphics.html"
+            
+            def __init__(self, session, tool_name):
+                super().__init__(session, tool_name)
+                
+                # Create main widget
+                self.ui_area = QWidget()
+                layout = QVBoxLayout()
+                self.ui_area.setLayout(layout)
+                self.setCentralWidget(self.ui_area)
+                
+                # Create form layout for settings
+                form = QFormLayout()
+                layout.addLayout(form)
+                
+                # Use Metal checkbox
+                self.use_metal_cb = QCheckBox()
+                self.use_metal_cb.setChecked(prefs.use_metal)
+                self.use_metal_cb.clicked.connect(self._use_metal_changed)
+                form.addRow("Use Metal rendering:", self.use_metal_cb)
+                
+                # Auto-detect checkbox
+                self.auto_detect_cb = QCheckBox()
+                self.auto_detect_cb.setChecked(prefs.auto_detect)
+                self.auto_detect_cb.clicked.connect(self._auto_detect_changed)
+                form.addRow("Auto-detect Metal support:", self.auto_detect_cb)
+                
+                # Multi-GPU checkbox
+                self.multi_gpu_cb = QCheckBox()
+                self.multi_gpu_cb.setChecked(prefs.multi_gpu_enabled)
+                self.multi_gpu_cb.clicked.connect(self._multi_gpu_changed)
+                form.addRow("Enable Multi-GPU acceleration:", self.multi_gpu_cb)
+                
+                # Multi-GPU strategy
+                self.strategy_combo = QComboBox()
+                self.strategy_combo.addItems([
+                    "Split Frame", 
+                    "Task Based", 
+                    "Alternating Frames", 
+                    "Compute Offload"
+                ])
+                strategy_map = {
+                    "split-frame": 0,
+                    "task-based": 1,
+                    "alternating": 2,
+                    "compute-offload": 3
+                }
+                self.strategy_combo.setCurrentIndex(strategy_map.get(prefs.multi_gpu_strategy, 0))
+                self.strategy_combo.currentIndexChanged.connect(self._strategy_changed)
+                form.addRow("Multi-GPU strategy:", self.strategy_combo)
+                
+                # Mesh shaders checkbox
+                self.mesh_shaders_cb = QCheckBox()
+                self.mesh_shaders_cb.setChecked(prefs.enable_mesh_shaders)
+                self.mesh_shaders_cb.clicked.connect(self._mesh_shaders_changed)
+                form.addRow("Enable mesh shaders:", self.mesh_shaders_cb)
+                
+                # Ray tracing checkbox
+                self.ray_tracing_cb = QCheckBox()
+                self.ray_tracing_cb.setChecked(prefs.enable_ray_tracing)
+                self.ray_tracing_cb.clicked.connect(self._ray_tracing_changed)
+                form.addRow("Enable ray tracing:", self.ray_tracing_cb)
+                
+                # Argument buffers checkbox
+                self.arg_buffers_cb = QCheckBox()
+                self.arg_buffers_cb.setChecked(prefs.enable_argument_buffers)
+                self.arg_buffers_cb.clicked.connect(self._arg_buffers_changed)
+                form.addRow("Enable argument buffers:", self.arg_buffers_cb)
+                
+                # Device local memory checkbox
+                self.device_local_cb = QCheckBox()
+                self.device_local_cb.setChecked(prefs.prefer_device_local_memory)
+                self.device_local_cb.clicked.connect(self._device_local_changed)
+                form.addRow("Prefer device local memory:", self.device_local_cb)
+                
+                # Add hardware info
+                self._add_hardware_info(layout)
+                
+                self.manage(None)
+            
+            def _add_hardware_info(self, layout):
+                """Add hardware info section"""
+                # Try to get Metal hardware info
+                try:
+                    from . import _metal
+                    if not _metal.is_metal_available():
+                        layout.addWidget(QLabel("Metal is not available on this system"))
+                        return
+                        
+                    context = _metal.PyMetalContext()
+                    if not context.initialize():
+                        layout.addWidget(QLabel("Failed to initialize Metal context"))
+                        return
+                        
+                    # Add Metal device info
+                    layout.addWidget(QLabel(f"Metal Device: {context.deviceName()}"))
+                    layout.addWidget(QLabel(f"Vendor: {context.deviceVendor()}"))
+                    layout.addWidget(QLabel(f"Unified Memory: {'Yes' if context.supportsUnifiedMemory() else 'No'}"))
+                    layout.addWidget(QLabel(f"Ray Tracing: {'Yes' if context.supportsRayTracing() else 'No'}"))
+                    layout.addWidget(QLabel(f"Mesh Shaders: {'Yes' if context.supportsMeshShaders() else 'No'}"))
+                    
+                    # Get multi-GPU info
+                    multi_gpu = _metal.PyMetalMultiGPU()
+                    if multi_gpu.initialize(context):
+                        devices = multi_gpu.getDeviceInfo()
+                        if len(devices) > 1:
+                            layout.addWidget(QLabel(f"Multiple GPUs: {len(devices)} devices"))
+                            for device in devices:
+                                layout.addWidget(QLabel(f"  - {device['name']} ({'Primary' if device['is_primary'] else 'Secondary'})"))
+                        else:
+                            layout.addWidget(QLabel("Multiple GPUs: No"))
+                except Exception as e:
+                    layout.addWidget(QLabel(f"Failed to get Metal info: {str(e)}"))
+            
+            def _use_metal_changed(self, checked):
+                prefs.use_metal = checked
+                run(self.session, f"set metal useMetal {checked}")
+                
+            def _auto_detect_changed(self, checked):
+                prefs.auto_detect = checked
+                run(self.session, f"set metal autoDetect {checked}")
+                
+            def _multi_gpu_changed(self, checked):
+                prefs.multi_gpu_enabled = checked
+                run(self.session, f"set metal multiGPU {checked}")
+                
+            def _strategy_changed(self, index):
+                strategies = ["split-frame", "task-based", "alternating", "compute-offload"]
+                if 0 <= index < len(strategies):
+                    prefs.multi_gpu_strategy = strategies[index]
+                    run(self.session, f"set metal multiGPUStrategy {strategies[index]}")
+                
+            def _mesh_shaders_changed(self, checked):
+                prefs.enable_mesh_shaders = checked
+                run(self.session, f"set metal meshShaders {checked}")
+                
+            def _ray_tracing_changed(self, checked):
+                prefs.enable_ray_tracing = checked
+                run(self.session, f"set metal rayTracing {checked}")
+                
+            def _arg_buffers_changed(self, checked):
+                prefs.enable_argument_buffers = checked
+                run(self.session, f"set metal argumentBuffers {checked}")
+                
+            def _device_local_changed(self, checked):
+                prefs.prefer_device_local_memory = checked
+                run(self.session, f"set metal deviceLocalMemory {checked}")
+        
+        # Register the preferences tool
+        session.tools.register("Metal Graphics", _MetalPrefsUI, None, None, None)
+    
+    # Register UI if GUI is available
+    if hasattr(session, 'ui') and session.ui.is_gui:
+        _register_ui()
+
+def set_metal_settings(session, useMetal=None, autoDetect=None, multiGPU=None, 
+                      multiGPUStrategy=None, meshShaders=None, rayTracing=None, 
+                      argumentBuffers=None, deviceLocalMemory=None):
+    """Set Metal rendering preferences"""
+    prefs = register_settings(session)
+    
+    # Update settings that were specified
+    if useMetal is not None:
+        prefs.use_metal = useMetal
+        
+    if autoDetect is not None:
+        prefs.auto_detect = autoDetect
+        
+    if multiGPU is not None:
+        prefs.multi_gpu_enabled = multiGPU
+        
+    if multiGPUStrategy is not None:
+        prefs.multi_gpu_strategy = multiGPUStrategy
+        
+    if meshShaders is not None:
+        prefs.enable_mesh_shaders = meshShaders
+        
+    if rayTracing is not None:
+        prefs.enable_ray_tracing = rayTracing
+        
+    if argumentBuffers is not None:
+        prefs.enable_argument_buffers = argumentBuffers
+        
+    if deviceLocalMemory is not None:
+        prefs.prefer_device_local_memory = deviceLocalMemory
+    
+    # Apply settings if graphics is active
+    from chimerax.graphics_metal.metal_graphics import MetalGraphics
+    if isinstance(session.main_view.graphics, MetalGraphics):
+        graphics = session.main_view.graphics
+        
+        # Apply multi-GPU settings
+        if multiGPU is not None and prefs.multi_gpu_enabled:
+            strategy_map = {
+                "split-frame": 0,
+                "task-based": 1,
+                "alternating": 2,
+                "compute-offload": 3
+            }
+            strategy = strategy_map.get(prefs.multi_gpu_strategy, 0)
+            graphics.enable_multi_gpu(True, strategy)
+        elif multiGPU is not None and not prefs.multi_gpu_enabled:
+            graphics.enable_multi_gpu(False)
+    
+    # Report current settings
+    session.logger.info(f"Metal Graphics Settings:")
+    session.logger.info(f"  Use Metal: {prefs.use_metal}")
+    session.logger.info(f"  Auto-detect: {prefs.auto_detect}")
+    session.logger.info(f"  Multi-GPU enabled: {prefs.multi_gpu_enabled}")
+    session.logger.info(f"  Multi-GPU strategy: {prefs.multi_gpu_strategy}")
+    session.logger.info(f"  Mesh shaders: {prefs.enable_mesh_shaders}")
+    session.logger.info(f"  Ray tracing: {prefs.enable_ray_tracing}")
+    session.logger.info(f"  Argument buffers: {prefs.enable_argument_buffers}")
+    session.logger.info(f"  Prefer device local memory: {prefs.prefer_device_local_memory}")
+
+# Register commands
+set_metal_settings.register_arguments = [
+    ('useMetal', BoolArg, 'Whether to use Metal for rendering'),
+    ('autoDetect', BoolArg, 'Automatically detect Metal support'),
+    ('multiGPU', BoolArg, 'Enable multi-GPU acceleration'),
+    ('multiGPUStrategy', MultiGPUStrategyArg, 'Multi-GPU rendering strategy'),
+    ('meshShaders', BoolArg, 'Enable mesh shaders'),
+    ('rayTracing', BoolArg, 'Enable ray tracing'),
+    ('argumentBuffers', BoolArg, 'Enable argument buffers'),
+    ('deviceLocalMemory', BoolArg, 'Prefer device local memory')
+]
diff --git a/src/bundles/graphics_metal/tests/test_context.py b/src/bundles/graphics_metal/tests/test_context.py
new file mode 100644
index 0000000000..8bf44d0e88
--- /dev/null
+++ b/src/bundles/graphics_metal/tests/test_context.py
@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+
+import unittest
+import sys
+import platform
+import os
+
+# Skip tests if not on macOS
+if platform.system() != "Darwin":
+    print("Skipping Metal tests on non-macOS platform")
+    sys.exit(0)
+
+try:
+    from chimerax.graphics_metal._metal import PyMetalContext, MetalError
+except ImportError:
+    print("Metal module not available, skipping tests")
+    sys.exit(0)
+
+class TestMetalContext(unittest.TestCase):
+    """Test Metal context creation and functionality"""
+    
+    def setUp(self):
+        """Set up test case - create context"""
+        self.context = PyMetalContext()
+    
+    def tearDown(self):
+        """Clean up test case"""
+        # Context will be automatically released in __dealloc__
+        self.context = None
+    
+    def test_initialization(self):
+        """Test that context initializes properly"""
+        # Initialize context
+        initialized = self.context.initialize()
+        self.assertTrue(initialized, "Metal context initialization failed")
+        self.assertTrue(self.context.isInitialized(), "Context reports not initialized after successful initialization")
+    
+    def test_device_info(self):
+        """Test that device info is available"""
+        # Initialize context
+        self.context.initialize()
+        
+        # Get device info
+        device_name = self.context.deviceName()
+        device_vendor = self.context.deviceVendor()
+        
+        self.assertIsNotNone(device_name, "Device name is None")
+        self.assertNotEqual(device_name, "", "Device name is empty")
+        self.assertIsNotNone(device_vendor, "Device vendor is None")
+        self.assertNotEqual(device_vendor, "", "Device vendor is empty")
+        
+        # Log device info for debugging
+        print(f"Metal Device: {device_name}")
+        print(f"Metal Vendor: {device_vendor}")
+    
+    def test_device_capabilities(self):
+        """Test device capability reporting"""
+        # Initialize context
+        self.context.initialize()
+        
+        # Get capabilities
+        unified_memory = self.context.supportsUnifiedMemory()
+        ray_tracing = self.context.supportsRayTracing()
+        mesh_shaders = self.context.supportsMeshShaders()
+        
+        # These could be True or False depending on hardware
+        # Just verify they return boolean values
+        self.assertIsInstance(unified_memory, bool, "Unified memory support is not a boolean")
+        self.assertIsInstance(ray_tracing, bool, "Ray tracing support is not a boolean")
+        self.assertIsInstance(mesh_shaders, bool, "Mesh shader support is not a boolean")
+        
+        # Log capabilities for debugging
+        print(f"Unified Memory: {unified_memory}")
+        print(f"Ray Tracing: {ray_tracing}")
+        print(f"Mesh Shaders: {mesh_shaders}")
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/src/bundles/graphics_metal/tests/test_integration.py b/src/bundles/graphics_metal/tests/test_integration.py
new file mode 100644
index 0000000000..79457e8695
--- /dev/null
+++ b/src/bundles/graphics_metal/tests/test_integration.py
@@ -0,0 +1,200 @@
+#!/usr/bin/env python
+
+"""
+Integration tests for ChimeraX Metal graphics
+
+These tests require a running ChimeraX session with the graphics_metal
+bundle installed and use the ChimeraX API to test the Metal renderer.
+"""
+
+import unittest
+import sys
+import platform
+import os
+import time
+
+# Skip tests if not on macOS
+if platform.system() != "Darwin":
+    print("Skipping Metal tests on non-macOS platform")
+    sys.exit(0)
+
+# Test if we're running inside ChimeraX
+try:
+    import chimerax
+    from chimerax.core.commands import run
+    from chimerax.graphics_metal import metal_graphics
+except ImportError:
+    print("Not running in ChimeraX or graphics_metal bundle not installed, skipping tests")
+    sys.exit(0)
+
+class TestMetalIntegration(unittest.TestCase):
+    """Integration tests for Metal graphics in ChimeraX"""
+    
+    @classmethod
+    def setUpClass(cls):
+        """Set up test class - get ChimeraX session"""
+        # This requires running inside ChimeraX
+        try:
+            from chimerax.core.session import session as chimerax_session
+            cls.session = chimerax_session
+        except ImportError:
+            cls.session = None
+    
+    def setUp(self):
+        """Set up test case - ensure we have a session"""
+        if self.session is None:
+            self.skipTest("No ChimeraX session available")
+    
+    def test_metal_availability(self):
+        """Test Metal availability detection"""
+        # Check if Metal is available
+        is_supported = metal_graphics.is_metal_supported()
+        self.assertIsInstance(is_supported, bool, "Metal support check did not return a boolean")
+        
+        # Log availability for debugging
+        print(f"Metal support: {'Available' if is_supported else 'Not available'}")
+    
+    def test_switch_to_metal(self):
+        """Test switching to Metal graphics provider"""
+        # Check if Metal is supported first
+        if not metal_graphics.is_metal_supported():
+            self.skipTest("Metal not supported on this system")
+        
+        # Save current graphics provider
+        original_provider = self.session.main_view.graphics_provider_info.name
+        
+        try:
+            # Switch to Metal
+            run(self.session, "graphics metal")
+            
+            # Verify switch was successful
+            self.assertIsInstance(
+                self.session.main_view.graphics, 
+                metal_graphics.MetalGraphics,
+                "Failed to switch to Metal graphics provider"
+            )
+            
+            # Get capabilities
+            capabilities = self.session.main_view.graphics.get_capabilities()
+            self.assertEqual(capabilities["api"], "Metal", "Graphics API is not Metal")
+            
+            # Log capabilities for debugging
+            print("Metal graphics capabilities:")
+            for key, value in capabilities.items():
+                print(f"  {key}: {value}")
+            
+            # Test rendering a simple model
+            run(self.session, "open 1ubq")
+            
+            # Give it time to render
+            time.sleep(1)
+            
+            # Change representation
+            run(self.session, "cartoon")
+            
+            # Give it time to render
+            time.sleep(1)
+            
+            # Try different camera view
+            run(self.session, "view")
+            
+            # Give it time to render
+            time.sleep(1)
+        
+        finally:
+            # Switch back to original provider
+            run(self.session, f"graphics {original_provider}")
+    
+    def test_multi_gpu_toggling(self):
+        """Test enabling and disabling multi-GPU rendering"""
+        # Check if Metal is supported first
+        if not metal_graphics.is_metal_supported():
+            self.skipTest("Metal not supported on this system")
+        
+        # Save current graphics provider
+        original_provider = self.session.main_view.graphics_provider_info.name
+        
+        try:
+            # Switch to Metal
+            run(self.session, "graphics metal")
+            
+            # Verify switch was successful
+            self.assertIsInstance(
+                self.session.main_view.graphics, 
+                metal_graphics.MetalGraphics,
+                "Failed to switch to Metal graphics provider"
+            )
+            
+            # Check if multi-GPU is supported
+            capabilities = self.session.main_view.graphics.get_capabilities()
+            if not capabilities.get("multi_gpu", False):
+                self.skipTest("Multi-GPU not supported on this system")
+            
+            # Enable multi-GPU
+            run(self.session, "graphics multigpu true")
+            
+            # Verify multi-GPU is enabled
+            self.assertTrue(
+                self.session.main_view.graphics.is_multi_gpu_enabled(),
+                "Failed to enable multi-GPU rendering"
+            )
+            
+            # Test rendering with multi-GPU
+            run(self.session, "open 1ubq")
+            
+            # Give it time to render
+            time.sleep(1)
+            
+            # Change representation
+            run(self.session, "cartoon")
+            
+            # Give it time to render
+            time.sleep(1)
+            
+            # Disable multi-GPU
+            run(self.session, "graphics multigpu false")
+            
+            # Verify multi-GPU is disabled
+            self.assertFalse(
+                self.session.main_view.graphics.is_multi_gpu_enabled(),
+                "Failed to disable multi-GPU rendering"
+            )
+        
+        finally:
+            # Switch back to original provider
+            run(self.session, f"graphics {original_provider}")
+    
+    def test_preferences(self):
+        """Test Metal preferences"""
+        # Get preferences
+        from chimerax.graphics_metal.preferences import register_settings
+        prefs = register_settings(self.session)
+        
+        # Save original values
+        original_use_metal = prefs.use_metal
+        original_multi_gpu = prefs.multi_gpu_enabled
+        
+        try:
+            # Change preferences
+            prefs.use_metal = not original_use_metal
+            prefs.multi_gpu_enabled = not original_multi_gpu
+            
+            # Verify changes were saved
+            self.assertEqual(prefs.use_metal, not original_use_metal, "Failed to change use_metal preference")
+            self.assertEqual(prefs.multi_gpu_enabled, not original_multi_gpu, "Failed to change multi_gpu_enabled preference")
+            
+            # Test command-based preference setting
+            run(self.session, f"set metal useMetal {original_use_metal}")
+            run(self.session, f"set metal multiGPU {original_multi_gpu}")
+            
+            # Verify command-based changes were saved
+            self.assertEqual(prefs.use_metal, original_use_metal, "Failed to change use_metal preference via command")
+            self.assertEqual(prefs.multi_gpu_enabled, original_multi_gpu, "Failed to change multi_gpu_enabled preference via command")
+        
+        finally:
+            # Restore original values
+            prefs.use_metal = original_use_metal
+            prefs.multi_gpu_enabled = original_multi_gpu
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/src/bundles/graphics_metal/tests/test_multi_gpu.py b/src/bundles/graphics_metal/tests/test_multi_gpu.py
new file mode 100644
index 0000000000..b248ae9c87
--- /dev/null
+++ b/src/bundles/graphics_metal/tests/test_multi_gpu.py
@@ -0,0 +1,125 @@
+#!/usr/bin/env python
+
+import unittest
+import sys
+import platform
+import os
+
+# Skip tests if not on macOS
+if platform.system() != "Darwin":
+    print("Skipping Metal tests on non-macOS platform")
+    sys.exit(0)
+
+try:
+    from chimerax.graphics_metal._metal import (
+        PyMetalContext, 
+        PyMetalMultiGPU, 
+        MetalError
+    )
+except ImportError:
+    print("Metal module not available, skipping tests")
+    sys.exit(0)
+
+class TestMultiGPU(unittest.TestCase):
+    """Test Metal multi-GPU functionality"""
+    
+    def setUp(self):
+        """Set up test case - create context and multi-GPU manager"""
+        self.context = PyMetalContext()
+        self.context.initialize()
+        
+        self.multi_gpu = PyMetalMultiGPU()
+        self.initialized = self.multi_gpu.initialize(self.context)
+    
+    def tearDown(self):
+        """Clean up test case"""
+        # Objects will be automatically released in __dealloc__
+        self.multi_gpu = None
+        self.context = None
+    
+    def test_initialization(self):
+        """Test that multi-GPU manager initializes properly"""
+        self.assertTrue(self.initialized, "Multi-GPU manager initialization failed")
+    
+    def test_get_device_info(self):
+        """Test that device info is available"""
+        # Skip if initialization failed
+        if not self.initialized:
+            self.skipTest("Multi-GPU manager not initialized")
+        
+        # Get device info
+        devices = self.multi_gpu.getDeviceInfo()
+        
+        # Verify device info
+        self.assertIsNotNone(devices, "Device info is None")
+        self.assertIsInstance(devices, list, "Device info is not a list")
+        
+        # There should be at least one device
+        self.assertGreaterEqual(len(devices), 1, "No devices found")
+        
+        # Check if we have multiple GPUs
+        if len(devices) > 1:
+            print(f"Found {len(devices)} GPUs:")
+            for device in devices:
+                print(f"  {device['name']} ({'Primary' if device['is_primary'] else 'Secondary'})")
+                # Verify device info keys
+                self.assertIn('name', device, "Device info missing 'name'")
+                self.assertIn('is_primary', device, "Device info missing 'is_primary'")
+                self.assertIn('is_active', device, "Device info missing 'is_active'")
+                self.assertIn('unified_memory', device, "Device info missing 'unified_memory'")
+                self.assertIn('memory_size', device, "Device info missing 'memory_size'")
+        else:
+            print("Only one GPU found, multi-GPU tests will be limited")
+    
+    def test_enable_disable(self):
+        """Test enabling and disabling multi-GPU"""
+        # Skip if initialization failed
+        if not self.initialized:
+            self.skipTest("Multi-GPU manager not initialized")
+        
+        # Get device info to see if we have multiple GPUs
+        devices = self.multi_gpu.getDeviceInfo()
+        has_multiple_gpus = len(devices) > 1
+        
+        # Enable multi-GPU
+        enabled = self.multi_gpu.enable(True)
+        if has_multiple_gpus:
+            self.assertTrue(enabled, "Failed to enable multi-GPU with multiple GPUs")
+            self.assertTrue(self.multi_gpu.isEnabled(), "Multi-GPU not enabled after enable(True)")
+        else:
+            # With only one GPU, enable() may return False
+            print("Note: enable() may return False with only one GPU")
+        
+        # Disable multi-GPU
+        self.multi_gpu.enable(False)
+        self.assertFalse(self.multi_gpu.isEnabled(), "Multi-GPU still enabled after enable(False)")
+    
+    def test_strategies(self):
+        """Test setting different multi-GPU strategies"""
+        # Skip if initialization failed
+        if not self.initialized:
+            self.skipTest("Multi-GPU manager not initialized")
+        
+        # Get device info to see if we have multiple GPUs
+        devices = self.multi_gpu.getDeviceInfo()
+        has_multiple_gpus = len(devices) > 1
+        
+        if not has_multiple_gpus:
+            self.skipTest("Multiple GPUs required for strategy tests")
+        
+        # Test each strategy
+        for strategy in range(4):
+            enabled = self.multi_gpu.enable(True, strategy)
+            self.assertTrue(enabled, f"Failed to enable multi-GPU with strategy {strategy}")
+            self.assertTrue(self.multi_gpu.isEnabled(), f"Multi-GPU not enabled after enable(True, {strategy})")
+            
+            # Verify strategy was set
+            current_strategy = self.multi_gpu.getStrategy()
+            self.assertEqual(current_strategy, strategy, f"Strategy not set correctly, expected {strategy}, got {current_strategy}")
+            
+            # Disable multi-GPU after testing each strategy
+            self.multi_gpu.enable(False)
+            self.assertFalse(self.multi_gpu.isEnabled(), "Multi-GPU still enabled after enable(False)")
+
+if __name__ == '__main__':
+    unittest.main()