Nuke Image Loading System

Nuke provides built-in support for standard image formats such as jpeg, png, and heif. Beyond basic formats, Nuke's architecture allows for extending support to custom image formats and provides capabilities for:

• Progressive decoding
• Animated image rendering
• Progressive animated image rendering
• Drawing vector images (directly or via bitmap conversion)
• Parsing thumbnails from image containers

To monitor image loading performance, you can integrate the Pulse network logging framework by assigning a delegate to the DataLoader within the ImagePipeline configuration.

(ImagePipeline.shared.configuration.dataLoader as? DataLoader)?.delegate = URLSessionProxyDelegate()

To share a disk cache between your main app and an extension (like a Notification Service Extension), point both to a directory within a shared App Group container. In the extension, set isSweepEnabled = false so that the extension does not attempt to enforce size limits or perform LRU cleanup; let the main app handle that.

let sharedCacheURL = FileManager.default
    .containerURL(forSecurityApplicationGroupIdentifier: "group.com.myapp")

// Main app
ImagePipeline.shared = ImagePipeline {
    $0.dataCache = try? DataCache(path: sharedCacheURL)
}

// Extension — reads/writes the same cache but skips LRU sweeps
ImagePipeline.shared = ImagePipeline {
    $0.dataCache = {
        let cache = try? DataCache(path: sharedCacheURL)
        cache?.isSweepEnabled = false
        return cache
    }()
}

The ImagePipeline handles downloading, caching, and preparing images. You can load an image directly using the async image(for:) method on the shared pipeline.

For more granular control, such as monitoring download progress, use imageTask(with:) to create an ImageTask. You can iterate over the progress stream and then await the image or response property.

// Simple async load
let image = try await ImagePipeline.shared.image(for: url)

// Load with progress monitoring
func loadImage() async throws {
    let imageTask = ImagePipeline.shared.imageTask(with: url)
    for await progress in imageTask.progress {
        // Update progress
    }
    imageView.image = try await imageTask.image
}

You can access the DataLoader from the ImagePipeline configuration to set a delegate. This is useful for monitoring network traffic (e.g., with Pulse) or handling authentication challenges via URLSessionTaskDelegate methods.

Note that the DataLoader retains the delegate.

// To monitor with Pulse:
(ImagePipeline.shared.configuration.dataLoader as? DataLoader)?.delegate = URLSessionProxyDelegate()

// To handle authentication challenges:
(ImagePipeline.shared.configuration.dataLoader as? DataLoader)?.delegate = YourDelegate()

final class YourDelegate: URLSessionTaskDelegate {
    func urlSession(_ session: URLSession, task: URLSessionTask, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
        // Handle authentication challenge...
    }
}

The ImageProcessing protocol was updated to support caching processed images. Custom processors no longer conform to Equatable directly; instead, they must provide a String identifier (for cache keys) and a hashableIdentifier (AnyHashable) for efficient memory cache lookups. Additionally, the process(image:context:) method now accepts an optional ImageProcessingContext?.

struct GaussianBlur: ImageProcessing, Hashable {
    let radius: Int

    func process(image: Image, context: ImageProcessingContext?) -> Image? {
        return /* create blurred image */
    }

    // Prefer to use reverse DNS notation.
    var identifier: String { return "com.youdomain.processor.gaussianblur-\(radius)" }
    var hashableIdentifier: AnyHashable { return self }
}