# glide on Android: three dependency paths, an API 14 floor, and no zoom on huge images

> glide is a Java image loading and caching library for Android, consumed as a Gradle or Maven dependency or as a jar from the releases page. It is a good fit for scrolling lists of images and for ordinary remote thumbnails, and it is explicit about where it stops: huge images downsample but will not zoom or pan, round image views collide with crossFade transitions, and the support floor sits at API 14 while the compile target is API 26.

**bumptech/glide** — An image loading and caching library for Android focused on smooth scrolling

- Repository: https://github.com/bumptech/glide
- Website: https://bumptech.github.io/glide/
- Stars: 35,022 · Forks: 6,174
- Language: Java
- License: NOASSERTION
- Published: 2026-08-17 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/bumptech-glide

## Three ways to add the library, and each one makes you type the version

There are three acquisition routes and none of them resolves a version for you. A jar can be downloaded from the releases page, or you can declare the dependency in Gradle, which needs both the google() and mavenCentral() repositories to be present:

```gradle
repositories {
  google()
  mavenCentral()
}

dependencies {
  implementation 'com.github.bumptech.glide:glide:5.0.9'
}
```

The Maven route carries the same three facts in XML form:

```xml
<dependency>
  <groupId>com.github.bumptech.glide</groupId>
  <artifactId>glide</artifactId>
  <version>5.0.9</version>
</dependency>
```

The practical consequence is that the version lives in your build file, where it stays until you edit it. There is no version catalog, no BOM and no dynamic range in the page, so a security or correctness fix in Glide reaches you only when someone on your side changes a string. The page does point at a snapshots page for the bleeding edge, which is a deliberate opt-in to unreleased code rather than a default.

## A floor of API 14, a compile target of API 26, and an unmaintained v3 as the only way back

The compatibility section states two numbers in the same style, and they pull in opposite directions. Glide v4 requires a minimum API level of 14, and it requires you to compile against API 26 or later. So the library will load on an old device, but your build has to target a recent platform to consume it, and a project holding minSdk at 14 while compiling against a current SDK has to keep the older floor from raising itself. The page offers one retreat for anyone who needs to support older Android versions: stay on Glide v3, which works on API 10. It says plainly that v3 is not actively maintained. That is the only stated escape hatch, and taking it means accepting a branch with no further fixes rather than a supported older version of the same library.

## Huge images downsample, and zooming and panning are simply not supported

This is the clearest limit in the whole page. Glide can load huge images by downsampling them, which is what makes map tiles and long comic strips display at all instead of failing. What it does not do is support zooming and panning inside an ImageView, because those gestures require special resource optimizations such as tiling in order to work without OutOfMemoryErrors. So the capability stops exactly where the user expects it to continue. A map screen that has to be pinch-zoomable, or a comic reader with pan and zoom gestures, gets a correct first render and dead gestures. The workarounds live outside the library, in a tiled image source or a custom view, and the page does not document a Glide configuration that supplies either. If zoom is a requirement of the feature, the image library is not the layer where that gets solved.

## CircleImageView and TransitionDrawable do not get along, and the fix is stated as future tense

Three popular round-image views, CircleImageView, CircularImageView and RoundedImageView, are called out by name as having known issues with TransitionDrawable, which is what .crossFade() combined with .thumbnail() or .placeholder() produces, and with animated GIFs. The page names two ways out: apply a BitmapTransformation, or drop the animation with .dontAnimate(). Both have a cost worth understanding before you pick. A BitmapTransformation changes the pixels, so it is work in the decode path on every image, which sits in tension with the library's stated goal of smooth list scrolling. .dontAnimate() removes the transition entirely, which is a visible product change rather than a tuning knob. The page also says that .circleCrop() will be available in v4, a forward-looking remark left in place while the published artifacts are 5.0.9, so treat that particular fix as something you confirm in the javadocs rather than assume.

## The R8 and ProGuard rules already ship inside the aar

Glide handles shrinking for you, at least for the common case. The specific rules are already bundled into the aar and can be interpreted by R8 automatically, living in library/proguard-rules.txt inside the library module. That removes the most common integration failure, where a reflection-based library loses its callbacks under shrinking and the image never arrives. The trade is that the rules are not opt-in. They apply whether or not you have looked at them, so a build that behaves differently under minification is a build you are debugging against rules you did not write and have not read. The page does not enumerate which classes those rules cover, so if you need to reason about a specific keep decision you have to read library/proguard-rules.txt in the repository and check the javadocs rather than looking for a summary here.

## The Status section still says Version 4 while the artifacts are 5.0.9

The narrative status line and the release artifacts disagree. The Status section says that Version 4 is now released and stable and that updates are released periodically with new features and bug fixes, while both dependency snippets above declare 5.0.9, and the compatibility numbers are given in terms of Glide v4. The release list also holds three tags for two versions, with v5.0.9 and a stray v.5.0.9 carrying a dot after the v, all dated 2026-07-11, and the last push to master is dated 2026-09-26. None of that means anything is broken, but it means you cannot use the prose to work out which line you are adopting. Read the version in the dependency you already have, check the tags before pinning to one, and treat the two compatibility numbers as a statement about the v4 line rather than a guarantee printed for the current release.

## The build is ./gradlew jar, and two sample modules have no documented run command

Building from source is three commands, and the page adds a prerequisite that is easy to miss: your Android SDK needs the Android Support Repository installed, and $ANDROID_HOME has to point at the SDK, or you add a local.properties file in the root project with a sdk.dir line.

```shell
git clone https://github.com/bumptech/glide.git
cd glide
./gradlew jar
```

The samples section then lists four launch commands, after telling you to follow the build steps first:

```shell
./gradlew :samples:flickr:run
./gradlew :samples:giphy:run
./gradlew :samples:svg:run
./gradlew :samples:contacturi:run
```

The repository also contains a samples/gallery directory and a samples/imgur directory, and neither has a command shown here. If you want to see how a specific image source is wired, you are left guessing the module path, and the same applies to the IDE route, where the page says to open the root directory and select setting.gradle while the root of the repository carries settings.gradle.kts. Both are small, and both cost a newcomer a wrong turn on first contact with a project that otherwise gets you running quickly.

## Every pull request is gated on signing a Google contributor agreement

The contribution path has a legal step in front of the code review. Before submitting pull requests, contributors must sign Google's individual contributor license agreement, and the page links that document directly. There is no alternative route stated, so a fix you have already written and tested cannot be sent as a patch until the agreement is in place. Budget for that, because it is the step most likely to end an otherwise finished contribution, and it applies to a typo fix as much as to a new decoder. The repository root is set up for the process, with CONTRIBUTING.md, ISSUE_TEMPLATE.md and PULL_REQUEST_TEMPLATE.md alongside the code, so the expectations are written down, and questions and pull requests are both described as welcome. The project is maintained by Sam Judd and the page states that it is not an official Google product, which is worth keeping in mind when the agreement points at Google.

## Conclusion

Use it when the work is fetching, decoding, caching and recycling images for lists and detail screens, and you are content to stay on one declared version. Do not reach for it when the product needs a tiled map or a pinch-zoomable comic strip, or when you need a contribution path that does not involve signing a contributor agreement. Before you upgrade, check which version the compatibility numbers in the page refer to, since the prose still talks about v4 while the published artifacts are 5.0.9.

## FAQ

### what is glide

Glide is an open source media management and image loading framework for Android, written in Java. It wraps media decoding, memory and disk caching, and resource pooling, and it fetches, decodes and displays video stills, images and animated GIFs. Its primary focus is making scrolling a list of images smooth.

### is glide free

The page describes Glide as an open source project and states the license as BSD, part MIT and Apache 2.0, with details in the LICENSE file. It also states that Glide is not an official Google product.

### how to install glide client

Glide is a library rather than a client, so it is added as a dependency rather than installed. You declare com.github.bumptech.glide:glide:5.0.9 in Gradle or the matching groupId, artifactId and version in Maven, or download a jar from the releases page.

### what is glide app

There is no application here. The repository contains an Android library, its samples, and a benchmark module, and the page adds that Glide is not an official Google product. The sample projects are run from a checkout with gradle commands such as ./gradlew :samples:flickr:run.

## Sources

- [Official documentation](https://bumptech.github.io/glide/)
- [Official README](https://github.com/bumptech/glide#readme)
- [Project repository](https://github.com/bumptech/glide)
- [Release notes](https://github.com/bumptech/glide/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/bumptech-glide