             }
         }
         
-        guard let max_width = blocks.lazy.map({ $0.0.width }).max() else { return }
-        guard let max_height = blocks.lazy.map({ $0.0.height }).max() else { return }
-        
-        let descriptor = MTLTextureDescriptor.texture2DDescriptor(
-            pixelFormat: texture.pixelFormat,
-            width: max_width,
-            height: max_height,
-            mipmapped: false)
-        descriptor.storageMode = .private
-        descriptor.usage = .shaderWrite
-        
-        guard let buffer = commandBuffer.device.makeTexture(descriptor: descriptor) else { return }
-        
         for (block, image) in blocks {
             
             let _minX = max(0, block.minX - minX)
             let _minY = max(0, block.minY - minY)
-            let _maxX = min(texture.width, block.maxX - minX)
-            let _maxY = min(texture.height, block.maxY - minY)
+            let _maxX = min(maxX - minX, block.maxX - minX)
+            let _maxY = min(maxY - minY, block.maxY - minY)
             
             let width = _maxX - _minX
             let height = _maxY - _minY
             
             guard width > 0 && height > 0 else { return }
             
-            let block = CGRect(x: _minX + minX, y: _minY + minY, width: width, height: height)
-            texture_renderer.render(image, to: buffer, commandBuffer: commandBuffer, bounds: block, colorSpace: workingColorSpace)
-            
-            let sourceOrigin = MTLOrigin(x: 0, y: 0, z: 0)
-            let sourceSize = MTLSize(width: width, height: height, depth: 1)
-            
-            let destinationOrigin = MTLOrigin(x: _minX, y: _minY, z: 0)
-            
-            guard let blitCommandEncoder = commandBuffer.makeBlitCommandEncoder() else { return }
-            
-            blitCommandEncoder.copy(
-                from: buffer,
-                sourceSlice: 0,
-                sourceLevel: 0,
-                sourceOrigin: sourceOrigin,
-                sourceSize: sourceSize,
-                to: texture,
-                destinationSlice: 0,
-                destinationLevel: 0,
-                destinationOrigin: destinationOrigin
-            )
-            
-            blitCommandEncoder.endEncoding()
+            let bounds = CGRect(x: _minX, y: _minY, width: width, height: height)
+            let _image = image.transformed(by: SDTransform.translate(x: Double(block.minX - minX), y: Double(block.minY - minY)))
+            
+            texture_renderer.render(_image, to: surface, bounds: bounds, colorSpace: workingColorSpace)
         }
     }
 }

                    let crop_zone = CGRect(x: x - block.minX, y: block.maxY - y - blockSize, width: blockSize, height: blockSize)
                    guard let cropped = image.cropping(to: crop_zone) else { continue }
                    
                    let translate = SDTransform.translate(x: Double(x), y: Double(y))
                    var texture = CIImage(cgImage: cropped).transformed(by: translate)
                    
                    if #available(macOS 10.14, iOS 12.0, tvOS 12.0, *) {
                        texture = texture.insertingIntermediate()

            image = image.insertingIntermediate()
        }
        
        guard blockSize > 1 && maxBlockSize > 1 else { return image }
        
        let _extent = extent.isInfinite ? extent : extent.insetBy(dx: .random(in: -1..<0), dy: .random(in: -1..<0))
        
        let info = TiledCacheKernel.Info(image: image, blockSize: min(blockSize, maxBlockSize), maxBlockSize: maxBlockSize, colorSpace: colorSpace)
