Skip to content

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.

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 priority moves the photo’s waiting download ahead of the others and shares it with the grid: 280 ms against 764 ms for Expo Image, whose priority="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 own placeholderContentFit. Fast Image shows a source’s ThumbHash (source.thumbhash) or a tiny image it blurs (source.blurDataUri, like Next.js’s blurDataURL), one per size of an image (or one for every size, as placeholder={{ thumbhash }}) and drawn where the image will be, or a placeholder: a bundled image, a data uri, or a url loaded like a source at a high priority, or with cache: '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, the useImage hook and readFromCacheAsync, which give an ImageRef (a native image with its size) that can be passed to views as source. Fast Image has nothing like it; its preload reports each image’s size. (Code.)
  • Web. Expo Image’s web version has placeholders (including BlurHash and ThumbHash), transitions, tintColor, lazy loading and responsive srcset selection (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’s blurDataUri, 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 recyclingKey for list cells. In Expo Image, a source changed to null or to an ImageRef while a url is loading isn’t cancelled, so the url’s image appears when it finishes, with an onLoad; 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 fetch and iOS do) and time out after 15 s with onError; 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 onError after 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, and getCachePath gives a data uri’s file. (Code.)
  • Caching. Both keep images until their url or cacheKey changes. Fast Image also has cache: 'web' (follow the server’s HTTP cache headers) and 'cacheOnly'; Expo Image’s cachePolicy chooses 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’s getCachePathAsync(cacheKey) is a lookup that resolves null when the file isn’t there yet. Fast Image’s configureCache works on both platforms and its limits can be set in native config; Expo Image’s is iOS only, and throws on Android. Both have writeToCache, which in Expo Image also takes an ImageRef and 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 preload resolves 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’s prefetch resolves 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) and paused; Expo Image has autoplay and startAnimating/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 preferHighDynamicRange is a boolean for constrained HDR (brighter highlights, held below the display’s peak); Fast Image’s dynamicRangeLimit has CSS’s three levels ('standard', 'constrained', 'no-limit', the last for a full-screen photo viewer), and on the web it’s CSS’s dynamic-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 none and scale-down at the same size on iOS and Android and takes CSS’s whole object-position syntax; Expo Image’s sizes and position numbers differ between iOS and Android, its iOS scale-down can crop, and a contentPosition string 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’s allowDownscaling={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 onProgress reaches only the view that started a shared load. (Code.)
  • alt. Both take it as the label after accessibilityLabel, and as the image’s alt text on the web. Fast Image also makes an image with alt an accessibility element on iOS (an explicit accessible wins), 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 with tintColor draws 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 an imageLoaded event for expo-observe. (Code.)
  • What Fast Image has that Expo Image doesn’t. cache: 'web' and 'cacheOnly', loop, imageRendering ('pixelated' and 'smooth'), onLoadEnd with the load’s result, onError with 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, with imageProps for any prop on the image instead. Expo Image’s gives every prop but style to the image, so an accessibility label or focusable on it is the image’s, behind the children. (Code.)
  • At parity: headers, cacheKey, recyclingKey, several sizes in source picked by the view’s size, tintColor on still images, HEIC, onProgress with a 0–1 progress and 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.)

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. Image comes 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 (a pod 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 Image 48 MB, Fast Image 52 MB for 20 photos of 4000 × 3000 px). On Android, React Native’s Image decodes 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.priority moves an image ahead of the others: on Android it showed the photo at 280 ms against 764 ms for React Native’s Image, which has no priority. On iOS React Native’s Image downloads 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 Image was 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 Image follows the server’s HTTP cache headers, like a browser (iOS’s NSURLCache, Fresco’s disk cache on Android), with a per-source cache option and Image.queryCache. Fast Image keeps an image until its url changes, and adds cacheKey for changing urls, size limits (configureCache), clearDiskCache, getCachePath and writeToCache, with cache: 'web' for HTTP cache behavior (caching). Fast Image’s views also take Image’s cache values, so a source typed for Image works 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 loop and paused. React Native’s Image animates 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 preload takes 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’s Image.prefetch takes one url and resolves true or rejects; it has Image.getSize/getSizeWithHeaders, queryCache, and on Android abortPrefetch. (Code.)
  • Fades. Fast Image fades on both platforms (transition, with a global default in setDefaults, skipping memory cache hits, optionally between images). React Native’s Image fades 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 recyclingKey for list cells. React Native’s Image does on iOS, and shows its placeholder (or nothing) meanwhile on Android. (Code.)
  • objectFit and objectPosition. Fast Image follows CSS for every objectFit value and has objectPosition. React Native’s Image maps scale-down to contain, pins none to the top-left, shows downloaded images at their size in device pixels for center, and has no objectPosition. (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’s Image. Both give a bundled image, or a source with a width and height, that size before it loads; with only a width, React Native’s Image keeps 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 Image blurs 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 FastImageBackground gives View props (accessibility, focus, testID, layout, touch) to its view and its own props to the image, with imageProps for any prop on the image instead. React Native’s ImageBackground, deprecated in 0.88, gives every prop but style to the image (and importantForAccessibility to both). (Code.)
  • SVG. Fast Image shows SVG files on both platforms (formats); React Native’s Image has 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 tintColor on iOS). On iOS, a tinted animated GIF doesn’t animate tinted with React Native’s Image; Fast Image tints each frame. (Code.)
  • onProgress. Fast Image sends bytes and a 0–1 progress on both platforms. React Native’s Image sends 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’s Image waits, so an image sized from its own onLoad never loads. (Code.)
  • What React Native’s Image has 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’s Image drops every header on iOS when one value isn’t a string, and on Android getString throws 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 Image insets 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, …) and id. React Native’s Image maps the first four and leaves out aria-live, the value props and id. (Code.)
  • Keyboard focus and TalkBack on Android. Fast Image takes keyboard and D-pad focus from focusable (and tabIndex), which React Native’s Image ignores. accessible makes it a TalkBack stop without keyboard focus, as it’s a VoiceOver element on iOS; React Native’s Image makes an accessible image a keyboard and D-pad stop too, with no action there. (Code.)
  • alt. Both take it as the label after aria-label and accessibilityLabel, and as the image’s alt text on the web. React Native’s Image makes an image with alt accessible on iOS and Android, even over accessible={false} (only aria-hidden hides it; on Android it stays a keyboard and D-pad stop); Fast Image does on iOS, where VoiceOver needs it, leaves an explicit accessible alone, and takes an empty alt as a decorative image (no label), as the web does. (Code.)
  • Focus on Apple TV. focusable and tabIndex make Fast Image focusable on Apple TV. In React Native tvOS, focusable does that for a View but not an Image (its native view reads only isTVSelectable, which only View sets from focusable), and tabIndex does it for neither (View maps it to focusable, then builds isTVSelectable from the focusable prop). (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 tintColor on still images. (Code.)

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 onError on 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 cache as cache: '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 a display: 'none' parent, or sized from onLoad) 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 by priority and fails stalled ones. (Code reading; the fork wasn’t in Fast Image’s benchmarks.)
  • Features only Fast Image has. objectFit and objectPosition, per-view loop and paused, keeping the previous image while a new source loads (recyclingKey), several sources picked for the view’s size, source.cacheKey, memoryCache and diskCache, getCachePath, writeToCache, configureCache, setDefaults, preload results per source, a 0–1 progress, 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 plus blurRadius and transition="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 blurRadius doesn’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 wrapper View around the image view, which gets onLayout, pointerEvents and hitSlop, so they behave differently from React Native’s Image. (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 the androidsvg-aar package, which conflicts with AndroidSVG’s other package; Fast Image documents the Gradle exclude. (Code and docs.)
  • TypeScript and Jest. The fork’s ImageStyle loses layout props with React Native’s Strict TypeScript API, and its TypeScript entry point needs transformIgnorePatterns in Jest; Fast Image’s types build on ViewStyle, and it renders in Jest without setup. (Code reading, and a report in the fork’s tracker.)
  • At parity. Caching by url with immutable, web and cacheOnly, headers, priority (a hint to the loaders in the fork), tintColor, blurRadius, defaultSource, clearMemoryCache and clearDiskCache, tvOS, and SDWebImage 5.21 and Glide underneath. (Not preload: 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 that transition takes true or a duration instead of 'fade'; Fast Image 10 removed resizeMode (now objectFit), fallback and children (now FastImageBackground), 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.)

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 Image you 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 native Image type 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 an Image with useImage or loadImage. Fast Image’s view has onLoadStart, onProgress, onLoad, onError and onLoadEnd. (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 headers and the app’s cookies. (Code.)
  • What the view can do. <NitroImage> has resizeMode (cover, contain, center, stretch) and recyclingKey. Fast Image also has tintColor, blurRadius, fades (transition), defaultSource, objectPosition, several sizes of an image, loop and paused for 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 an Image for the app to show, and also encodes them; Fast Image shows a source’s thumbhash itself, 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 preload takes sources (headers, cacheKey, priority), resolves with a result per image and loads a few at a time. Nitro Image’s preload(url) returns nothing, takes only a url, and on Android starts every request at once; loadFromURLAsync does resolve with the image or reject. (Code.)
  • Cache control. Both have a cache key (options.cacheKey in Nitro Image). Nitro Image’s forceRefresh loads 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’s source.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, plus react-native-nitro-web-image for 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 image is cleared. (Code.)

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 with cache: '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 has objectFit (five CSS values) and objectPosition where Turbo Image has four resizeModes, and its center scales large images down on Android but not on iOS. On Android with a cacheKey, 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 loop and paused. Turbo Image animates GIF and APNG (and shows SVG) when the app sets format for that image, and has no loop or pause control; a tinted animated image doesn’t play tinted. (Code.)
  • Preloading. Fast Image’s preload resolves with a result per image, uses cacheKey, and loads a few at a time. Turbo Image’s prefetch resolves true when all have finished, loaded or not, ignores cacheKey, and on Android ends the app for a source without a uri and leaves a network callback registered per call. Its documented dispose isn’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), with dataCache to ignore them; Fast Image keeps an image until its url changes by default, with cache: 'web' to follow headers. Both have cacheKey and clear their caches; Fast Image also has getCachePath, writeToCache, configureCache and memoryCache: false. With dataCache, 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’s clearDiskCache resolves 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, onFailure and onCompletion match Fast Image’s onLoadStart, onProgress, onLoad, onError and onLoadEnd. Fast Image’s progress has a 0–1 progress and 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, with transition per image and setDefaults for all. (Code.)
  • Sources. Turbo Image takes a { uri, headers, cacheKey }; Fast Image also takes require()d images, several sizes of an image (the view loads the one that fits) and iOS photo library images. (Code.)