# Issues found in Expo Image

Fast Image's maintainers found these while comparing Fast Image with Expo Image. Fast Image fixes or works around each one in its own code, as described below, except those in the last section, [Other issues](#other-issues), which Fast Image has no counterpart for. They were checked against expo-image 58.0.15 (the expo repository at commit `59dfdddb`, 2026-10-17) on 2026-10-18. Paths are relative to the expo repository. Fast Image's benchmark measured expo-image 57.0.5; the code behind the benchmark-backed issues is the same in its npm package and in 58.0.15. Glide's sources weren't read for this file: where an issue depends on Glide's internals, that's said, and it comes from Fast Image's notes on Glide 4.16 (expo-image uses Glide 5.0.5). If you maintain Expo Image, feel free to hand this file to your coding agent.

## Android: allowDownscaling={false} can crash with a large image

- **What happens:** with `allowDownscaling={false}`, an image whose decoded bitmap is over the hardware canvas limit (about 100 MB, e.g. 7200 × 7200 px) crashes the app when it's drawn: `RuntimeException: Canvas: trying to draw too large(...) bitmap`.
- **Where:** `packages/expo-image/android/src/main/java/expo/modules/image/ExpoImageViewWrapper.kt`, `createDownsampleStrategy()` returns Glide's `DownsampleStrategy.NONE` when `allowDownscaling` is false. The other branches cap the size with `SafeDownsampleStrategy` (`CustomDownsampleStrategy.kt`), this one doesn't.
- **How to reproduce:** Reproduced and reported upstream with a repro app, [expo/expo#50429](https://github.com/expo/expo/issues/50429): show a 7200 × 7200 JPEG with `allowDownscaling={false}`.
- **How Fast Image handles it:** `downsample={false}` decodes at full size up to 16 megapixels (4096 × 4096) and above that at the largest size under it, which Android can still draw ([#1302](https://github.com/DylanVann/react-native-fast-image/pull/1302)).

## Android: a contentPosition string that isn't a number or a percentage throws during layout

- **What happens:** `contentPosition={{ top: '10px', left: 0 }}` (or any string field other than a number, a percentage or `'center'`) throws a `NumberFormatException` on Android when the image is laid out, which isn't caught. The types allow it (`ImageContentPositionValue` includes `string`). On iOS the same value is ignored.
- **Where:** `packages/expo-image/android/src/main/java/expo/modules/image/records/ContentPosition.kt`, `calcOffset()` calls `value.removeSuffix("%").toFloat()` on any string that isn't `"center"`. It runs from `ExpoImageView.applyTransformationMatrix()`, which `onLayout()` calls. `resolveContentPosition()` in `packages/expo-image/src/utils.ts` only checks the string shorthand, not the object's fields.
- **How to reproduce:** Found by reading the code, not run. Render an image with `contentPosition={{ top: '10px', left: 0 }}` on Android.
- **How Fast Image handles it:** `objectPosition` parses CSS's `<position>` syntax (keywords, `px` and `%` lengths, edge offsets) and React Native's object form; an invalid value is ignored (centered) with a warning in development, on every platform ([#1298](https://github.com/DylanVann/react-native-fast-image/pull/1298)).

## iOS: a load replaced by no source or an ImageRef still shows and sends onLoad

- **What happens:** when `source` changes to `null` (or an empty array), or to an `ImageRef`, while a url is still loading, the url's load isn't cancelled. When it finishes, its image replaces what the view shows (the `ImageRef`'s image, or the placeholder) and `onLoad` fires for it. Separately, changing `source` to `null` doesn't clear an image already showing on iOS unless there's a placeholder; on Android the view is cleared.
- **Where:** `packages/expo-image/ios/ImageView.swift`, `reload(force:)`: the `guard let source = bestSource else { displayPlaceholderIfNecessary(); return }` returns before `cancelPendingOperation()`, so `pendingOperation` keeps running, and `imageLoadCompleted` then calls `didLoad`, which sends `onLoad` and calls `renderSourceImage`. The `ImageRef` branch of the `source` prop (`ImageModule.swift`) sets `sources = nil` and renders the ref, then reaches the same `reload()`. Nothing in this path sets `sdImageView.image` to `nil`.
- **How to reproduce:** Found by reading the code, not run. Show a slow remote image, and before it finishes set `source` to `null` (or to an `ImageRef` from `useImage`); the remote image appears when its download finishes, with an `onLoad`.
- **How Fast Image handles it:** every reload cancels the view's current load, also for a `data:` uri or no source, and anything a replaced load still delivers is ignored. A regression case checks a source change to a `data:` uri while a slow image loads ([#1159](https://github.com/DylanVann/react-native-fast-image/pull/1159)).

## Android: views of different sizes, and a view during a prefetch, download an image again

- **What happens:** an image shown at two sizes at the same time is downloaded once per size. In Fast Image's benchmark (16 photos at two sizes at once), Expo Image made 32 requests, where 16 were needed, and showed all 32 images at 516 ms (median), against 348 ms for a library downloading each photo once. A view mounted while `Image.prefetch` of the same url is still downloading downloads it again too.
- **Where:** Glide shares a running load only between requests with the same `EngineKey` (model, size and options); a different size or option starts its own job, and the downloaded file is in Glide's disk cache only after the first job finishes (Glide internals). Views load at their own size (`ImageViewWrapperTarget.getSize()`, `ExpoImageViewWrapper.rerenderIfNeeded()`) with a `GlideUrlWrapper` model and a `ContentFitDownsampleStrategy`, and `prefetch` in `packages/expo-image/android/src/main/java/expo/modules/image/ExpoImageModule.kt` loads a plain `GlideUrl` at the original size with `NoopDownsampleStrategy`. Its comment says quality and downsampling were added to match the view's cache key, but the model, size and downsample option still differ, so a view never joins a prefetch's job.
- **How to reproduce:** Reproduced in Fast Image's benchmark (expo-image 57.0.5, "Sizes" in [benchmarks.md](https://github.com/DylanVann/react-native-fast-image/blob/main/docs/benchmarks.md#android)). For the prefetch: call `Image.prefetch(url)` for a slow url, mount an `Image` of it before the prefetch resolves, and count the requests the server gets (found by reading the code; Fast Image reproduced the same race with Glide before [#1231](https://github.com/DylanVann/react-native-fast-image/pull/1231)).
- **How Fast Image handles it:** on Android, requests for one url (or `cacheKey`), of any size, from views, preloads or `getCachePath`, share one download, and each decodes its own size from it ([#1271](https://github.com/DylanVann/react-native-fast-image/pull/1271), [#1231](https://github.com/DylanVann/react-native-fast-image/pull/1231)).

## Android: a failed prefetch is downloaded again when the network comes back

- **What happens:** with `ACCESS_NETWORK_STATE` (which expo-image's own manifest declares), a url that `Image.prefetch` failed to load is requested again each time the network comes back, until Glide drops the request. Its result is no longer used: since expo/expo#49944 the promise ignores it.
- **Where:** `prefetch` in `packages/expo-image/android/src/main/java/expo/modules/image/ExpoImageModule.kt` loads each url with `.submit()` and never clears the request. Glide keeps a request until it's cleared, and its connectivity monitor calls `RequestTracker.restartRequests()` when the network comes back, which starts every request that hasn't completed, failed ones included (Glide internals).
- **How to reproduce:** Found by reading the code (expo repository at `cae0f09b4`). Prefetch a url that fails while offline, turn the network off and on, and count the requests the server gets. Fast Image's preload had the same restart, and its unit test `failedPreloadDownloadIsntStartedAgainWhenTheNetworkComesBack` saw the second request before the fix.
- **How Fast Image handles it:** a preload's failed load is cleared once its result is in, so Glide doesn't start it again, and each source reports once ([#1356](https://github.com/DylanVann/react-native-fast-image/pull/1356)).

## Android: priority 'high' doesn't move an image ahead of downloads already waiting

- **What happens:** an image with `priority="high"` mounted while many others load is requested after them. In Fast Image's benchmark (the grid's 60 photos loading, then the last one opened at the screen's width 100 ms later, with `priority="high"`), Expo Image showed the photo at 764 ms (median; 816 ms at the 90th percentile), downloading it a second time (61 requests); in 5 of 20 runs it showed it within 280–432 ms, in the others within 480–864 ms. Fast Image showed it at 280 ms with 60 requests.
- **Where:** `packages/expo-image/android/src/main/java/expo/modules/image/enums/Priority.kt` maps `high` to Glide's `Priority.IMMEDIATE`. In Glide (internals), priority only orders jobs waiting for one of Glide's few source threads; Glide's OkHttp fetcher hands each request to OkHttp (`call.enqueue`) as soon as its job starts, so requests go out in OkHttp's order (first come, first served, 5 per host). A request that joins a load in progress keeps that load's priority. The view's request is also a new download (previous issue).
- **How to reproduce:** Reproduced in Fast Image's benchmark (expo-image 57.0.5, "Opening a photo while others load" in [benchmarks.md](https://github.com/DylanVann/react-native-fast-image/blob/main/docs/benchmarks.md#android)).
- **How Fast Image handles it:** downloads that haven't started wait in Fast Image's own queue, ordered by priority (views before preloads), with at most OkHttp's per-host limit waiting on the network per host; a more urgent request for a url whose download is still waiting moves that download up and shares it ([#1271](https://github.com/DylanVann/react-native-fast-image/pull/1271), [#1285](https://github.com/DylanVann/react-native-fast-image/pull/1285)).

## iOS: large images are decoded at full size and then resized on the main thread

- **What happens:** by default (`allowDownscaling`), an image is decoded at full size and then redrawn smaller for the view, on the main thread. In Fast Image's benchmark (20 photos of 4000 × 3000 px in small views, iPhone 15 Pro Max), Expo Image took 560 ms (median) to show them, against 328 ms for Fast Image, the app used 414 MB once they showed (Fast Image 52 MB), and the phone drew no new frame for about 350 ms before they appeared. With `cachePolicy` `'memory'` or `'memory-disk'`, the full-size image is what SDWebImage keeps in its memory cache. With `enforceEarlyResizing` (or `tintColor`), the image is decoded smaller, but to fit inside the view, so a `cover` image whose aspect ratio differs from the view's is enlarged and looks soft.
- **Where:** `packages/expo-image/ios/ImageView.swift`, `didLoad(_:cacheType:imageUrl:)` calls `processImage(_:idealSize:scale:)`, which calls `resize(image:toSize:scale:)` (`ios/Utils/ImageUtils.swift`, a `UIGraphicsImageRenderer` drawing) from SDWebImage's completion block, which SDWebImage calls on the main queue; the manager stores the image in its caches before that. `thumbnailPixelSize(for:)` sets `.imageThumbnailPixelSize` (the view's size in pixels, with `.imagePreserveAspectRatio`) only for `tintColor`, `enforceEarlyResizing` or photo library assets; SDWebImage's thumbnail decoding fits the image inside that size.
- **How to reproduce:** Reproduced in Fast Image's benchmark (expo-image 57.0.5, "Large" in [benchmarks.md](https://github.com/DylanVann/react-native-fast-image/blob/main/docs/benchmarks.md#ios)); the main-thread resize is from reading the code. Show 20 photos of 4000 × 3000 px from a server in 100 pt views, and watch the app's memory and frame rate in Instruments.
- **How Fast Image handles it:** `downsample` (on by default) reads the image's header first and decodes it with ImageIO's thumbnail decoding straight at the size its fit needs (the fill size for `cover`, with EXIF orientation applied), off the main thread; the memory cache keeps that decoded size, and the downloaded file stays in the disk cache, so a larger view decodes again without downloading ([#1158](https://github.com/DylanVann/react-native-fast-image/pull/1158)).

## iOS: an image that was downloading when the app went to the background fails

- **What happens:** if the app goes to the background while an image downloads and stays there for more than 15 seconds, the download fails when the app comes back (`NSURLErrorTimedOut`), so the view gets `onError` and stays empty (or on its placeholder) until something reloads it.
- **Where:** `packages/expo-image/ios/ImageView.swift` loads through `SDWebImageManager` with the shared downloader, whose `downloadTimeout` defaults to 15 s and keeps counting while iOS suspends the download. Nothing in `packages/expo-image/ios` observes the app going to the background or becoming active; `loadingOptions` has `.retryFailed`, which only stops SDWebImage from skipping the url on later loads.
- **How to reproduce:** Found by reading the code; Fast Image reproduced the same SDWebImage behavior in its own regression case before [#1139](https://github.com/DylanVann/react-native-fast-image/pull/1139). Load an image from a slow server (e.g. one that sends a part per second), send the app to the background for 20 s, and bring it back.
- **How Fast Image handles it:** a download that was running when the app went to the background and fails with a network error is loaded again once the app is active, once per load, without a second `onLoadStart`; `onProgress` continues ([#1139](https://github.com/DylanVann/react-native-fast-image/pull/1139)).

## Android: image requests don't send the app's cookies

- **What happens:** on Android, image requests send no cookies, and cookies set by image responses aren't kept. An image behind cookie authentication (a session cookie set by a `fetch` login) loads on iOS (`.handleCookies`, the shared `HTTPCookieStorage`) and fails on Android.
- **Where:** `packages/expo-image/android/src/main/java/expo/modules/image/okhttp/ExpoImageOkHttpClientGlideModule.kt` builds its client with `OkHttpClientProvider.createClient()`. React Native's `createClientBuilder()` gives each new client an empty `ReactCookieJarContainer`; React Native connects only its own networking module's container to the cookie store, so this client's stays empty (unless the app set an `OkHttpClientFactory`).
- **How to reproduce:** Found by reading the code. Log in with `fetch` against a server that sets a session cookie, then load an image that needs that cookie.
- **How Fast Image handles it:** its image client uses Android's cookie store (the one `fetch` and React Native's `Image` use) through OkHttp's `JavaNetCookieJar`, keeps a cookie jar the app set up itself, and sends requests without cookies if the WebView (which holds the store) isn't available, instead of crashing ([#1138](https://github.com/DylanVann/react-native-fast-image/pull/1138)).

## Android: image downloads have no timeout

- **What happens:** a download that stalls (a connection that never answers, or a response that stops sending data) never fails, so the image never shows and never gets `onError`. Since the response body is read on one of Glide's few source threads (Glide internals), a few stalled downloads also hold up other remote images.
- **Where:** `packages/expo-image/android/src/main/java/expo/modules/image/okhttp/ExpoImageOkHttpClientGlideModule.kt` uses `OkHttpClientProvider.createClient()`, whose builder sets connect, read and write timeouts to 0 (none).
- **How to reproduce:** Found by reading the code. Point an image at a server that accepts the connection and then sends nothing, and wait for `onError`.
- **How Fast Image handles it:** its image client gets 15-second connect and read timeouts, as SDWebImage uses on iOS, unless the app's own client already has timeouts ([#1271](https://github.com/DylanVann/react-native-fast-image/pull/1271)).

## iOS: prefetch of a url that failed before fails without a request until the app restarts

- **What happens:** after a prefetch of a url fails in certain ways (data that isn't an image, such as a Wi-Fi login page sent with status 200, an invalid url, or network errors other than the connectivity ones), every later `Image.prefetch` of that url resolves `false` without a request ("Image url is blacklisted") until the app is relaunched, even after the server works again.
- **Where:** `packages/expo-image/ios/ImageModule.swift`, `prefetch` uses `SDWebImagePrefetcher.shared`, whose options are `SDWebImageLowPriority` only (no `SDWebImageRetryFailed`). `SDWebImageManager` (`loadImageWithURL:options:context:progress:completed:` and its failure handling) records such failures in `failedURLs` and fails later loads of them without `SDWebImageRetryFailed`. Views use their own `SDWebImageManager` with `.retryFailed`, so they aren't affected, and a view's success doesn't clear the shared manager's list.
- **How to reproduce:** Found by reading the code; Fast Image reproduced the same SDWebImage behavior with its `preload-retry` case before [#1177](https://github.com/DylanVann/react-native-fast-image/pull/1177). Prefetch a url whose first response is HTML with status 200 and later ones the image; the second prefetch fails without a request.
- **How Fast Image handles it:** preloads pass `SDWebImageRetryFailed`, as views do, so a url that failed is tried again ([#1177](https://github.com/DylanVann/react-native-fast-image/pull/1177)), also by a preload right after the failure: a failed preload resolves once SDWebImage has finished its download, which a new request would otherwise join and fail with, without a request ([#1404](https://github.com/DylanVann/react-native-fast-image/pull/1404)).

## Android: onProgress goes to the view that started a shared load only

- **What happens:** when two views load the same url at the same size and options at the same time, Glide adds the second to the first's load, and only the first gets `onProgress`. If the first view then changes to another source while the second still uses that download, the first keeps getting the old download's progress, interleaved with its new load's.
- **Where:** `packages/expo-image/android/src/main/java/expo/modules/image/ExpoImageViewWrapper.kt`, `rerenderIfNeeded()` sets the view's `progressListener` on its request's `GlideUrlWrapper`, and `okhttp/GlideUrlWrapperLoader.kt` reports progress to the listener of the model the fetch was built from. `GlideUrlWrapper` is a data class whose equality is its `glideUrl` only, so a joining request's model (with its own listener) isn't the one fetching (Glide's `Engine` adds the joining request as a callback of the running job).
- **How to reproduce:** Found by reading the code. Mount two views of the same size with the same slow url and an `onProgress` each; only one gets events.
- **How Fast Image handles it:** progress is looked up by the shared download's key, under a lock, for every view with `onProgress` that's loading it (from `onLoadStart` to its `onLoad` or `onError`), so views joining a load, or waiting for a preload's download, get it, and a view gets no progress from an earlier load ([#1271](https://github.com/DylanVann/react-native-fast-image/pull/1271)).

## Android: prefetch starts every url at once and decodes them into memory views don't use

- **What happens:** `Image.prefetch(urls)` starts a Glide request for every url at once, at the default priority, so a long list fills OkHttp's queue ahead of the images the app shows next, and those wait for the prefetches. Each prefetched image is also decoded at full size into Glide's memory cache, where views don't look (they load at their own size, with other options), also with `cachePolicy: 'disk'`.
- **Where:** `packages/expo-image/android/src/main/java/expo/modules/image/ExpoImageModule.kt`, `prefetch`: `urls.forEach { Glide.with(context).load(GlideUrl(it, headers))...submit() }`, with `diskCacheStrategy(NONE)` only for `'memory'` and no `skipMemoryCache` for `'disk'`.
- **How to reproduce:** Found by reading the code. Prefetch 100 urls from a slow server, then mount an image of another url and note when its request arrives.
- **How Fast Image handles it:** `preload` loads 3 sources at a time across calls, at low priority unless the source sets one, and resolves with a result per source ([#1133](https://github.com/DylanVann/react-native-fast-image/pull/1133)). A source with `memoryCache: false` is only downloaded, without decoding ([`source.memoryCache`](https://github.com/DylanVann/react-native-fast-image/blob/main/README.md#sourcememorycache)).

## Every view sends every event to JavaScript

- **What happens:** each image sends `onLoadStart`, `onProgress` (on Android, for every chunk read from the network), `onLoad` and `onDisplay` to JavaScript whether or not the app handles them, so a screen of images sends many events nobody uses.
- **Where:** `packages/expo-image/src/ExpoImage.tsx` always passes its own `onLoadStart`, `onLoad`, `onProgress` and `onError` to the native view. On Android, `events/OkHttpProgressListener.kt` invokes `onProgress` for each callback from React Native's `ProgressResponseBody`, and expo-modules-core emits a view's declared events without checking for a handler (Android: `packages/expo-modules-core/android/src/main/java/expo/modules/kotlin/viewevent/ViewEvent.kt`, `invoke()`; iOS: `packages/expo-modules-core/ios/Fabric/ExpoFabricView.swift`, `installEventDispatchers()` installs a dispatcher for every declared event), so `onDisplay` is sent too.
- **How to reproduce:** Found by reading the code. Log the events reaching JavaScript (e.g. with a breakpoint in the native view's event emitter) for a grid of images with no handlers.
- **How Fast Image handles it:** JavaScript tells the native view which events have handlers (a bit per event), and images without handlers send nothing ([#1220](https://github.com/DylanVann/react-native-fast-image/pull/1220), and [#1225](https://github.com/DylanVann/react-native-fast-image/pull/1225) for progress in 9.x).

## Android: the cross-fade between two images shows the background mid-fade

- **What happens:** with a `transition`, when a new image (or the image after a placeholder) fades in over the one showing, what's behind the view shows through during the fade: with two opaque images, 25% of the background at the midpoint, a visible dip on a contrasting background.
- **Where:** `packages/expo-image/android/src/main/java/expo/modules/image/ExpoImageViewWrapper.kt`, `onResourceReady()`: when the previous view has a drawable, it animates `previousView.alpha` from 1 to 0 under `newView.alpha` from 0 to 1, at the same time. Composited, that's `new · t + (old · (1 − t) + background · t) · (1 − t)`, so the background contributes `t · (1 − t)`.
- **How to reproduce:** Found by reading the code. Put an image with `transition={1000}` on a red background, change its `source` between two opaque images, and record the screen.
- **How Fast Image handles it:** the Android cross-dissolve draws `from · (1 − t) + image · t`, so nothing behind the view shows through ([#1261](https://github.com/DylanVann/react-native-fast-image/pull/1261)).

## Android: clearing the caches needs an Activity, and clearDiskCache blocks Expo's async functions

- **What happens:** `Image.clearMemoryCache()` and `Image.clearDiskCache()` resolve `false` and clear nothing when there's no current Activity (JavaScript running after Android destroyed the Activity, or a headless task). `clearDiskCache` also runs on Expo's single thread for modules' async functions, so every Expo module's async calls wait while the disk cache is deleted.
- **Where:** `packages/expo-image/android/src/main/java/expo/modules/image/ExpoImageModule.kt`, `clearMemoryCache` and `clearDiskCache` start with `appContext.currentActivity ?: return@AsyncFunction false`, though `Glide.get()` takes any context. `clearDiskCache` has no `runOnQueue`, so it runs on `AppContext.modulesQueue` (the `expo.modules.AsyncFunctionQueue` `HandlerThread` in expo-modules-core).
- **How to reproduce:** Found by reading the code. Call `Image.clearDiskCache()` from a headless JS task; or call it with a few hundred MB cached and time another Expo module's async function called right after.
- **How Fast Image handles it:** both work with the application context, without an Activity ([#1267](https://github.com/DylanVann/react-native-fast-image/pull/1267)), and the disk cache is cleared on Fast Image's own cache thread, in order with its other cache functions ([#1295](https://github.com/DylanVann/react-native-fast-image/pull/1295)).

## contentFit 'none' and 'scale-down' show different sizes on iOS and Android, and iOS 'scale-down' can crop

- **What happens:** with `contentFit="none"` (and `"scale-down"` for an image smaller than the view), a remote image is shown at its pixel size in points on iOS (a 40 × 40 image is 40 pt, as on the web) and in device pixels on Android (about 15 dp on a 2.625× phone). And on iOS, `scale-down` shows a remote image whose size is between the view's size in points and in pixels (e.g. a 300 × 300 image in a 150 pt view on a 3× screen) at 300 pt, cropped to the view, instead of scaled down to fit. With `allowDownscaling={false}` it acts as `none` for any image larger than the view.
- **Where:** iOS: `packages/expo-image/ios/ContentFit.swift` maps `none` and `scaleDown` to `.center`, which draws the `UIImage` at its size in points (remote images get `scale` 1 from `ImageSource.scale`). `idealSize(contentPixelSize:containerSize:scale:contentFit:)` in `ios/Utils/ImageUtils.swift` decides `scaleDown` by comparing the view's size with the image's size divided by the screen scale (100 pt in the example), and returns that size; `shouldDownscale` then sees no need to resize (300 px is not more than 100 pt × 3), so the 300 pt image is shown with `.center`. Scaling down only happens through `processImage`'s resize. Android: `packages/expo-image/android/src/main/java/expo/modules/image/enums/ContentFit.kt`, `toMatrix()` leaves `None` (and a smaller `ScaleDown`) unscaled, at the drawable's intrinsic size, which for Glide's bitmaps is the bitmap's pixels.
- **How to reproduce:** Found by reading the code (Fast Image measured the same Android sizes with Glide in its own regression case before [#1282](https://github.com/DylanVann/react-native-fast-image/pull/1282)). Show a 40 × 40 and a 300 × 300 remote image with `contentFit="scale-down"` in 150 pt views on a 3× iPhone and an Android phone.
- **How Fast Image handles it:** `objectFit` follows CSS on both platforms: an image's own size is its pixels as points (dp on Android), `scale-down` is the smaller of `none` and `contain`, and Android lays out `none` and `scale-down` itself from the image's own size ([#1282](https://github.com/DylanVann/react-native-fast-image/pull/1282)).

## contentPosition numbers and numeric strings mean different things on iOS and Android

- **What happens:** a number in `contentPosition` (documented as points) is points on iOS and device pixels on Android, so `{ top: 20, left: 20 }` moves the image about 2.6 times less on a 2.625× Android phone. A string that's a number without `%`, such as `'20'` (allowed by `` `${number}` `` in the types), is 20 points on iOS and 20% on Android. With both `left` and `right` (or `top` and `bottom`), iOS prefers whichever is a number, Android the `left` (`top`) one. Placeholders are always centered.
- **Where:** Android: `packages/expo-image/android/src/main/java/expo/modules/image/records/ContentPosition.kt`, `calcOffset()` passes a `Double` to `calcTranslation()` (`ImageUtils.kt`) as a matrix translation in pixels, and treats every other string as a percentage after removing a `%`; `offsetX()` tries `left` before `right`. `ExpoImageView.applyTransformationMatrix()` uses `ContentPosition.center` for placeholders. iOS: `packages/expo-image/ios/ContentPosition.swift`, `distance(from:)` reads a number or a numeric string as points, and `offsetX` tries both edges' distances before percentages.
- **How to reproduce:** Found by reading the code. Show a `contentFit="none"` image with `contentPosition={{ top: 20, left: 20 }}` on both platforms.
- **How Fast Image handles it:** `objectPosition` numbers (and `px` lengths) are points on iOS and dp on Android, percentages follow CSS, both edges of one axis are rejected by the types and centered at runtime with a warning, and `defaultSource` is placed the same way ([#1298](https://github.com/DylanVann/react-native-fast-image/pull/1298)).

## blurRadius depends on the image's resolution and the platform

- **What happens:** the same `blurRadius` blurs a large photo much less than a small image on iOS, and blurs differently on iOS and Android: iOS blurs the full-size decoded image (radius / 2, in the image's pixels for remote images) before it's resized for the view; Android blurs the bitmap decoded for the view, on a copy 4× smaller, so its radius is in units of 4 device pixels, and caps it at 25. On Android, each change of `blurRadius` starts a new load, with `onLoadStart` and `onLoad` again.
- **Where:** `packages/expo-image/ios/ImageModule.swift` (`blurRadius` prop, `radius / 2.0`) and `ios/ImageView.swift` (`createTransformPipeline()`, an `SDImageBlurTransformer` that SDWebImage applies to the decoded image before `processImage` resizes it); `SDImageBlurTransformer` multiplies the radius by the image's `scale`. Android: `ExpoImageViewWrapper.kt`, `createPropOptions()` adds `SoftwareBlurTransformation(min(it, 25), 4)`, and the `blurRadius` setter sets `shouldRerender`.
- **How to reproduce:** Found by reading the code. Show a 4000 × 3000 photo and a 300 × 225 copy of it in the same 100 pt view, both with `blurRadius={10}`, on iOS and Android.
- **How Fast Image handles it:** the image is blurred at about the size it's shown at, with React Native's iOS box-blur math on both platforms, so a radius looks the same whatever the file's resolution and platform; changing it blurs the image showing again without load events ([#1193](https://github.com/DylanVann/react-native-fast-image/pull/1193), [#1292](https://github.com/DylanVann/react-native-fast-image/pull/1292)).

## iOS: tinted animated images don't play tinted

- **What happens:** an animated GIF or WebP with `tintColor` doesn't play in the tint color.
- **Where:** `packages/expo-image/ios/ImageView.swift`, `setImage(_:contentFit:isPlaceholder:)` sets `image?.withRenderingMode(.alwaysTemplate)` and the view's `tintColor`. `SDAnimatedImageView` draws an animated image's frames itself (`displayLayer:` sets `layer.contents` to each frame's `CGImage`), which `tintColor` doesn't affect, and `sdImageView.animationTransformer` is only set for resizing (`processImage`).
- **How to reproduce:** Found by reading the code, not run. Show an animated GIF with `tintColor="red"`; what it shows (untinted frames, or a still tinted frame if UIKit's template copy isn't an animated image) depends on the class UIKit gives the template copy.
- **How Fast Image handles it:** a still image is shown as a template with the view's `tintColor`, and an animated image's frames are tinted as they're decoded, with SDWebImage's `animationTransformer` and `SDImageTintTransformer` ([#1195](https://github.com/DylanVann/react-native-fast-image/pull/1195)).

## ImageBackground's accessibility and focus props are the image's, behind the children

- **What happens:** every prop but `style` goes to the `Image` that fills `ImageBackground`, so `accessible`, an accessibility label or `focusable` on it make the image behind the children the screen reader or focus stop, not the view with the children. On Android TV the D-pad stops on the image; there's no way to put them on the view.
- **Where:** `packages/expo-image/src/ImageBackground.tsx` renders `<View style={style}><Image {...props} style={[StyleSheet.absoluteFill, imageStyle]} />{children}</View>`.
- **How to reproduce:** Found by reading the code (Expo's `main` at `cae0f09b4`, 2026-10-23). Render `<ImageBackground focusable source={...}><Text>Title</Text></ImageBackground>` on Android TV and move focus with the D-pad.
- **How Fast Image handles it:** `FastImageBackground` gives View props, accessibility and focus among them, to its view and its own props to the image, with `imageProps` for any prop on the image instead ([#1364](https://github.com/DylanVann/react-native-fast-image/pull/1364)).

## iOS: an image with only alt isn't read by VoiceOver

- **What happens:** `<Image alt="A cat" source={...} />` gets the label, but VoiceOver skips the image on iOS, as it's not an accessibility element: `alt` is only another name for `accessibilityLabel`, and on iOS a view's label is read only when it's `accessible`. On the web the same props are an `<img alt>` that screen readers read.
- **Where:** `packages/expo-image/src/ExpoImage.tsx`, `render()` passes `accessibilityLabel={accessibilityLabel ?? alt}` and leaves `accessible` as it's given.
- **How to reproduce:** Found by reading the code (Expo's `main` at `cae0f09b4`, 2026-10-23). Show `<Image alt="A cat" source={...} />` and move through the screen with VoiceOver.
- **How Fast Image handles it:** on iOS an image labelled by `alt` (or `aria-label`) is an accessibility element unless `accessible` or `aria-hidden` says otherwise ([#1365](https://github.com/DylanVann/react-native-fast-image/pull/1365)).

## configureCache is iOS only, and throws on Android

- **What happens:** `Image.configureCache()` exists only on iOS: on Android the native module has no such function, so calling it throws a `TypeError` (`ImageModule.configureCache is not a function`). On iOS the limits aren't saved (the app has to call it on every launch, after images may already have loaded), there's no age limit, and a lower `maxDiskSize` is only applied at SDWebImage's next cleanup (when the app goes to the background or terminates).
- **Where:** `packages/expo-image/src/Image.tsx`, `configureCache()` calls `ImageModule.configureCache(config)`; only `packages/expo-image/ios/ImageModule.swift` defines it (`Function("configureCache")`, which sets `SDImageCache.shared.config`), and `ExpoImageModule.kt` doesn't. The Android disk cache is Glide's default (`ExpoImageAppGlideModule.applyOptions`, `InternalCacheDiskCacheFactory(context)`).
- **How to reproduce:** Found by reading the code. Call `Image.configureCache({ maxDiskSize: 100 * 1024 * 1024 })` on Android.
- **How Fast Image handles it:** `configureCache` works on both platforms and reports the limits and disk usage; starting limits can be set in native config (or its Expo config plugin) so they apply from the first image, runtime changes are saved for later launches, iOS has `maxDiskAge` and applies a lower limit at once, and Android sets Glide's disk cache size ([#1183](https://github.com/DylanVann/react-native-fast-image/pull/1183)).

## writeToCacheAsync replaces a cached image on iOS but not on Android

- **What happens:** writing an image for a `cacheKey` that's already cached replaces it on iOS and keeps the old one on Android, where the promise resolves as if it had been written. On iOS, a file written for a key whose image is in the memory cache doesn't replace the memory entry, so views keep showing the old image until it's evicted. The file isn't checked to be an image, and only `file://` uris are accepted (pickers on Android often return `content://`).
- **Where:** iOS: `packages/expo-image/ios/ImageModule.swift`, `writeToCacheAsync` calls `SDImageCache.shared.store(nil, imageData:, forKey:, toDisk: true)`, which overwrites the file and only updates the memory cache when given an image. Android: `ExpoImageModule.kt`, `writeToCacheAsync` loads a `GlideUrlWithCustomCacheKey` with `asFile()` and `DiskCacheStrategy.DATA`; Glide looks in its disk cache before fetching (Glide internals), so for a key already there it returns the cached file and never reads the new one (`LocalFileGlideModelLoader`). Both throw `WriteToCacheRemoteSourceException` for anything but a file url.
- **How to reproduce:** Found by reading the code. Write image A for a key, show it, then write image B for the same key and show it again on each platform.
- **How Fast Image handles it:** `writeToCache(source, file)` behaves the same on both platforms for an image that's already cached (it isn't replaced, and the docs say to use a new `cacheKey`), checks the file is an image, and takes `content://` uris on Android ([#1179](https://github.com/DylanVann/react-native-fast-image/pull/1179)).

## iOS: preferHighDynamicRange can show an image decoded the other way

- **What happens:** two views of the same image, one with `preferHighDynamicRange` and one without, can show each other's decode: the HDR view a standard range one (no HDR), or the standard view an HDR one (brighter than the rest of its screen), whichever was decoded first and is in the memory cache.
- **Where:** `packages/expo-image/ios/ImageView.swift`, `createBaseImageContext` sets SDWebImage's `imageDecodeToHDR` from the prop, but SDWebImage's memory cache key (`SDWebImageManager cacheKeyForURL:context:`) is the url with the thumbnail size and transformer, not the decode mode, so both decodes are stored and found under one key.
- **How to reproduce:** Found by reading the code. Show an HDR photo (e.g. an iPhone photo with a gain map) in a view without the prop, then the same url in a view with it, on an HDR iPhone.
- **How Fast Image handles it:** `dynamicRangeLimit` drops a memory-cached copy decoded the other way before a load, so each view decodes the file as it asked for.

## iOS: a full-size view can show the smaller copy a tinted view decoded

- **What happens:** with SDWebImage 5.21.6 or later (Expo Image allows `~> 5.21.0`), an image a view with `tintColor` or `enforceEarlyResizing` decoded smaller from the disk cache is also put in memory under the image's full-size key. A view of the same url without them, with `cachePolicy` `'memory'` or `'memory-disk'`, then shows that smaller copy, enlarged and soft. With the default (`'disk'`) the copy only takes memory.
- **Where:** `packages/expo-image/ios/Utils/ImageUtils.swift`, `createSDWebImageContext` sets `.originalQueryCacheType` to the `cachePolicy`'s type for every source but photo library assets (`ImageSource.cacheOriginalImage`), and `ImageView.swift`'s `thumbnailPixelSize(for:)` sets `.imageThumbnailPixelSize` for those loads. SDWebImageManager's `callOriginalCacheProcessForOperation` decodes the original file with the thumbnail size and, for a disk hit, stores the result in memory under the original key (`storeImage:… cacheType:SDImageCacheTypeMemory`, which ignores `.storeCacheType`; 5.21.5's `SDImageCache` moved a thumbnail to its own key).
- **How to reproduce:** Found by reading the code, not run. With an image on disk but not in memory (after restarting the app), show it in a small view with `tintColor`, then in a large view of the same url with `cachePolicy="memory-disk"`: the large view shows a blurry, enlarged copy.
- **How Fast Image handles it:** a downsampled load reads the file through its own original cache, which keeps only images decoded at full size in memory, so the full-size key never holds a smaller copy; full-size loads also drop a smaller copy found there before they start ([#1382](https://github.com/DylanVann/react-native-fast-image/pull/1382)).

## Android: an image in a popped screen goes blank while the screen slides away

- **What happens:** when a native stack (react-native-screens) pops a screen, its images are blank for the rest of the screen's exit animation.
- **Where:** `packages/expo-image/android/src/main/java/expo/modules/image/ExpoImageViewWrapper.kt`, `onViewDestroys()` sets both image views' drawables to `null` and clears their requests; `ExpoImageModule.kt` calls it from `OnViewDestroys`, when React Native drops the view. React Native drops a popped screen's views as its animation starts, while react-native-screens still draws them until it ends (`Screen.startRemovalTransition()` calls `startViewTransition` on each of them).
- **How to reproduce:** Found by reading the code (expo repository at `5599fba0d`), not run. Push a screen with an `Image` in a native stack, let it load and go back. Fast Image's regression case `navigation-pop-thumbhash` saw its own image go back to its placeholder there before the fix below.
- **How Fast Image handles it:** on Android, a view dropped while it's still attached keeps its image, and its request is cleared once it's detached ([#1386](https://github.com/DylanVann/react-native-fast-image/pull/1386)).

## iOS: SVGs are drawn on the main thread, and a tinted one at three times its pixels each way

- **What happens:** an SVG without `tintColor` is shown as a vector image, which UIKit draws on the main thread when the view shows it, and again on every frame its size changes. UIKit draws it at the view's size, so a view zoomed in on with a transform or a zoomed ScrollView (a pinch-to-zoom viewer) shows it scaled up and soft. Fast Image measured the same vector images in its own views (iPhone 15 Pro Max, Release): 40 cached 24-point icons took 36 ms of the main thread to mount, against 11 ms as PNGs, and 7 illustrations (200 shapes) 112 ms, against 7 ms; one illustration animating its width blocked the main thread for 5–9 ms on every frame. With `tintColor`, the SVG is drawn into a bitmap in SDWebImage's decode, off the main thread, but at the view's size in pixels taken as points, so at three times the pixels needed each way on a 3× screen (a 24-point icon is 216 × 216 px, nine times the memory).
- **Where:** `packages/expo-image/ios/ImageView.swift`, `thumbnailPixelSize(for:)` returns the view's size in pixels only for `tintColor`, `enforceEarlyResizing` or photo library assets, and without it `SDImageSVGCoder` decodes a vector image. With it, `SDImageSVGCoder`'s `createBitmapSVGWithData:targetSize:preserveAspectRatio:` (SDWebImageSVGCoder 1.7.0, which expo-image's podspec pins with `~> 1.7.0`) draws the SVG at `targetSize` with `SDGraphicsBeginImageContextWithOptions(targetRect.size, NO, 0)`, and a scale of 0 is the screen's scale.
- **How to reproduce:** Found by reading the code, not run; the main-thread times are Fast Image's own measurements of vector images in its views before [#1389](https://github.com/DylanVann/react-native-fast-image/pull/1389), and the zoomed vector is what Fast Image's `zoom` cases showed before [#1392](https://github.com/DylanVann/react-native-fast-image/pull/1392). Show a tinted 24-point SVG icon and check the image's `CGImage` size (216 × 216 on a 3× screen); show an SVG whose view animates its size and watch the main thread in Instruments.
- **How Fast Image handles it:** an SVG is drawn into a bitmap for the view's size in pixels in the load, off the main thread, tinted or not, and kept in the memory cache at that size; it's drawn again when the view grows by a fifth, as other images are decoded again ([#1389](https://github.com/DylanVann/react-native-fast-image/pull/1389)); with `downsample={false}` at its own size, or the view's if that's larger, so it's sharp zoomed in on up to its own size ([#1392](https://github.com/DylanVann/react-native-fast-image/pull/1392)).

## iOS: tinted SVGs drawn at the same time can come out with wrong pixels

- **What happens:** Core Graphics draws antialiased translucent shapes wrongly when several threads draw them at once, even into separate bitmaps (FB25211753, which Apple confirmed on iOS 26 and 27 in [this forum thread](https://developer.apple.com/forums/thread/851778)): some shapes' edges come out jagged and in the wrong colors. Expo Image draws a tinted SVG into a bitmap on SDWebImage's decode threads, which run one per download at the same time, so tinted SVGs loading together can come out wrong.
- **Where:** `packages/expo-image/ios/ImageView.swift`, `thumbnailPixelSize(for:)` asks for a bitmap with `tintColor`, and `packages/expo-image/ios/Coders/SVGCoder.swift` decodes with SDWebImageSVGCoder, whose `createBitmapSVGWithData:targetSize:preserveAspectRatio:` draws the document (`SDCGContextDrawSVGDocument`) on the thread decoding it, with nothing keeping two drawings apart.
- **How to reproduce:** Found by reading the code, not run in Expo Image. Fast Image measured the Core Graphics behavior on an iPhone 15 Pro Max: a 200-shape SVG drawn on 8 threads at once came out wrong in 10–20% of the drawings, and drawn one at a time never.
- **How Fast Image handles it:** every SVG it parses or draws goes through one lock, the main thread first ([#1390](https://github.com/DylanVann/react-native-fast-image/pull/1390)).

## Android: a percent-encoded data uri doesn't load

- **What happens:** a data uri whose data isn't base64, such as `data:image/svg+xml;utf8,<svg …>` (common for inline SVGs), doesn't load on Android. iOS loads it.
- **Where:** `packages/expo-image/android/src/main/java/expo/modules/image/dataurls/Base64DataFetcher.kt`, `loadData` passes everything after the comma to `Base64.decode`, whatever the uri's header says.
- **How to reproduce:** Found by reading the code, not run in Expo Image. Fast Image's Android version had the same gap with Glide's data url loader, which only reads `;base64,` uris: the `data-uri-utf8` case never loaded before [#1397](https://github.com/DylanVann/react-native-fast-image/pull/1397).
- **How Fast Image handles it:** a percent-encoded data uri is decoded and encoded again as base64 before Glide loads it ([#1397](https://github.com/DylanVann/react-native-fast-image/pull/1397)).

## Other issues

These were found while comparing the two libraries, but Fast Image has no counterpart for them, so there's no fix to point to.

### Prefetching an empty list never resolves

- **What happens:** `Image.prefetch([])` returns a promise that never settles, on iOS and Android, so code that awaits it (e.g. prefetching a page of results that turned out empty) stops there.
- **Where:** `packages/expo-image/src/Image.tsx`, `prefetch()` passes the array to the native module as is. `packages/expo-image/ios/ImageModule.swift` and `packages/expo-image/android/src/main/java/expo/modules/image/ExpoImageModule.kt`, `prefetch`: the promise is only resolved from the completion of a load started in `urls.forEach`, so with no urls nothing resolves it.
- **How to reproduce:** Found by reading the code. `await Image.prefetch([])` and log after it.

### iOS: generating a BlurHash or ThumbHash from a url downloads it every time and keeps a URL session per call

- **What happens:** `Image.generateBlurhashAsync(url, …)` and `Image.generateThumbhashAsync(url)` download the image on every call, without using the image cache or `source` headers, even if the image was just shown. Each call also creates its own `SDWebImageDownloader`, whose `URLSession` keeps it alive for the rest of the app's life, so an app that generates hashes for many images accumulates one session (with its operation queue) per call. On Android the same functions load through Glide, with its caches.
- **Where:** `packages/expo-image/ios/ImageModule.swift`, `generatePlaceholder(source:onFailure:generator:)`: `let downloader = SDWebImageDownloader()` then `downloader.downloadImage(with:…)`. In SDWebImage, `-[SDWebImageDownloader init]` creates an `NSURLSession` with the downloader as its delegate, a `URLSession` keeps a strong reference to its delegate until it's invalidated, and the downloader only invalidates it in `dealloc` (or `invalidateSessionAndCancel:`, which isn't called). Without `SDWebImageDownloaderUseNSURLCache`, requests use `NSURLRequestReloadIgnoringLocalCacheData`.
- **How to reproduce:** Found by reading the code. Call `generateBlurhashAsync` for the same url several times while counting the server's requests; for the sessions, look for `SDWebImageDownloader` instances in Xcode's memory graph after the calls finish.

### Android: with excludeAppGlideModule, two of Expo Image's Android fixes don't apply

- **What happens:** an app that sets `excludeAppGlideModule` (because it has its own Glide `AppGlideModule`) loses two things Expo Image sets up in its own module: GIFs decode with APNG4Android's GIF decoder again, which Expo Image's module avoids because it "can crash on small interlaced frames", and a url whose response wasn't an image (e.g. a Wi-Fi login page sent with status 200) stays failed until the disk cache is cleared, which 58.0.0 fixed with `ExpoImageDiskCache` (expo/expo#48442).
- **Where:** `packages/expo-image/android/build.gradle` leaves out `ExpoImageAppGlideModule.kt` when `excludeAppGlideModule` is set. That file is the only place that prepends Glide's `StreamGifDecoder`/`ByteBufferGifDecoder` (`registerComponents`) and installs `ExpoImageDiskCache` (`applyOptions`). The decoders could also be registered from a `LibraryGlideModule` such as `okhttp/ExpoImageOkHttpClientGlideModule.kt`, which Glide still runs with the app's own module; the disk cache can only be set in an `AppGlideModule`.
- **How to reproduce:** Found by reading the code. In an app with its own `AppGlideModule` and `excludeAppGlideModule = true`, load a url that first returns HTML with status 200 and then the image; it keeps failing until `Image.clearDiskCache()`.

### Android: cover images are decoded larger than the view

- **What happens:** with `contentFit="cover"` (the default), an image whose aspect ratio differs from the view's is decoded at the size that covers the view and isn't cropped, so the bitmap is larger than the view by the ratio of the two aspect ratios: 1.33 times the view's pixels for a 4:3 photo in a square view, 4 times for a 4:1 panorama (a 300 × 300 px view holds a 1200 × 300 bitmap, 1.4 MB instead of 0.36 MB). Glide's memory cache keeps that larger bitmap too. Keeping the whole image lets `contentPosition` change without decoding again.
- **Where:** `packages/expo-image/android/src/main/java/expo/modules/image/CustomDownsampleStrategy.kt`, `ContentFitDownsampleStrategy.calculateScaleFactor()` uses `max(requestedWidth / sourceWidth, requestedHeight / sourceHeight)` for `Cover`, and `ExpoImageViewWrapper.rerenderIfNeeded()` adds no crop transformation; `ExpoImageView.applyTransformationMatrix()` positions the whole bitmap and the view clips it.
- **How to reproduce:** Found by reading the code. Show a 4000 × 1000 image with `contentFit="cover"` in a 100 dp square view and read the size of the view's bitmap (e.g. `(drawable as BitmapDrawable).bitmap` in a debugger).

### Android: views showing the same GIF may share one animation (possible)

- **What happens (possible, not confirmed):** two views that get the same Glide resource for a GIF (loads of the same url at the same size and options that run at the same time, or a memory cache hit with `cachePolicy` `'memory'` or `'memory-disk'`) may share one animation: they'd advance in step, and a view stopped with `stopAnimating()` or `autoplay={false}` could show the other view's frames when it's redrawn.
- **Where:** `packages/expo-image/android/src/main/java/expo/modules/image/ExpoImageAppGlideModule.kt` makes GIFs decode to Glide's `GifDrawable`. In Glide (internals, not checked here), a resource handed to several requests gives each a `GifDrawable` from the same `ConstantState`, which shares one `GifFrameLoader`, and `stop()` only unsubscribes that drawable from it. `ExpoImageViewWrapper.setIsAnimating()` and `onResourceReady()` call `start()`/`stop()` on the view's drawable.
- **How to reproduce:** Not run. What would confirm it: mount two views of the same size with the same GIF url at once, call `stopAnimating()` on one, and check whether it changes frames when it's redrawn (e.g. on scroll), or whether both views' drawables have the same `constantState` in a debugger; then again with `cachePolicy="memory-disk"` and the second view mounted after the first loaded.
