I Got Tired of Making App Store Screenshots, So I Built an Open-Source Tool

Shipping an app is fun. Preparing the App Store screenshots? Not so much.

You finish building a feature, fix the last few bugs, and finally get your release ready. Then you open App Store Connect or Google Play Console and remember there's still another job to do: create a complete set of promotional screenshots.

Different device sizes. Different layouts. Titles and subtitles. Multiple languages. And every time you change something, you potentially have to export everything again.

I've been working on NimoteCode, a mobile IDE for Android and iOS, and this became one of those repetitive tasks I really didn't want to keep doing manually.

So I built NimoteShot, a free, open-source screenshot generator for App Store and Google Play listings.

GitHub: https://github.com/mobiledevloperlab/nimoteshot

The idea is straightforward: use AI to understand real app screenshots and help write the marketing copy, but keep the actual image generation deterministic, editable, and local.

The problem isn't taking screenshots

Taking a screenshot is easy.

Turning that screenshot into something suitable for an app listing is where the work starts.

A typical workflow looks something like this:

1. Capture the app on a real device or emulator.
2. Import the screenshot into a design tool.
3. Choose a background, device frame, and typography.
4. Write a short headline that explains the feature.
5. Adjust everything for different screen dimensions.
6. Translate the text and repeat the layout work.
7. Export the assets and check that they meet store requirements.

It's manageable for one release. It gets frustrating when you're maintaining multiple languages and shipping updates frequently.

I looked at this as a developer rather than a designer: most of the process follows a repeatable set of rules.

The parts that need judgment are understanding what a screen does, deciding which features matter, and writing good copy.

The rest should be something software can handle.

What NimoteShot does

NimoteShot takes real screenshots of your app and turns them into promotional images for iPhone, iPad, and Android listings.

You can give it your app name, a short description or website, and your original screenshots.

A vision-capable AI model can analyze the visible interface and draft headlines, subtitles, and a design direction.

You can then review everything in a browser-based editor, change the text or layout, and export the finished images.

Here's an example using NimoteCode.

Original app screenshot:

Generated promotional screenshot:

The important detail is that the actual app interface remains the source material.

I didn't want an image model inventing buttons, changing code in the editor, or producing a beautiful-looking interface that doesn't exist in the app.

AI should help explain the product, not fabricate it.

AI for decisions, local code for rendering

This is probably the most important design decision in NimoteShot.

I separated the process into two responsibilities.

AI handles interpretation and copywriting.

A vision model examines the screenshots and product context, then helps draft the feature descriptions and visual direction.

The local rendering engine handles the final images.

It applies the selected templates, typography, backgrounds, layouts, and output dimensions.

That separation makes a surprisingly big difference.

Imagine you've generated six promotional screenshots and notice that the headline on the third one is too long.

With a fully generative approach, you might need to ask the model to generate that image again, potentially changing other visual details in the process.

With NimoteShot, you edit the headline directly.

The affected preview is rendered locally. No additional AI request is needed.

You can also adjust the colors, templates, and order of the screens without rerunning the entire analysis.

I wanted something closer to an editable design tool than a one-click AI image generator.

Localization shouldn't mean rebuilding everything

Another part I wanted to improve was localization.

NimoteShot currently supports 17 output languages, including English, Chinese, Japanese, Korean, Spanish, French, German, Portuguese, Hindi, Arabic, and others.

Each language can have its own editable copy.

That matters because localization is not simply replacing one string with another.

A short English headline might become much longer in German. Chinese and Japanese have different typography requirements. Arabic and Hebrew need appropriate text shaping.

NimoteShot uses bundled fonts selected according to character coverage, with complex-script shaping support where the required dependencies are available.

The goal is to keep the workflow consistent across languages while still allowing developers to review and refine every translation.

AI-generated text is a starting point, not something that should go straight into production without review.

You can use it without AI

Although NimoteShot has AI in its name, I didn't want an API key to be mandatory.

There's a manual design mode that works without a model.

You can upload your screenshots, select a design, edit the text, preview the result, and export the images locally.

If you want AI assistance, you can configure a supported vision-capable provider.

The project supports several provider integrations, including DeepSeek, Qwen, Gemini, Claude, OpenAI-compatible APIs, Ollama, and others, subject to the capabilities of the selected model.

The software itself is free and open source. Cloud model providers may charge for their API usage.

One privacy distinction is worth making: rendering and exporting happen locally, but AI screenshot analysis sends the selected captures and product context to the configured model provider. If you need to keep everything local, use manual design or a compatible locally hosted model.

Getting started

NimoteShot runs on Windows, macOS, and Linux, with Python 3.11 or newer.

Clone the repository:

git clone https://github.com/mobiledevloperlab/nimoteshot.git
cd nimoteshot

On macOS or Linux:

./install.sh

On Windows, run this in PowerShell:

powershell -ExecutionPolicy Bypass -File .\install.ps1

The installer creates a Python virtual environment, installs dependencies, and starts the local web studio.

By default, the interface is available at:

http://127.0.0.1:8765

Use the URL printed by the installer if it chooses another port.

From there, the workflow is:

1. Enter your app's name and product description.
2. Upload your real screenshots.
3. Select the target devices and languages.
4. Choose AI-assisted generation or manual design.
5. Review and edit the previews.
6. Export the PNG files or download a ZIP package.

The exported assets include the selected device resolutions, and the task configuration can be kept for later edits.

For developers who prefer automation, there's also a CLI.

For example, after configuring a compatible provider:

.venv/bin/python scripts/nimoteshot.py generate \
  --brand "My App" \
  --description "A mobile editor with SSH, Git and terminal tools" \
  --provider qwen \
  --style editorial \
  --locales zh-CN,fr-FR,ja-JP

I like having both options: a visual workflow when I want to refine the design and a command-line workflow when I want something more repeatable.

A few implementation details

NimoteShot is built with Python and includes a local web editor, AI-provider integrations, and an image-rendering pipeline.

Some of the less visible features are the ones I find most useful:

• Incremental previews: Editing one screen doesn't require regenerating every other screen.
• Stale-response protection: Older preview results are prevented from replacing newer edits.
• Editable configurations: You can return to a saved task rather than starting over.
• Multi-resolution exports: The renderer produces PNGs for supported device and orientation targets.
• Source traceability: Original captures are archived with a SHA-256 source manifest.

These aren't particularly flashy features, but they make the difference between a demo and a tool that's practical to use during a release.

The current project also includes automated tests covering editing, previews, language switching, and exports.

What it doesn't try to do

NimoteShot isn't intended to replace a professional designer or make every creative decision automatically.

You still need to choose which features deserve attention, review the generated copy, and check the exported images before submitting them to the stores.

It also doesn't guarantee that every possible Apple or Google Play listing requirement will remain unchanged. Store specifications evolve, so the final submission should always be reviewed against the current requirements.

What it does try to eliminate is the repetitive work between having real screenshots and preparing usable promotional assets.

And for me, that's already valuable.

Open source, and I'd love feedback

NimoteShot is available on GitHub under AGPL-3.0-or-later.

It's still a growing project, and I'd particularly appreciate feedback from developers who publish apps in multiple languages or maintain both Android and iOS releases.

I'm interested in hearing:

• Which part of preparing store screenshots takes you the most time?
• Would you rather use a browser editor or automate screenshot generation through a CLI?
• What would make this useful enough to include in your release workflow?

If you want to try it, here's the repository:

NimoteShot on GitHub

Issues, bug reports, design suggestions, and pull requests are welcome.

And if the project saves you some time before your next app release, that's exactly why I built it.

---

Built while working on NimoteCode, my mobile development IDE. The screenshots in this post come from the open-source NimoteShot repository and its NimoteCode demo.