RxSwift extensions for Nuke





GitHub Stars



Last Commit

4mos ago










This repository contains RxSwift extensions for Nuke as well as examples of common use cases solved by Rx.


RxNuke provides a set of reactive extensions for Nuke:

extension Reactive where Base: ImagePipeline {
    public func loadImage(with url: URL) -> Single<ImageResponse>
    public func loadImage(with request: ImageRequest) -> Single<ImageResponse>

A Single is a variation of Observable that, instead of emitting a series of elements, is always guaranteed to emit either a single element or an error. The common use case of Single is to wrap HTTP requests. See Traits for more info. {:.info}

Here's a basic example where we load an image and display the result on success:

ImagePipeline.shared.rx.loadImage(with: url)
    .subscribe(onSuccess: { imageView.image = $0.image })
    .disposed(by: disposeBag)

Going From Low to High Resolution

Let's say you want to show a user a high-resolution image that takes a while to loads. You can show a spinner while the high-resolution image is downloaded, but you can improve the user experience by quickly downloading and displaying a thumbnail.

As an alternative, Nuke also supports progressive JPEG. To learn about it, see a dedicated guide. {:.info}

You can implement it using concat operator. This operator results in a serial execution. It starts a thumbnail request, waits until it finishes, and only then starts a request for a high-resolution image.

Observable.concat(pipeline.rx.loadImage(with: lowResUrl).orEmpty,
                  pipeline.rx.loadImage(with: highResUtl).orEmpty)
    .subscribe(onNext: { imageView.image = $0.image })
    .disposed(by: disposeBag)

orEmpty is a custom property which ignores errors and completes the sequence instead (equivalent to func catchErrorJustComplete() from RxSwiftExt. {:.info}

public extension RxSwift.PrimitiveSequence {
    var orEmpty: Observable<Element> {
        asObservable().catchError { _ in .empty() }

Loading the First Available Image

Let's say you have multiple URLs for the same image. For example, you uploaded the image from the camera to the server; you have the image stored locally. When you display this image, it would be beneficial to first load the local URL, and if that fails, try to download from the network.

This use case is very similar to Going From Low to High Resolution, except for the addition of the .take(1) operator that stops the execution when the first value is received.

Observable.concat(pipeline.rx.loadImage(with: localUrl).orEmpty,
                  pipeline.rx.loadImage(with: networkUrl).orEmpty)
    .subscribe(onNext: { imageView.image = $0.image })
    .disposed(by: disposeBag)

Load Multiple Images, Display All at Once

Let's say you want to load two icons for a button, one icon for a .normal state, and one for a .selected state. You want to update the button, only when both icons are fully loaded. This can be achieved using a combineLatest operator.

Observable.combineLatest(pipeline.rx.loadImage(with: iconUrl).asObservable(),
                         pipeline.rx.loadImage(with: iconSelectedUrl).asObservable())
    .subscribe(onNext: { icon, iconSelected in
        button.isHidden = false
        button.setImage(icon.image, for: .normal)
        button.setImage(iconSelected.image, for: .selected)
    }).disposed(by: disposeBag)

Showing Stale Image While Validating It

Let's say you want to show the user a stale image stored in disk cache (Foundation.URLCache) while you go to the server to validate if the image is still fresh. It can be implemented using the same append operator that we covered previously.

let cacheRequest = URLRequest(url: imageUrl, cachePolicy: .returnCacheDataDontLoad)
let networkRequest = URLRequest(url: imageUrl, cachePolicy: .useProtocolCachePolicy)

Observable.concat(pipeline.rx.loadImage(with: ImageRequest(urlRequest: cacheRequest).orEmpty,
                  pipeline.rx.loadImage(with: ImageRequest(urlRequest: networkRequest)).orEmpty)
    .subscribe(onNext: { imageView.image = $0.image })
    .disposed(by: disposeBag)

See "Image Caching" to learn more about HTTP cache. {:.info}

Auto Retry

Auto-retry with an exponential backoff of other delay options (including immediate retry when a network connection is re-established) using smart retry.

pipeline.rx.loadImage(with: request).asObservable()
    .retry(3, delay: .exponential(initial: 3, multiplier: 1, maxDelay: 16))
    .subscribe(onNext: { imageView.image = $0.image })
    .disposed(by: disposeBag)

Tracking Activities

Suppose you want to show an activity indicator while waiting for an image to load. Here's how you can do it using ActivityIndicator class provided by RxSwiftUtilities:

let isBusy = ActivityIndicator()

pipeline.rx.loadImage(with: imageUrl)
    .subscribe(onNext: { imageView.image = $0.image })
    .disposed(by: disposeBag)

    .disposed(by: disposeBag)

In a Table or Collection View

Here's how you can integrate the code provided in the previous examples into your table or collection view cells:

final class ImageCell: UICollectionViewCell {
    private var imageView: UIImageView!
    private var disposeBag = DisposeBag()

    // <.. create an image view using your preferred way ..>

    func display(_ image: Single<ImageResponse>) {

        // Create a new dispose bag, previous dispose bag gets deallocated
        // and cancels all previous subscriptions.
        disposeBag = DisposeBag()

        imageView.image = nil

        // Load an image and display the result on success.
        image.subscribe(onSuccess: { [weak self] response in
            self?.imageView.image = response.image
        }).disposed(by: disposeBag)


RxNuke 3.0Swift 5.3Xcode 12.0iOS 11.0 / watchOS 4.0 / macOS 10.13 / tvOS 11.0
RxNuke 1.0Swift 5.1Xcode 11.0iOS 11.0 / watchOS 4.0 / macOS 10.13 / tvOS 11.0
RxNuke 0.8Swift 4.2 – 5.0Xcode 10.1 – 10.2iOS 10.0 / watchOS 3.0 / macOS 10.12 / tvOS 10.0


RxNuke is available under the MIT license. See the LICENSE file for more info.

Rate & Review

Great Documentation0
Easy to Use0
Highly Customizable0
Bleeding Edge0
Responsive Maintainers0
Poor Documentation0
Hard to Use0
Unwelcoming Community0