# saket/telephoto for Zoomable Media in Jetpack Compose

> saket/telephoto is a Kotlin library for Compose media interactions, including zoomable images, gesture modifiers, large-image subsampling, and transient peek overlays. It fits Android teams that need focused UI behavior, but its public dependency setup and detailed API contract must be checked on the project website.

**saket/telephoto** — Building blocks for designing media experiences in Compose UI

- Repository: https://github.com/saket/telephoto
- Website: https://saket.github.io/telephoto/
- Stars: 1,572 · Forks: 60
- Language: Kotlin
- License: Apache-2.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/saket-telephoto

## Telephoto's Scope for Compose Media Experiences

saket/telephoto addresses a specific Android UI problem: giving media composables interactive viewing behavior without building every gesture and display concern from scratch. The README describes the project as building blocks for designing media experiences in Compose UI. That wording sets a useful boundary. Telephoto is a UI interaction library, not an image loader, media player, downloader, or storage service.

The primary audience is Kotlin developers building Android applications with Compose. The repository metadata identifies Android, Compose, image, subsampling, and zoom as topics. The README names three visible capabilities: a zoomable image, a standalone zoomable modifier, and a transient zoom overlay. These features address different parts of an interface. A persistent image viewer needs pan and zoom, a video surface may need the same gesture layer without using an image composable, and a feed interaction may need a short-lived overlay.

The project is therefore most relevant when the product requirement is about presenting media after an application has obtained and rendered it. The README does not describe network loading, caching, image decoding, thumbnail generation, video decoding, playback, or persistence. It is reasonable to expect those concerns to remain with the application or another dependency, but the exact division of responsibility should be verified against the linked API documentation.

## ZoomableImage and Memory-Aware Image Display

`ZoomableImage` is the component intended to replace a normal Compose `Image()` in an interactive media view. According to the README, it supports pan and zoom gestures and performs automatic subsampling for large images that would otherwise not fit into memory. The important distinction is that this is display-oriented behavior. Subsampling is presented as a response to rendering a large source within limited memory, not as a claim that Telephoto compresses files or changes the original image asset.

This component addresses two problems at once. It provides the familiar interaction of moving across and magnifying visual content, and it aims to keep very large images displayable when a full-resolution bitmap would be impractical. That combination matters for galleries, image details, and media-heavy Compose screens. It also means that integration is not merely a gesture modifier. The application still has to provide a suitable image source and must account for loading, failure, and placeholder states that are not described in the README.

The API documentation is necessary to determine how those responsibilities are assigned. The README does not state whether the component accepts a painter, bitmap, URI, or another input. It also does not describe the subsampling algorithm, decode dimensions, cache ownership, or behavior when the image exceeds a particular size threshold. Those implementation details should be checked before relying on memory behavior for a specific device class or image format. The README supports the capability claim, but not a detailed performance guarantee.

## Modifier.zoomable for Videos and Custom Media

`Modifier.zoomable()` packages the gesture detector from `ZoomableImage` as a standalone Compose modifier. The README explicitly says it can be used with videos and other non-image composables. This separation is the clearest architectural feature in the project. Telephoto can supply interaction behavior to content that its image component does not render directly.

For a video surface, the application remains responsible for whatever rendering and playback mechanism it uses. The modifier supplies pan and zoom behavior, not a player. The same separation applies to custom composables, diagrams, or other visual containers. This can be useful when an application already has a media presentation layer and only needs a shared interaction pattern. It also avoids forcing every interactive surface to be implemented as `ZoomableImage`.

The README does not document gesture arbitration with parent scroll containers, nested zoom, double-tap behavior, animation state, transform origins, accessibility semantics, or cancellation when the underlying content changes. It also does not state how the modifier should be coordinated with video controls. Those are integration questions rather than missing product goals, but they can determine whether the modifier behaves correctly in a real screen. The linked Zoomable documentation should be consulted for the current modifier signatures and composition rules.

## Zoomable Peek Overlay for Temporary Inspection

The Zoomable Peek Overlay provides a third, more specialized interaction. The README calls it a transient, overlaid zoom effect inspired by Instagram. Its intended lifecycle differs from a persistent viewer: the content appears temporarily over the surrounding interface and then disappears. That pattern can fit image inspection from a list or feed, where opening a full screen would interrupt the current browsing flow.

The separate `zoomable-peek-overlay` entry in the repository layout indicates that this is not just a parameter on the main image component. The repository also contains `zoomable-image` and `zoomable`, matching the three interaction areas named in the README. Separating these concerns allows an application to choose a persistent viewer, a reusable gesture layer, or a transient overlay without treating them as interchangeable widgets.

The README does not specify the overlay's trigger model, animation duration, dismissal behavior, backdrop policy, or accessibility semantics. The Instagram reference describes the visual inspiration, not a compatibility claim. A team using the overlay should verify whether the component owns its transient state, whether it composes correctly with navigation and back handling, and how it exposes actions to accessibility services. Those details are project-specific and should not be inferred from the word overlay.

## Telephoto Installation Starts With Project Documentation

The README does not include a Gradle coordinate, dependency declaration, repository setup, minimum Android API, Kotlin requirement, or Compose version. It directs readers to the official project website at https://saket.github.io/telephoto for full documentation. The repository contains build infrastructure such as `settings.gradle.kts`, a root `build.gradle`, and Gradle wrapper files, but those are repository development files and do not establish the public consumer installation command.

The project homepage is the documented starting point for installation: https://saket.github.io/telephoto.

The reader should open that page, select the relevant component documentation, and copy the current dependency configuration exactly as published there. The reader should then confirm that the published artifact matches the app's Kotlin and Compose versions before adding it to a build file.

The same documentation gap affects a first-use example. The README names `ZoomableImage`, `Modifier.zoomable()`, and Zoomable Peek Overlay, but it does not show imports, required props, image input types, or a complete composable. A first implementation should begin with the current API page rather than with an assumed `Image()` overload. Confirming the artifact and a minimal screen together is safer than copying an outdated third-party snippet that may not match `0.19.0`.

## Release History, Licensing, and Upgrade Checks

Telephoto is not archived. The last recorded push was on 2026-07-22. The recent release list includes `0.19.0` on 2026-04-02, `0.18.0` on 2025-10-04, and `0.17.0` on 2025-09-15. These records provide dated project activity, but the README does not define a maintenance policy, support window, or compatibility matrix.

The project uses Apache-2.0. Its README includes the Apache License, Version 2.0 notice, and the repository includes `license.txt`. The license identifies the terms under which the software may be used, copied, and modified, subject to the conditions stated in that text. This review does not interpret the license or provide legal advice. Distribution processes should still account for the applicable notices and any licenses belonging to separately used dependencies.

Upgrade cost should be evaluated at the API and build-system level. Telephoto consists of Compose composables and modifiers, so changes in Kotlin, Compose, or Android tooling may affect integration independently of the library release. The repository metadata does not establish whether the API remained compatible across the listed releases. Before changing versions, inspect the release notes, current documentation, and sample or test code for renamed parameters, changed overloads, and minimum toolchain requirements.

## Choosing Telephoto Instead of a Media Pipeline Library

Telephoto is the wrong choice when the main problem is obtaining or managing media rather than displaying it interactively. The README does not claim responsibility for HTTP image loading, disk caching, request cancellation, thumbnail generation, image encoding, server processing, or video playback. An application needing those capabilities needs an application-owned pipeline or a library whose documented scope includes them.

It may also be the wrong choice for teams that require a fixed installation recipe and complete API documentation without consulting external project pages. The README is concise and points to the website, but it does not provide the dependency coordinate or a copy-ready first-use example. That documentation gap is a practical adoption constraint for teams that need reproducible onboarding across multiple environments.

Telephoto focuses on Compose UI interaction rather than general image processing. Its releases document multiplatform support for parts of the API, including iOS and web targets for Modifier.zoomable; check the component and target compatibility for the version you use. The appropriate comparison is therefore not with an image loader or video player by name, but by boundary. If the application already owns media acquisition and rendering, Telephoto may supply the missing interaction layer. If those are the missing pieces, the README does not justify selecting Telephoto.

## Conclusion

Compose developers should evaluate Telephoto when they need focused pan, zoom, and large-image display behavior and are willing to verify its current API. Developers who need a documented dependency recipe, video playback, image loading, or a complete media pipeline should not treat it as that solution. The first check is whether the current project documentation provides an artifact compatible with the app's Kotlin, Compose, and Android versions.

## FAQ

### What is saket/telephoto used for?

It provides Compose UI building blocks for media experiences, including a zoomable image, a standalone pan-and-zoom modifier, and a transient zoom overlay. The README specifically mentions automatic subsampling for large images.

### Can Telephoto be used with videos?

The README says `Modifier.zoomable()` can be used with videos and other non-image composables. It describes the modifier as a gesture detector and does not document video playback or decoding as part of Telephoto.

### How do I install Telephoto?

The README does not provide a Gradle coordinate or dependency setup. It directs readers to the official project website for full documentation, so the public artifact and compatibility requirements must be checked there.

### What license does Telephoto use?

Telephoto uses Apache-2.0. The repository includes the Apache License notice in the README and a `license.txt` file.

## Sources

- [License: Apache-2.0](https://github.com/saket/telephoto/blob/trunk/LICENSE)
- [Project website](https://saket.github.io/telephoto/)
- [README](https://github.com/saket/telephoto/blob/trunk/README.md)
- [Releases](https://github.com/saket/telephoto/releases)
- [saket/telephoto on GitHub](https://github.com/saket/telephoto)

---

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