# shots-studio: an Android screenshot manager with on-device AI

> shots-studio is a Flutter application for Android that treats the screenshot folder as an archive you can search. It finds screenshots by the text, objects, and topics inside them, suggests tags with a language model, and groups them into collections. The model can run on the device with Gemma, or in the cloud with Gemini, and the choice is the privacy decision.

**AnsahMohammad/shots-studio** — An AI Powered Screenshot manager for Android

- Repository: https://github.com/AnsahMohammad/shots-studio
- Website: https://ansahmohammad.github.io/shots-studio/
- Stars: 690 · Forks: 48
- Language: Dart
- License: GPL-3.0
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/ansahmohammad-shots-studio

## Searching a gallery by what is inside it

shots-studio is a screenshot manager whose purpose is to declutter the gallery, and the pitch is stated as a problem first: drowning in screenshots you cannot find when you need them.

The answer it gives is search by content rather than by file name, and that single difference is the whole product. A phone's screenshot folder is full of images whose names are timestamps, so the only index a file manager can build is a date, and the practical consequence is that people stop looking and start scrolling. An index that knows a screenshot contains a receipt, or a particular error message, or a particular app's interface is a different kind of index.

The readme describes what the search can match on as text, objects, or topics that the screenshot contains, and notes that it works even for images that were never labelled. That last point matters, because the value of content search is largest on the screenshots nobody tagged.

The other two features follow from the same idea. Tags can be suggested by the model or added by hand, which is what makes the archive navigable once the search has found something, and collections group related screenshots for quick navigation, which is the difference between a pile and a set.

The application is Android only, built with Flutter, licensed under the GPL, and the last push was on 2026-04-14. The release history shows a dense version line, with v1.9.100 in March 2026 and v1.9.92 in February, plus a beta tagged build in January, so the project is iterating on the details rather than the shape.

It is distributed in all three of the usual ways, which is a sign of a project that wants to be installable without a store account: as a release artefact from the repository, in the Play Store under the package name shown in the badge, and on F-Droid.

## Two model choices, and the switch between them

The application offers a choice of models, and the readme frames it as one decision about where the work happens.

The on-device option is Gemma, described as private, offline, and instant. The cloud options are Gemini 2.0 Flash for speed and Gemini 2.5 Pro for deeper analysis. The claim attached to the on-device path is that screenshots are processed without an internet connection, which the readme ties to two properties, speed and privacy, since a request that never leaves the phone never waits for a network round trip and never hands the image to anyone else.

The privacy section states the default plainly, and it is the line to read before using the app on anything personal. By default, the application can send screenshot data to Google's Gemini API for cloud powered analysis. Switching to the on-device model is what makes the no data leaves the device claim true. The Gemini API terms are linked for the cloud path.

That default is defensible for a project that wants people to try the app and see it work without setting up a model download first, and it is also the kind of default that a careful user should change. A screenshot gallery is unusually rich in content that people would not paste into a chat window, and the app has no reason to send it anywhere.

The practical sequence is short. Cloud analysis needs an API key from the Gemini service, and the offline path needs no key at all, because the model runs locally and is enabled in the settings. The on-device model is the one with a storage cost, since a language model has to be downloaded before it can run.

The readme also frames the choice in terms of what you are optimising for. Faster results come from the local model, deeper analysis comes from the larger cloud one, and the offline path is the one that keeps working on a train.

## Getting it installed and the permissions it wants

The setup is four steps, and they are ordered the way you would actually do them.

The first is the mode. For cloud analysis you get an API key, and for offline analysis you switch on the on-device model in the settings, which needs no key.

The second is the install. The application is a standard Android package, so you download the APK from the releases page or from F-Droid and install it, and the Play Store copy is the same application for people who would rather not sideload.

The third step is the one that will make the app appear to do nothing if you skip it. The application needs storage access in order to scan and process the screenshots, and without that permission it has an empty gallery to work with.

The fourth step is the actual work. There is an AI button, and tapping it analyses the screenshots and adds the tags automatically, which is the batch operation that makes the archive useful in the first place.

The distinction between the last two steps is worth holding on to, because it is the difference between the index existing and the index being built. Permission to read the folder is a one time decision, and the button is a job you run over the collection, and until the job has run there is nothing to search.

The user interface is the reason the button is marked with a lightning symbol rather than a label, which is a small reminder that the tool is aiming at the phone gallery rather than at a professional workflow, and the whole design is in that direction. There is no plugin system, no batch script, and no headless mode, because the use case is a person scrolling through a screenshot folder on a phone.

## The repository, with a legacy directory and a roadmap

The top level of the repository is small enough to describe, and two entries in it tell you about the project's history.

There is the application directory, which holds the Flutter code, and a metadata directory, which is where the app description and the store listings live. There is a scripts directory, which holds the git hooks, and a docs directory with the assets used in the readme.

The entry that stands out is a directory named legacy. Its presence tells you the application was rewritten or restructured at some point and the older code was kept rather than deleted, which is a common and defensible choice in a project with a lot of contributors, and one that also means a reader who wants to know how the current version works should start from the application directory and ignore the rest.

There is a roadmap file at the root, which is a good sign for a project that wants contributors, since it says what is planned rather than leaving the direction implicit.

The rest is the standard set: the readme, the licence, the contributing guide, a GitHub directory with the workflows including a build check, a GitLab pipeline file next to it, and a gitignore.

The build check badge in the readme is worth noting, because it means the Android build is verified on every change, and the presence of a GitLab pipeline next to the GitHub workflows suggests the project is kept buildable on two forges.

The readme also points at a discussions page rather than only the issue tracker, and the downloads badge counts the release downloads, so the project is measuring how many people actually install it.

## Contributing, and the hook that checks your work

The contributing section is short and has one instruction that is worth repeating because it is unusual. Before working on a fix, open an issue or add a comment under one and tag the maintainer to discuss.

That is a maintainer asking for a conversation before the code, which is a reasonable thing for a project where the visual design of a phone app is a large part of the work and where a patch that changes the look is not obviously a patch that improves things.

The contributing guide file is the place for the details, and the invitation covers code, features, bug fixes, and documentation.

The last section of the readme is about git hooks, and it is the kind of detail that saves a contributor a failed check later. The repository keeps its hooks in a directory rather than in the git hooks folder, and one command points git at it.

```bash
git config core.hooksPath scripts/git-hooks
```

Running it once after cloning is enough, and the project-specific hooks then run on commit. The reason for the pattern is that the hooks live in the repository, so they are versioned, reviewable, and updated when the project updates them, rather than being a set of local scripts that each contributor has to install by hand.

The contributor list in the readme names two people, and the project describes itself as community built and fully open source, with the licence making that legally meaningful for anyone who wants to fork it.

## Conclusion

shots-studio fits an Android user whose gallery is mostly screenshots and who wants to find a picture of a receipt or a code fragment from six months ago by describing it rather than by remembering a filename. It does not fit someone who wants their screenshots indexed by a third party service, because the default configuration sends screenshot data to the Gemini API, and it does not fit a user with too little storage for a language model. Verify first which mode you are running in before you import a screen full of private content, that the Gemma model is actually downloaded and enabled in the settings if you intend to work offline, and that the storage permission you grant is the one the app needs to scan the screenshot directory in the first place.

## FAQ

### What does shots-studio do with my screenshots?

It indexes them so you can find them by what they contain rather than by file name, suggests tags with a language model, and groups them into collections. The search matches on text, objects, and topics, and works on screenshots that were never labelled by hand.

### Does shots-studio send my screenshots to a server?

By default it can, because the default configuration sends screenshot data to the Gemini API for cloud analysis. Switching to the on-device Gemma model in the settings is what makes the data stay on the phone, and that path needs no API key and works without an internet connection.

### How do I install shots-studio?

As an Android application, from the release artefacts in the repository, from F-Droid, or from the Play Store. You then have to grant storage access so the app can scan and process the screenshots, and finally run the analysis from the AI button to build the index.

### What does the on-device Gemma model cost me?

Storage, and the download itself. A language model has to be fetched before it can run locally, which is why the offline path is the one with a setup cost while the cloud path only needs an API key. The offline path then needs no network at all, and the readme ties that to both speed and privacy.

### How do I contribute to shots-studio?

Open an issue or comment on one and tag the maintainer to discuss before writing the fix, then follow the contributing guide, which covers code, features, bug fixes, and documentation. The repository also keeps its git hooks in a directory, and one configuration command points git at them after you clone.

## Sources

- [AnsahMohammad/shots-studio on GitHub](https://github.com/AnsahMohammad/shots-studio)
- [License: GPL-3.0](https://github.com/AnsahMohammad/shots-studio/blob/main/LICENSE)
- [Project website](https://ansahmohammad.github.io/shots-studio/)
- [README](https://github.com/AnsahMohammad/shots-studio/blob/main/README.md)
- [Releases](https://github.com/AnsahMohammad/shots-studio/releases)

---

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