Kingfisher: Swift Image Caching Library

What is Kingfisher?

Kingfisher provides a Swift-only solution for fetching and storing web images, designed for iOS, macOS, tvOS, watchOS, and visionOS platforms. The library includes a `kf` extension for UIImageView, NSImageView, and additional UIKit/AppKit components, as well as a SwiftUI `KFImage` view, all utilizing the same layered memory and disk caching system. Network requests can be cancelled, and data already retrieved is reused rather than downloaded multiple times for the same URL.

Key features of Kingfisher

• ✓Multi-layer hybrid cache with separate memory and disk layers, plus configurable expiration dates and size limits.
• ✓Opt-in async cache probing in `KingfisherManager` so disk cache checks don't block the caller thread.
• ✓Built-in image processors, including downsampling and round-corner processors, chainable with the `|>` operator.
• ✓Independent components: the downloader, cache, and processors work on their own outside the `kf`/`KFImage` extensions.
• ✓Cancelable downloads that reuse previously downloaded content instead of re-fetching the same URL.
• ✓Extensions across UIImageView, NSImageView, NSButton, UIButton, WKInterfaceImage, TVMonogramView, and CPListItem.
• ✓SwiftUI support via `KFImage`, plus Swift 6 and strict-concurrency readiness.
• ✓Live Photo loading and caching, and Low Data Mode support for constrained networks.

Installing Kingfisher in your project

Kingfisher installs through Swift Package Manager: in Xcode, choose File > Swift Packages > Add Package Dependency, add `https://github.com/onevcat/Kingfisher.git`, and select the "Up to Next Major" rule with "8.0.0". CocoaPods works too: ```ruby source 'https://github.com/CocoaPods/Specs.git' platform :ios, '13.0' use_frameworks! target 'MyApp' do pod 'Kingfisher', '~> 8.0' end ``` There's also a pre-built option: download `Kingfisher.xcframework` from the GitHub release page's assets, drag it into your project, add it to your app target, and in the target's "Frameworks, Libraries, and Embedded Content" section set it to "Embed Without Signing". Kingfisher 8.0 needs iOS 13.0+/macOS 10.15+/tvOS 13.0+/watchOS 6.0+/visionOS 1.0+ for the UIKit/AppKit extension, iOS 14.0+/macOS 11.0+/tvOS 14.0+/watchOS 7.0+/visionOS 1.0+ for the SwiftUI `KFImage` view, and Swift 5.9+.

Loading images with Kingfisher: UIKit and SwiftUI examples

The simplest call is the UIKit extension: ```swift import Kingfisher let url = URL(string: "https://example.com/image.png") imageView.kf.setImage(with: url) ``` Kingfisher downloads the image, writes it to both the memory and disk cache, and shows it in `imageView`; setting the same URL again pulls from cache instead of re-downloading. The SwiftUI equivalent is `KFImage`: ```swift var body: some View { KFImage(URL(string: "https://example.com/image.png")!) } ``` For real screens you'll usually chain processors. This downsamples a high-resolution image to the view's bounds, rounds its corners, and shows an activity indicator and placeholder while it loads: ```swift let url = URL(string: "https://example.com/high_resolution_image.png") let processor = DownsamplingImageProcessor(size: imageView.bounds.size) |> RoundCornerImageProcessor(cornerRadius: 20) imageView.kf.indicatorType = .activity imageView.kf.setImage( with: url, placeholder: UIImage(named: "placeholderImage"), options: [ .processor(processor), .scaleFactor(UIScreen.main.scale), .transition(.fade(1)), .cacheOriginalImage ]) { result in switch result { case .success(let value): print("Task done for: \(value.source.url?.absoluteString ?? "")") case .failure(let error): print("Job failed: \(error.localizedDescription)") } } ``` If you'd rather not use the `kf` extension, the `KF` builder chains the same options as method calls and ends with `.set(to: imageView)`. Swap `KF` for `KFImage` and the identical chain works in SwiftUI instead.

Kingfisher alternatives

Frequently asked questions about Kingfisher

The problem it solves

iOS and macOS developers loading remote images by hand tend to rewrite the same URLSession download, memory/disk cache, and cancellation logic in every project, then bolt on corner-rounding or downsampling manually with Core Graphics. Kingfisher packages that combination — async download, a hybrid cache with configurable expiration and size limits, and a chainable processor pipeline — into one dependency instead of leaving each app to rebuild it from a raw URLSession call.

Best use cases

• •Populating a table or collection view with remote thumbnails without hand-writing download and cache logic.
• •Loading a high-resolution detail image, downsampled and corner-rounded to fit the view, while the original stays cached separately.
• •Prefetching a list of image URLs ahead of scrolling so cells render already cached.
• •Adding a remote image view to a SwiftUI screen via `KFImage` instead of a custom `AsyncImage` wrapper.
• •Loading and caching Live Photo assets alongside regular still images.

Who should try it — and who should skip

Try Kingfisher if you're building for iOS, macOS, tvOS, watchOS, or visionOS in Swift and need remote image loading backed by a real cache — memory and disk layers with expiration and size limits, plus downsampling and corner-rounding processors ready to chain. It also fits teams shipping the same screen in both UIKit and SwiftUI, since the builder API carries over. Skip it if your app is Objective-C-first with no Swift bridge planned, if you're already locked into SDWebImage's cache format, or if you only ever load a single placeholder icon and a full caching layer is overkill.

Related repositories