Comparisons
This page and the linked issues files are probably more useful to other libraries’ maintainers, and their coding agents, than to people choosing a library. Most of the code reading was done with coding agents and reviewed by me. I maintain Fast Image, and the benchmark scenarios come from the problems I was working on, so keep that in mind.
My impression: Fast Image doesn’t have many of the small issues I found in the other libraries, has a nicer API in some places, and performs well. In the benchmarks it’s the fastest or tied on Android in every scenario, and within about 40 ms of the fastest on iOS, without a scenario where it does badly. The other libraries usually have one or two they do much worse at (large photos’ memory on iOS for Expo Image and Nitro Image, Android scrolling for Turbo Image, large photos on Android for React Native’s Image), even where they’re a little faster than Fast Image somewhere else.
While working through Fast Image’s issues, I looked at how other image libraries handle the same things, and found differences and some potential issues in them along the way.
This page lists what I consider the major differences between Fast Image and each library, the most important first, including what the other library does better or has that Fast Image doesn’t. They come from reading each library’s code at the version named in its section (checked on 2026-10-18), and from the benchmarks. Each item says how it’s known: from the benchmarks, from a regression case, or from reading the code (not run).
For each library there’s also a plain markdown file of the potential issues found in it: what happens, where in its code, how to reproduce it, and, where Fast Image has a fix, how Fast Image handles it. It’s meant to be handed to a coding agent: if you work on one of these libraries, you can give it the file to go through, try to reproduce the issues and fix them. Libraries change, so some may already be fixed: if something here is out of date, please open an issue or a pull request.
Expo Image
Section titled “Expo Image”Checked: expo-image 58.0.15 (expo repository at 59dfdddb, 2026-10-17); the benchmarks measured expo-image 57.0.5, whose npm package has the same code in the parts the results depend on.
Potential issues in Expo Image: issues/expo-image-issues.md
- Part of Expo. Expo Image is an Expo SDK package: it’s in Expo Go, versioned and tested with each SDK, and documented on docs.expo.dev. Fast Image works in Expo apps too, with a config plugin, but needs a development build.
- Memory and time with large photos on iOS. Fast Image decodes images at about the size they’re shown at by default; Expo Image decodes them at full size and then resizes them on the main thread. For 20 photos of 4000 × 3000 px, Fast Image took 52 MB and 328 ms, Expo Image 414 MB and 560 ms, with no new frame for about 350 ms (benchmarks). On Android they’re at parity (97 and 102 MB, 480 ms each). (Benchmark; the main-thread resize from code.)
- Opening a photo while others load (Android). Fast Image’s
prioritymoves the photo’s waiting download ahead of the others and shares it with the grid: 280 ms against 764 ms for Expo Image, whosepriority="high"only orders Glide’s own threads and which downloads the photo again (benchmarks). On iOS they’re about equal (564 and 580 ms). (Benchmark.) - One download per image on Android. Fast Image downloads an image once, whatever sizes it’s shown at, and a view mounted during its preload uses the preload’s download; Expo Image downloads it once per size (32 requests instead of 16 for 16 photos at two sizes, all shown at 516 ms against 348 ms). On iOS both share SDWebImage’s download, and Expo Image was a little faster (212 against 248 ms). (Benchmark.)
- Load times and scrolling otherwise. At parity for a grid of 60 photos (iOS 308 and 316 ms, Android 548 ms each). Scrolling 500 photos on Android, Expo Image missed 1.1% of frame deadlines and Fast Image 0.3%; neither had hitches on iOS (benchmarks). (Benchmark.)
- Placeholders. Expo Image has BlurHash and ThumbHash placeholders, can generate both from an image (
generateBlurhashAsync,generateThumbhashAsync), and takes any source as a placeholder, with its ownplaceholderContentFit. Fast Image shows a source’s ThumbHash (source.thumbhash) or a tiny image it blurs (source.blurDataUri, like Next.js’sblurDataURL), one per size of an image (or one for every size, asplaceholder={{ thumbhash }}) and drawn where the image will be, or aplaceholder: a bundled image, a data uri, or a url loaded like a source at a high priority, or withcache: 'cacheOnly'only shown if it’s already cached, e.g. a list’s thumbnail while the full image loads. It has no BlurHash and doesn’t generate hashes. (Code.) - Images as objects. Expo Image has
Image.loadAsync, theuseImagehook andreadFromCacheAsync, which give anImageRef(a native image with its size) that can be passed to views assource. Fast Image has nothing like it; itspreloadreports each image’s size. (Code.) - Web. Expo Image’s web version has placeholders (including BlurHash and ThumbHash), transitions,
tintColor, lazy loading and responsivesrcsetselection (responsivePolicy). Fast Image’s web version is minimal: an<img>with the main props and events, and blurred placeholders that show without JavaScript (a source’sblurDataUri, or a ThumbHash with an opt-in decoder; web). Expo Image decodes BlurHashes and ThumbHashes in the browser. (Code.) - Changing the source (iOS). Both keep the current image while a new source loads, with
recyclingKeyfor list cells. In Expo Image, a source changed tonullor to anImageRefwhile a url is loading isn’t cancelled, so the url’s image appears when it finishes, with anonLoad; Fast Image cancels and ignores replaced loads. (Code.) - Leaving a screen (Android). In a native stack (react-native-screens), Fast Image’s images stay while a popped screen slides away; Expo Image’s go blank as the animation starts. (Code; Fast Image’s regression case for its own fix.)
- Networking on Android. Fast Image’s image requests send the app’s cookies (as
fetchand iOS do) and time out after 15 s withonError; Expo Image’s send no cookies on Android and have no timeout. Both send cookies on iOS. (Code.) - Backgrounding on iOS. Fast Image loads an image again if its download was cut off by the app going to the background; with Expo Image it fails with
onErrorafter 15 s away. (Code; Fast Image’s regression case for the SDWebImage behavior.) - Data uris. On Android, Expo Image’s own data uri loader only reads base64 ones, so a percent-encoded SVG (
data:image/svg+xml;utf8,<svg …>) doesn’t load; Fast Image loads both, andgetCachePathgives a data uri’s file. (Code.) - Caching. Both keep images until their url or
cacheKeychanges. Fast Image also hascache: 'web'(follow the server’s HTTP cache headers) and'cacheOnly'; Expo Image’scachePolicychooses memory and disk, and by default ('disk') doesn’t keep decoded images in memory, so an image shown again is decoded from disk (caching). On iOS, with'memory'or'memory-disk', Expo Image’s full-size views can get the smaller copy a tinted view decoded from disk; Fast Image keeps smaller copies under their own key. (Code.) - Cache functions. Fast Image’s
getCachePath(source)downloads the image if needed and resolves with its path or why it failed; Expo Image’sgetCachePathAsync(cacheKey)is a lookup that resolvesnullwhen the file isn’t there yet. Fast Image’sconfigureCacheworks on both platforms and its limits can be set in native config; Expo Image’s is iOS only, and throws on Android. Both havewriteToCache, which in Expo Image also takes anImageRefand behaves differently on the two platforms for a key already cached. Clearing the caches on Android needs an Activity in Expo Image. (Code.) - Preloading. Fast Image’s
preloadresolves with a result per source (with its size or error), loads 3 at a time at low priority, and can skip decoding (memoryCache: false). Expo Image’sprefetchresolves one boolean for the batch, starts every url at once on Android, downloads a failed url again whenever the network comes back on Android, and on iOS doesn’t try a url again after some failures until the app restarts. (Code.) - Animated images. Both animate GIF, animated WebP, APNG and animated AVIF on both platforms. Fast Image has
loop(a count, or once, or forever) andpaused; Expo Image hasautoplayandstartAnimating/stopAnimating, without loop control. A tinted animated image doesn’t play tinted on iOS in Expo Image. (Code.) - Transitions. Expo Image has more effects (flips, curls, SF Symbol replace effects on iOS 17+) and timing curves, and no fade by default. Fast Image cross-dissolves only, fades on Android by default (300 ms), skips memory cache hits by default, has a global default (
setDefaults), and its Android cross-dissolve is exact, where Expo Image’s shows the background mid-fade. (Code.) - HDR photos. Both show HDR photos in HDR on iOS 17+, neither on Android. Expo Image’s
preferHighDynamicRangeis a boolean for constrained HDR (brighter highlights, held below the display’s peak); Fast Image’sdynamicRangeLimithas CSS’s three levels ('standard','constrained','no-limit', the last for a full-screen photo viewer), and on the web it’s CSS’sdynamic-range-limit. Expo Image’s memory cache can give a view an image decoded the other way (an HDR decode to a standard view, or the reverse), which Fast Image checks for. (Code; Fast Image’s checked on an iPhone.) - objectFit and objectPosition. Both name the fits as CSS does. Fast Image shows
noneandscale-downat the same size on iOS and Android and takes CSS’s wholeobject-positionsyntax; Expo Image’s sizes and position numbers differ between iOS and Android, its iOSscale-downcan crop, and acontentPositionstring like'10px'throws on Android. (Code.) - Full-size decoding. Fast Image’s
downsample={false}caps Android decodes at 16 megapixels so they can be drawn, and on iOS decodes images over 64 megapixels at 16 (objectFit="none"still shows them at their own size); Expo Image’sallowDownscaling={false}has no cap, and crashes with very large images on Android. (Reported upstream with a repro.) - blurRadius. Fast Image’s looks the same whatever the file’s resolution and platform, and a change sends no load events. Expo Image’s depends on the image’s resolution on iOS, is capped at 25 on Android, and reloads on Android. (Code.)
- Events. Fast Image sends only the events an image has handlers for; Expo Image sends every event for every image, including progress per network chunk on Android. On Android, Expo Image’s
onProgressreaches only the view that started a shared load. (Code.) alt. Both take it as the label afteraccessibilityLabel, and as the image’s alt text on the web. Fast Image also makes an image withaltan accessibility element on iOS (an explicitaccessiblewins), so VoiceOver reads it (a label alone isn’t read there). Expo Image only uses it as the label. (Code.)- SVG on iOS. Fast Image draws an SVG into a bitmap in the load, off the main thread (for the view’s size, or with
downsample={false}at its own size if that’s larger, to stay sharp zoomed in on), so a cached one shows as fast as a PNG. Expo Image shows it as a vector image, soft when zoomed in on with a transform, which UIKit draws on the main thread (again on every frame of a size change), and withtintColordraws it at three times the pixels needed each way (issues), on several threads at once, where Core Graphics can draw some edges wrong (issues); Fast Image draws one SVG at a time. (Fast Image’s measurements of vector images in its views; Expo Image’s code.) - What Expo Image has that Fast Image doesn’t. SF Symbols (
sf:sources, with symbol effects),svgVariables(CSS variables in SVGs), Live Text (enableLiveTextInteraction),decodeFormat(16-bit bitmaps on Android),onDisplay,lockResourceAsync/reloadAsync, and animageLoadedevent for expo-observe. (Code.) - What Fast Image has that Expo Image doesn’t.
cache: 'web'and'cacheOnly',loop,imageRendering('pixelated'and'smooth'),onLoadEndwith the load’s result,onErrorwith the HTTP status, a global default for fades (setDefaults), cache limits in native config, and a width or height set to'auto'sized from the loaded image. (Code.) - Platforms and install. Fast Image needs React Native 0.83+ with the New Architecture and iOS/tvOS 15.1+ (Fast Image 9 for older setups); Expo Image 58 needs iOS/tvOS 16.4+ and its Expo SDK. Fast Image accepts any SDWebImage 5.x from 5.21.5, where Expo Image pins 5.21.x, and Expo Image adds libavif and libdav1d for AVIF on iOS, where Fast Image uses the system’s decoder. Both can be in one app: Fast Image adds its Glide components to Expo Image’s Glide setup on Android (with expo-image). (Code.)
- Background component. Both have one (
FastImageBackground,ImageBackground): a view the image fills, with the children on top. Fast Image gives View props (accessibility, focus,testID, layout, touch) to the view, and its own (source,objectFit,onLoad, …) to the image, withimagePropsfor any prop on the image instead. Expo Image’s gives every prop butstyleto the image, so an accessibility label orfocusableon it is the image’s, behind the children. (Code.) - At parity: headers,
cacheKey,recyclingKey, several sizes insourcepicked by the view’s size,tintColoron still images, HEIC,onProgresswith a 0–1progressand no events while the total is unknown, tvOS, and padding when drawing (both ignore it; Fast Image leaves it out of the layout too). (Code.)
React Native’s Image
Section titled “React Native’s Image”Checked: React Native main at 27e7721 (2026-10-16, after 0.88.0); the benchmarks measured React Native 0.86.3’s Image.
Potential issues in React Native’s Image: issues/react-native-image-issues.md
- Built in.
Imagecomes with React Native: nothing to install, no native dependencies added to the app, maintained and released with React Native, and on the web react-native-web provides it. Fast Image adds SDWebImage on iOS and Glide on Android (apod install, and their size in the app). - Memory with large photos. On iOS both decode images at about the size they’re shown at, and are at parity (React Native’s
Image48 MB, Fast Image 52 MB for 20 photos of 4000 × 3000 px). On Android, React Native’sImagedecodes network images at full size by default, so the same photos took 269 MB and the last 4 didn’t show; Fast Image took 97 MB (resizeMethod="resize"avoids it). (Benchmark.) - Opening a photo while others load. Fast Image’s
source.prioritymoves an image ahead of the others: on Android it showed the photo at 280 ms against 764 ms for React Native’sImage, which has no priority. On iOS React Native’sImagedownloads the url again rather than joining the download already running, and showed it at 800 ms against 564 ms (benchmarks). (Benchmark.) - Load times and scrolling. Close overall. iOS: Fast Image was faster for the grid (316 against 380 ms) and the same photos at two sizes (248 against 300 ms), equal for large photos. Android: React Native’s
Imagewas a little faster for the grid (516 against 548 ms), equal for two sizes (348 ms, both downloading each photo once, as both share a download between sizes), and both scrolled with almost no late frames (0.4% and 0.3%) (benchmarks). (Benchmark.) - Caching. React Native’s
Imagefollows the server’s HTTP cache headers, like a browser (iOS’sNSURLCache, Fresco’s disk cache on Android), with a per-sourcecacheoption andImage.queryCache. Fast Image keeps an image until its url changes, and addscacheKeyfor changing urls, size limits (configureCache),clearDiskCache,getCachePathandwriteToCache, withcache: 'web'for HTTP cache behavior (caching). Fast Image’s views also takeImage’scachevalues, so a source typed forImageworks as it is:'only-if-cached'is'cacheOnly', and the others load as Fast Image’s default,'immutable'('reload'warns in development). (Code.) - Animated images. Fast Image animates GIF, animated WebP, APNG and animated AVIF on both platforms, with
loopandpaused. React Native’sImageanimates only GIF on iOS, needs Fresco’s optional modules added to the app for GIF and WebP on Android, and has no loop or pause props. Both animate each view on its own on Android. (Code; React Native’s docs for the Android modules.) - Preloading and image info. Fast Image’s
preloadtakes many sources (with headers and priority), loads a few at a time, and resolves with a result per source, including the image’s size. React Native’sImage.prefetchtakes one url and resolvestrueor rejects; it hasImage.getSize/getSizeWithHeaders,queryCache, and on AndroidabortPrefetch. (Code.) - Fades. Fast Image fades on both platforms (
transition, with a global default insetDefaults, skipping memory cache hits, optionally between images). React Native’sImagefades only on Android (fadeDuration, 300 ms by default), also when the system’s animations are off. (Code; the animation setting from the benchmark.) - Changing the source. Fast Image keeps the current image until the new one has loaded on both platforms, with
recyclingKeyfor list cells. React Native’sImagedoes on iOS, and shows its placeholder (or nothing) meanwhile on Android. (Code.) - objectFit and objectPosition. Fast Image follows CSS for every
objectFitvalue and hasobjectPosition. React Native’sImagemapsscale-downtocontain, pinsnoneto the top-left, shows downloaded images at their size in device pixels forcenter, and has noobjectPosition. (Code; sizes checked on the simulator and emulator.) - Sizing from the image. Fast Image sizes a width or height set to
'auto'from the loaded image (its aspect ratio, or with both'auto'its own size), as an<img>does; a side left out stays 0, as with React Native’sImage. Both give a bundled image, or a source with awidthandheight, that size before it loads; with only a width, React Native’sImagekeeps the source’s height, where Fast Image takes the other side from its aspect ratio. (Code.) - blurRadius. Fast Image’s looks the same on iOS and Android whatever the file’s resolution, and changing it sends no load events. React Native’s
Imageblurs a large network image much less on Android, and sends the load events again for each change. (Regression case for the radius; code for the events.) - Stalled downloads on Android. Fast Image’s downloads time out after 15 s with
onError; React Native’s network client has no timeouts, so a stalled image download never ends. (Code.) - Background component. Fast Image’s
FastImageBackgroundgives View props (accessibility, focus,testID, layout, touch) to its view and its own props to the image, withimagePropsfor any prop on the image instead. React Native’sImageBackground, deprecated in 0.88, gives every prop butstyleto the image (andimportantForAccessibilityto both). (Code.) - SVG. Fast Image shows SVG files on both platforms (formats); React Native’s
Imagehas no SVG decoder (react-native-svg draws them). Still images in the common formats (JPEG, PNG, still WebP, and on iOS whatever ImageIO decodes) work in both. (Code.) - Tint. At parity for still images (both show a template image in the view’s
tintColoron iOS). On iOS, a tinted animated GIF doesn’t animate tinted with React Native’sImage; Fast Image tints each frame. (Code.) - onProgress. Fast Image sends bytes and a 0–1
progresson both platforms. React Native’sImagesends Fresco’s level out of 10000 on Android and a total of -1 on iOS when the size is unknown. (Code.) - Several sizes in
source. Both pick the source closest to the view’s size in pixels, natively. Fast Image also loads the largest when the view has no size yet, where React Native’sImagewaits, so an image sized from its ownonLoadnever loads. (Code.) - What React Native’s
Imagehas that Fast Image doesn’t.capInsets,loadingIndicatorSource,progressiveRenderingEnabled,resizeMethod/resizeMultiplier, tiling (resizeMode="repeat", which Fast Image no longer has), and web-style props (src,srcSet,width,height,crossOrigin,referrerPolicy); and a fuller web version through react-native-web, where Fast Image’s is minimal (web). (Code.) - Headers. Both send a source’s
headers. Fast Image sends numbers and booleans as strings (as fetch does), leaves out null and undefined values (headers that aren’t set), and warns in development about values it can’t send (objects). React Native’sImagedrops every header on iOS when one value isn’t a string, and on AndroidgetStringthrows for a number value. (Code.) - Padding. Fast Image ignores padding on both platforms: the image fills the view inside its borders, and padding doesn’t add to the view’s size either. React Native’s
Imageinsets the image by padding on iOS and ignores it on Android. (Code.) - ARIA props. Fast Image maps all of
View’s:aria-label,aria-labelledby,aria-hidden, the state props (aria-busy,aria-checked, …),aria-live, the value props (aria-valuenow, …) andid. React Native’sImagemaps the first four and leaves outaria-live, the value props andid. (Code.) - Keyboard focus and TalkBack on Android. Fast Image takes keyboard and D-pad focus from
focusable(andtabIndex), which React Native’sImageignores.accessiblemakes it a TalkBack stop without keyboard focus, as it’s a VoiceOver element on iOS; React Native’sImagemakes anaccessibleimage a keyboard and D-pad stop too, with no action there. (Code.) alt. Both take it as the label afteraria-labelandaccessibilityLabel, and as the image’s alt text on the web. React Native’sImagemakes an image withaltaccessible on iOS and Android, even overaccessible={false}(onlyaria-hiddenhides it; on Android it stays a keyboard and D-pad stop); Fast Image does on iOS, where VoiceOver needs it, leaves an explicitaccessiblealone, and takes an emptyaltas a decorative image (no label), as the web does. (Code.)- Focus on Apple TV.
focusableandtabIndexmake Fast Image focusable on Apple TV. In React Native tvOS,focusabledoes that for aViewbut not anImage(its native view reads onlyisTVSelectable, which onlyViewsets fromfocusable), andtabIndexdoes it for neither (Viewmaps it tofocusable, then buildsisTVSelectablefrom thefocusableprop). (Code.) - At parity: cookies on Android (both use React Native’s cookie jar), sharing one download between sizes on Android, images staying while a native stack’s popped screen slides away on Android, tvOS (except focus, above), View props and accessibility on a single native view, and
tintColoron still images. (Code.)
The dream-horizon-org fork
Section titled “The dream-horizon-org fork”Checked: the fork’s main at eabb78f (2026-02-04; its latest release is 8.13.0, from 2025-11-05). The fork, @d11/react-native-fast-image, continues Fast Image 8.x: it added a New Architecture (Fabric and TurboModule) version in September–October 2024, while Fast Image wasn’t maintained, and kept Fast Image’s API working on it since. Both wrap SDWebImage and Glide, and their props and caching model come from the same code.
Potential issues in the dream-horizon-org fork: issues/dream-horizon-org-fork-issues.md
- Architectures. The fork supports both the legacy architecture and the New Architecture in one package, and declares no minimum React Native version. Fast Image needs React Native 0.83+ with the New Architecture, iOS 15.1+ and Android 7.0+; apps on the legacy architecture or older React Native use Fast Image 9.x, which is maintained. (Both packages’ code and docs.)
- Correctness. Many issues Fast Image fixed in 8.x–10.0 are still in the fork, among them crashes (one with an image in a view much larger than the screen, on Android), a preload’s headers sent with every later request on iOS, Android downloads failing when another image of the url mounts, a replaced load reported as
onErroron iOS and reloads with load events on unrelated prop changes. The full list is in the file linked above. (Code reading; most were reproduced in Fast Image’s regression cases while it had the same code, and several are reported in the fork’s tracker.) - Network and memory. On iOS with the New Architecture the fork loads sources without
cacheascache: 'web', so cached images are requested again, and it decodes iOS images at full size where Fast Image decodes them at the view’s size (downsample). On Android, an image in a view laid out without a size (under adisplay: 'none'parent, or sized fromonLoad) is decoded for the screen’s length on the sides it doesn’t have, a 16 × 16 icon as 2400 × 2400; Fast Image decodes it no larger than its own size. On Android it downloads an image once per size and has no download timeouts, where Fast Image shares one download per image, queues downloads bypriorityand fails stalled ones. (Code reading; the fork wasn’t in Fast Image’s benchmarks.) - Features only Fast Image has.
objectFitandobjectPosition, per-viewloopandpaused, keeping the previous image while a new source loads (recyclingKey), several sources picked for the view’s size,source.cacheKey,memoryCacheanddiskCache,getCachePath,writeToCache,configureCache,setDefaults, preload results per source, a 0–1progress,FastImageBackground, photo library (ph://) images, a width or height set to'auto'sized from the loaded image, a web version for react-native-web, and an Expo config plugin. The fork’s API is Fast Image 8’s plusblurRadiusandtransition="fade", which Fast Image also has. (Both packages’ code and docs.) - AVIF on older OS versions, where the fork does more. It bundles libavif (with dav1d on iOS) and Glide’s AVIF integration, so AVIF decodes on every OS version it supports, while Fast Image uses the system decoders (iOS 16+, and Android devices with an AVIF decoder, required from Android 14). The cost is app size and native libraries to keep updated (the fork’s tracker has an open report about its libdav1d version). (Build files and docs.)
- Animated images. Both animate GIF, APNG, animated WebP and AVIF on both platforms (the fork with APNG4Android on Android). In the fork, Android views showing the same animated image share one animation, tinted animated images on iOS show their first frame, and
blurRadiusdoesn’t blur animated images on Android. (Code reading.) - One native view. Fast Image is a single native view with all of
View’s props; the fork renders a wrapperViewaround the image view, which getsonLayout,pointerEventsandhitSlop, so they behave differently from React Native’sImage. (Code reading; reproduced in Fast Image 8.x/9.x with the same JS.) - Expo. Fast Image works next to expo-image on Android and has a config plugin; in an app with expo-image, the fork’s Glide modules aren’t registered (no
onProgress). (Code reading.) - SVG. Both include it. The fork can leave it out with
DISABLE_SVG=1(its iOS build then fails, per an open report in its tracker); Fast Image has no such switch. Both bring theandroidsvg-aarpackage, which conflicts with AndroidSVG’s other package; Fast Image documents the Gradle exclude. (Code and docs.) - TypeScript and Jest. The fork’s
ImageStyleloses layout props with React Native’s Strict TypeScript API, and its TypeScript entry point needstransformIgnorePatternsin Jest; Fast Image’s types build onViewStyle, and it renders in Jest without setup. (Code reading, and a report in the fork’s tracker.) - At parity. Caching by url with
immutable,webandcacheOnly,headers,priority(a hint to the loaders in the fork),tintColor,blurRadius,defaultSource,clearMemoryCacheandclearDiskCache, tvOS, and SDWebImage 5.21 and Glide underneath. (Notpreload: on Android the fork downloads a failed preload again whenever the network comes back, and on iOS a url that failed once fails every later preload without a request until the app is relaunched.) (Code and docs.) - Moving between them. The fork keeps Fast Image 8’s API. Fast Image 9 has the same props (
resizeMode,fallback, children,blurRadius), except thattransitiontakestrueor a duration instead of'fade'; Fast Image 10 removedresizeMode(nowobjectFit),fallbackand children (nowFastImageBackground), as Upgrading from 9.x describes. (Docs.) - Activity. The fork’s last release was 8.13.0 (November 2025) and its last commit February 2026; Fast Image released 10.0.0 in October 2026. (npm and git history.)
Nitro Image
Section titled “Nitro Image”Checked: react-native-nitro-image and react-native-nitro-web-image 0.15.2 (commit c96240d), which use SDWebImage on iOS and Coil 3 on Android; the benchmarks measured the same version.
Potential issues in Nitro Image: issues/nitro-image-issues.md
- A different kind of library. Nitro Image is an image object API on Nitro Modules: an
Imageyou can load (from a url, a file, resources, SF Symbols, raw pixels or encoded data), resize, crop, rotate, mirror, render into another, encode, save and turn into a ThumbHash, with fast synchronous and async calls. It’s the nativeImagetype other libraries such as VisionCamera hand to JavaScript, and its view (<NitroImage>) is one part. Fast Image is a view component with caching; it doesn’t edit images. Web images are a separate package,react-native-nitro-web-image. (Code, README.) - Android speed and downloads. In the benchmarks, Fast Image showed images sooner on Android in every scenario: the grid at 548 ms against 796, large photos at 480 against 848, an image at two sizes at 348 against 564 (16 requests against 32: Nitro Image downloads a url again for each size), and a photo opened over a loading grid at 280 ms against 832. Memory was about the same (97 MB against 92), and scrolling missed 0.3% of frames against 1.2%. See downloads for each size. (Benchmarks.)
- iOS: as fast, with much more memory for large photos. On iOS, Nitro Image was as fast or slightly faster (grid 316 ms for both, large photos 300 against 328, two sizes 216 against 248, opened photo 548 against 564), but 20 large photos in small views took 407 MB against Fast Image’s 52, as it decodes them at full size. (Benchmarks.)
- Events.
<NitroImage>sends no load, error or progress events; failures can only be seen when loading anImagewithuseImageorloadImage. Fast Image’s view hasonLoadStart,onProgress,onLoad,onErrorandonLoadEnd. (Code.) - Authentication. Nitro Image’s web images send neither headers (there’s no option) nor the app’s cookies, on either platform; Fast Image sends
headersand the app’s cookies. (Code.) - What the view can do.
<NitroImage>hasresizeMode(cover, contain, center, stretch) andrecyclingKey. Fast Image also hastintColor,blurRadius, fades (transition),defaultSource,objectPosition, several sizes of an image,loopandpausedfor animated images, and a width or height set to'auto'sized from the loaded image. Both can show a ThumbHash while loading: Nitro Image decodes it to anImagefor the app to show, and also encodes them; Fast Image shows a source’sthumbhashitself, and doesn’t encode. (Code.) - Failures and the cache. On iOS, a url that failed in some ways (a page that isn’t an image, a TLS error) fails without a request until the app is relaunched; on Android, a response that isn’t an image is kept in the disk cache and fails that url from then on; Fast Image loads such urls again. (Code.)
- Preloading. Fast Image’s
preloadtakes sources (headers,cacheKey, priority), resolves with a result per image and loads a few at a time. Nitro Image’spreload(url)returns nothing, takes only a url, and on Android starts every request at once;loadFromURLAsyncdoes resolve with the image or reject. (Code.) - Cache control. Both have a cache key (
options.cacheKeyin Nitro Image). Nitro Image’sforceRefreshloads a fresh copy on iOS, and on Android fails without a request. Fast Image also clears its caches (clearDiskCache), sets their limits, gets an image’s cached file and writes one; Nitro Image has none of these. (Code.) - Priority. Both have one (Nitro Image’s
options.priority, Fast Image’ssource.priority). Nitro Image’s'high'didn’t change when a photo opened over a loading grid showed, on either platform: on Android it picks the thread the request runs on, and doesn’t move it ahead of waiting downloads (832 ms, against 280 ms for Fast Image). (Benchmarks; the reason from code.) - Platforms and install. Nitro Image needs the New Architecture and
react-native-nitro-modules, for iOS (and visionOS) and Android, plusreact-native-nitro-web-imagefor urls. Fast Image needs React Native 0.83+ with the New Architecture and supports iOS, tvOS, Android and the web, with an Expo config plugin. (Code, package files.) - Formats. Fast Image includes SVG, animated WebP, APNG and AVIF decoding (formats). Nitro Image uses SDWebImage’s and Coil’s defaults plus Coil’s GIF module, with no SVG decoder on either platform. (Code: podspec and build.gradle dependencies.)
- Changing the image on Android. With Fast Image the image showing stays until a new source has loaded, and a cleared source clears the view. On Android, Nitro Image blanks the view while a new url loads, and keeps the old image when
imageis cleared. (Code.)
Turbo Image
Section titled “Turbo Image”Checked: react-native-turbo-image 1.24.3 (commit 9fd1175), which uses Nuke on iOS and Coil 2 on Android; the benchmarks measured the same version.
Potential issues in Turbo Image: issues/turbo-image-issues.md
- Android speed and downloads. In the benchmarks, Fast Image showed images sooner on Android in every scenario: the grid at 548 ms against 648, large photos at 480 against 864, an image at two sizes at 348 against 564 (with 16 requests against 32: Turbo Image downloads a url again for each size), and a photo opened over a loading grid at 280 ms against 632 (Turbo Image has no priority). Scrolling a long list missed 0.3% of frames with Fast Image and 7.3% with Turbo Image. See downloads for each size. (Benchmarks.)
- iOS speed is at parity. On iOS, Turbo Image was as fast or slightly faster for the grid (300 ms against 316), two sizes (216 against 248) and the opened photo (532 against 564, the fastest measured), and slower for large photos (532 ms against 328), with similar memory (64 MB against 52). (Benchmarks.)
- Placeholders: Turbo Image has more. It shows a BlurHash, a ThumbHash or an image already in its memory cache while loading, an optional activity indicator, and can keep the placeholder on failure. Fast Image shows a ThumbHash, a data uri, a local image or a url (
placeholder) while loading and on failure; a url withcache: 'cacheOnly'covers the memory cache key case (an image another view showed, found in memory at any size on iOS) and also finds it on disk. (Code.) - Effects. Both tint and blur. Turbo Image also has
rounded(a circle crop),monochrome,resize(scale to a width) and Live Text on iOS 16+. Fast Image hasobjectFit(five CSS values) andobjectPositionwhere Turbo Image has fourresizeModes, and itscenterscales large images down on Android but not on iOS. On Android with acacheKey, Turbo Image’s effects share one memory cache entry, so a view can show another’s tint or blur. (Code.) - Animated images. Fast Image detects GIF, WebP, APNG and AVIF and animates them, with
loopandpaused. Turbo Image animates GIF and APNG (and shows SVG) when the app setsformatfor that image, and has no loop or pause control; a tinted animated image doesn’t play tinted. (Code.) - Preloading. Fast Image’s
preloadresolves with a result per image, usescacheKey, and loads a few at a time. Turbo Image’sprefetchresolvestruewhen all have finished, loaded or not, ignorescacheKey, and on Android ends the app for a source without a uri and leaves a network callback registered per call. Its documenteddisposeisn’t implemented natively. (Code.) - Architecture and platforms. Fast Image is a native New Architecture component (React Native 0.83+; Fast Image 9 for older apps and the legacy architecture) for iOS, tvOS, Android and the web, with an Expo config plugin. Turbo Image is a legacy view manager (
requireNativeComponent) that works on both architectures, on the New Architecture through React Native’s interop layer, for iOS, tvOS and Android, with no web version. (Code, README.) - Caching. Turbo Image follows the server’s cache headers by default (
urlCache), withdataCacheto ignore them; Fast Image keeps an image until its url changes by default, withcache: 'web'to follow headers. Both havecacheKeyand clear their caches; Fast Image also hasgetCachePath,writeToCache,configureCacheandmemoryCache: false. WithdataCache, Turbo Image keeps a response that isn’t an image (a captive portal’s page) and fails that url until the cache is cleared. On iOS, Turbo Image’sclearDiskCacheresolves before its HTTP cache is empty, so an image loaded right after can still come from it; Fast Image’s loads in the few seconds after a clear don’t use responses from before it. (Code.) - Headers and cookies. Both send per-image headers. On Android, Turbo Image’s requests don’t send the app’s cookies or use React Native’s OkHttp client; Fast Image’s do. On iOS both send cookies. (Code.)
- Priority. Fast Image has
source.priority; Turbo Image has none. (Code.) - Events: about parity. Turbo Image’s
onStart,onProgress,onSuccess,onFailureandonCompletionmatch Fast Image’sonLoadStart,onProgress,onLoad,onErrorandonLoadEnd. Fast Image’s progress has a 0–1progressand is only sent to images with a handler (Turbo Image sends it for every image on Android); on Android, Turbo Image sends the last-created view’s events again when the app returns from the background. (Code.) - Fades. Turbo Image fades images in over 300 ms by default on both platforms (not over a placeholder), set per image with
fadeDuration. Fast Image fades by default on Android only, withtransitionper image andsetDefaultsfor all. (Code.) - Sources. Turbo Image takes a
{ uri, headers, cacheKey }; Fast Image also takesrequire()d images, several sizes of an image (the view loads the one that fits) and iOS photo library images. (Code.)