newCGContext returns RiveRendererContext instead of CGRendererContext since v6.9.4

[daichikuwa0618]

Description

RenderContextManager.newCGContext returns RiveRendererContext (Metal-based) instead of CGRendererContext (CoreGraphics-based). This means setting defaultRenderer = .cgRenderer has no effect — the Metal renderer is always used.

Introduced in

Commit 7aa9afaf ("refactor(apple): use new render context per file and view (#9838)"), included in v6.9.4+.

Before this commit, there was a getCGRendererContext method that correctly returned the CG renderer. The refactoring replaced it with newCGContext, but the implementation was changed to return RiveRendererContext:

// RenderContextManager.mm line 432-435 (v6.15.1)
- (RenderContext*)newCGContext
{
    return [[RiveRendererContext alloc] init]; // ← should be CGRendererContext
}

Expected behavior

- (RenderContext*)newCGContext
{
    return [[CGRendererContext alloc] init];
}

Impact

• RenderContextManager.shared().defaultRenderer = .cgRenderer does not switch to CoreGraphics
• Users cannot fall back to CG renderer (e.g., for snapshot testing or CPU-only rendering environments)
• The CGRendererContext class exists in the codebase but is unreachable

Context

We discovered this while investigating snapshot testing with swift-snapshot-testing. The default CALayer.render(in: CGContext) crashes (SIGBUS) on Metal-backed RiveView layers. We hoped to switch to CG renderer as a workaround, but found this bug.

Related: #263 (snapshot testing), #380 (try! in constructors)

Device & Versions

• rive-ios: 6.15.1
• Xcode: 26.3
• iOS: any

[daichikuwa0618]

After reviewing the Choose a Renderer docs more carefully, it seems like the Apple runtime is intentionally Rive-only now.

If this is the case, could you:

1. Confirm that CG renderer is deprecated/removed for the Apple runtime
2. Consider removing the cgRenderer case from RendererType and newCGContext to avoid confusion
3. Update the RenderContextManager.h header comment that mentions "CG" as a context option

Our main use case was trying to find a way to make Rive views compatible with CALayer.render(in:) for snapshot testing (see #263). The CG renderer seemed like it could help, but if it's deprecated, we'll stick with our drawHierarchy workaround.

[dskuza]

Ah, good catch. However, it's important to note that features such as vector feathering are not supported by the CG renderer. Let me confirm with the team whether this should be deprecated from the legacy runtime. The new runtime only includes the Rive renderer (but I haven't yet tested snapshotting it with any snapshot libraries, but I have with UIView.snapshotView(afterScreenUpdates:)).

Regarding snapshotting with the pointfree library, I did POC this once with the Rive renderer. Here is the sample code I used to get it rendering:

enum RiveRenderer {
    static func snapshot(view: UIView, after: TimeInterval) -> UIImage? {
        let size = view.bounds.size

        let riveViews = riveViews(in: view)

        riveViews.forEach {
            $0.isHidden = true
            $0.advance(delta: after)
        }

        let baseImage = UIGraphicsImageRenderer(size: size, format: UIGraphicsImageRendererFormat.default()).image { _ in
            view.drawHierarchy(in: view.bounds, afterScreenUpdates: true)
        }

        riveViews.forEach { $0.isHidden = false }

        let finalImage = UIGraphicsImageRenderer(size: size, format: UIGraphicsImageRendererFormat.default()).image { context in
            baseImage.draw(at: .zero)

            for riveView in riveViews {
                let semaphore = DispatchSemaphore(value: 0)
                var texture: (any MTLTexture)? = nil
                
                riveView.draw(in: riveView.bounds) { buffer in
                    guard let currentTexture = riveView.currentDrawable?.texture else {
                        semaphore.signal()
                        return
                    }
                    texture = currentTexture
                    semaphore.signal()
                }

                // Wait for the draw callback to complete
                semaphore.wait()

                guard let uiImage = snapshot(texture: texture) else { return }

                let rootFrame = riveView.convert(riveView.bounds, to: view)
                uiImage.draw(in: rootFrame)
            }
        }

        return finalImage
    }


    private static func riveViews(in view: UIView) -> [RiveView] {
        var views: [RiveView] = []
        if let riveView = view as? RiveView {
            views.append(riveView)
        }
        for subview in view.subviews {
            views += riveViews(in: subview)
        }
        return views
    }

    private static func snapshot(texture: (any MTLTexture)?) -> UIImage? {
        guard let texture = texture else {
            return nil
        }

        let options: [CIImageOption: Any] = [
            .colorSpace: CGColorSpace(name: CGColorSpace.sRGB)!,
            .nearestSampling: true
        ]
        
        guard let ciImage = CIImage(mtlTexture: texture, options: options)?
                .oriented(.downMirrored) else {
            return nil
        }

        let ciContext = CIContext(options: [
            .workingColorSpace: CGColorSpace(name: CGColorSpace.sRGB)!,
            .outputColorSpace: CGColorSpace(name: CGColorSpace.sRGB)!
        ])
        
        guard let cgImage = ciContext.createCGImage(ciImage, from: ciImage.extent) else {
            return nil
        }

        let image = UIImage(cgImage: cgImage)

        return image
    }
}

public extension Snapshotting where Value == UIView, Format == UIImage {
    static func rive(after: TimeInterval) -> Snapshotting {
        Snapshotting<UIView, UIImage>(
            pathExtension: "png",
            diffing: .image,
            snapshot: { view in
                guard let image = RiveRenderer.snapshot(view: view, after: after) else {
                    return UIImage()
                }
                return image
            }
        )
    }
}

I'm not positive how much the library's API has changed since I last looked into it, but perhaps this will be a starting point for you.