Windows desktop app · runs on your machine

Turn a screenshot into working code.

Drop in a screenshot, a set of screens, a URL, a description or a screen recording. shot2code generates a working page, then you refine it by saying what to change.

Installer .exe recommended. Bring a GitHub Copilot sign-in or one API key.

latest Windows 10/11 · x64 Unpacks about 600 MB
The shot2code workspace at 1920 by 1080: an icon rail with Chat, History, New, Shortcuts and Settings, two generated model options in the conversation panel, and a 1366-pixel desktop preview centered on a neutral backdrop with Fit, 100 percent and History controls.
The generated page stays centered and readable while Chat, History and the complete editable project remain one action away.
  • 12 output stacks
  • Local SQLite project history
  • No telemetry

Generated code is model output: review it before running it outside the sandboxed preview. The published Windows binaries are not code-signed, so Windows SmartScreen will warn on first run — verify the SHA-256 checksum instead.

A local workspace, not a web service.

Your screenshots, the generated code and your API keys stay on the machine you installed it on.

Start from what you already have

One screenshot, several related screens, a URL, a plain-text description, or a screen recording. With multiple screenshots you choose how they relate: separate pages, responsive views, UI states, or supporting references.

Edit it like a project

The Code tab is a multi-file project tree with an editor, file tabs, Entry, Preview, Read-only and Generated badges, and a whitespace-only Format action. Select an element in the preview and describe the change.

Size it the way you work

On wide windows, drag the divider between Chat and the preview, or between the file tree and the editor. Both are keyboard-operable separators, both remember your width across restarts, and both are clamped so neither side becomes unusable. A pane width is a view preference — resizing never creates or changes a version.

Keep your history on the device

Projects, versions and prompts live in a local SQLite database under %LOCALAPPDATA%\shot2code\. History steps back through every version, Recent projects picks up where you left off, and deleting a project removes it and its versions from the device.

Take the result with you

Export a self-contained single HTML file, or a Vite project folder for the stack you chose. Multi-file source projects are exported as they are rather than wrapped in an invented scaffold.

You still need a model provider. shot2code does not ship a model. A GitHub Copilot sign-in (no API key needed) or a Gemini, Anthropic or OpenAI key makes generation work; without one, the app tells you so instead of pretending to be connected.

What it looks like

The workspace in both themes and at three window sizes. Select any screenshot to open it at full resolution.

shot2code at 1920 by 1080: the rail labels Chat, History, New, Shortcuts and Settings; the conversation panel shows two generated model options and activity; the main workspace centers a 1366-pixel desktop preview with Desktop, Mobile and Code tabs, Fit and 100 percent controls, History 2 of 2, Select and edit, download and refresh actions.
The workspace at 1920×1080. The fixed-width preview is centred instead of pinned to one side, and Chat can collapse when the canvas needs the full window.
The shot2code Code workspace at 1920 by 1080 in the light theme: two generated model options appear in Chat, while index.html is formatted across 88 lines with Entry and Preview badges, Format, Copy, Download and CodePen actions, and a language and line-count status bar.
Light theme. Every generation becomes a version you can step back through in History, which records the model behind each option, and a retried version keeps a link to the version it re-rolls.
The shot2code Code workspace at 1440 by 900 in the dark theme: the rail, Chat, toolbar, file header and syntax-highlighted editor use coordinated dark surfaces while keeping the same History, model-option and file actions.
Dark theme. The editor highlights the active line and gutter and uses theme-correct surfaces, so the code stays legible in either theme.
The shot2code Chat workspace at 768 by 1024: the rail becomes a top bar, Preview and Chat are paired beside a separate History button, two generated model options are visible, and agent activity plus the update composer remain usable in one column.
Narrow windows. Preview, Chat and History remain separate, labelled destinations, and model options plus the update composer reflow without horizontal scrolling.

How a screenshot becomes a project

An agent loop with real tools, running from your machine against the provider you configured.

  1. 1

    Give it a reference

    Upload screenshots, paste a URL, describe the screen, or record it. Pick the output stack, and optionally tick the models you want to try — from GitHub Copilot, OpenAI, Anthropic or Google Gemini.

  2. 2

    It writes the files

    The model calls tools — create a file, edit a file, extract assets, render a screenshot preview — and shot2code executes them locally and feeds the results back.

  3. 3

    Compare and refine

    One option is generated per selected model, in parallel, so you pick the closest one. Then say what to change, or select an element in the preview and describe the edit.

  4. 4

    Keep or export it

    Every version is saved locally and reachable from History or Recent projects. Export a single HTML file or a Vite project folder when you are happy.

Generation streams over a local WebSocket from a bundled FastAPI backend; the desktop shell starts it on a free port. The only outbound traffic is to the model provider you chose, the update check, and anything you explicitly share.

What the app can do

What the app does today — and which capabilities need an extra key.

Inputs
Screenshots, multiple related screenshots, a URL, a text description, or a screen recording. Video input needs a Gemini key.
Model choice
Pick models from GitHub Copilot, OpenAI, Anthropic and Google Gemini in Settings or beside the composer. One option per selected model; tick nothing to leave it automatic.
Editing
Multi-file tree, file tabs, a collapsible explorer, select-and-edit from the preview, and a formatter that only ever changes whitespace and refuses component source.
Layout
On wide windows, drag or keyboard-move the dividers between Chat and the workspace, and between the file tree and the editor. Widths persist, clamp to the window, and stay a view preference — resizing never creates a version.
Startup
Core routes come up first; generation, evaluation and project tooling load on first use, and the Chromium and Copilot probes run in the background. The shell requires a genuine health response and gives up after 90 seconds rather than hanging.
Help
Ctrl+/ opens Get started, Guides, Support and the shortcut reference, linking these published guides. In the desktop app it also opens the backend log folder for a bug report.
Project history
A local SQLite database keeps projects, versions, prompts and retry ancestry, and records the model behind each option. Nothing is uploaded; deleting a project deletes it from disk.
Import
Point at a folder, ZIP or selected source files. The scanner parses text only — it never executes the project's configuration or code — then offers design context or an editable project.
Preview
A derived, self-contained artifact rendered in an opaque-origin sandbox with a restrictive Content-Security-Policy. At 100% a fixed-width canvas is centred in a neutral frame. When a build cannot be represented safely it shows a diagnostic instead of guessing.
Assets and images
Asset extraction reuses the real logos from your screenshot (Gemini key). Image generation, editing and background removal need a Replicate key set in backend/.env.

Keyboard-first

Ctrl+/ opens the Help centre, which carries the full shortcut reference. Ctrl+1–4 switch Preview, Code, Chat and History; Ctrl+3 again collapses the chat panel on wide windows. Project actions use Ctrl+Alt combinations — N new, I import, U upload, S settings, E export. Pane dividers take arrow keys, Shift for larger steps, Home/End and Enter to reset. In the desktop app, Ctrl+= and Ctrl+- zoom in fixed steps between 50% and 300%, and Ctrl+0 resets.

Sharing that asks first

CodePen is offered only when the selected stack can honestly run in a browser-only Pen, and it always asks before code leaves the device. For build-dependent projects, download the project folder instead.

Honest fallbacks

When export cannot find a valid root build command, it keeps every source file and adds a Safe fallback note rather than inventing a scaffold that looks plausible and breaks later.

Twelve output stacks

Each one has an explicit single-HTML and project-folder export strategy, so what you download actually builds.

  • HTML + Tailwind
  • HTML + CSS
  • React + Tailwind
  • Vue + Tailwind
  • Bootstrap
  • Ionic + Tailwind
  • Alpine.js + Tailwind
  • Preact + Tailwind
  • Tailwind + daisyUI
  • Bulma
  • Material 3
  • htmx + Tailwind

HTML and CDN projects export as a Vite project with a deterministic static copy, so inline modules and import maps are not silently reordered. React and Preact use Vite's framework build path when the generated source is safely transformable, and a documented Vite HTML fallback when it is not.

Bring your own model

One provider is enough — and whichever you bring, you choose which of its models actually run. Keys are stored on your device and sent only to the provider they belong to.

GitHub Copilot

The easiest option, because there is no API key to manage: run gh auth login (or copilot) once and shot2code picks the sign-in up. Needs an active Copilot subscription, and reaches Claude, GPT, Gemini and Grok models through it. The model list is discovered live from the signed-in account, so it is your plan's real entitlement.

Provider guide

Gemini, Anthropic, OpenAI

Paste an API key into Settings. It is kept on this device and sent with the generation request to that provider only. Each of these providers has a maintained, validated model list, so picking models for them contacts nobody. Gemini additionally powers video input and asset extraction.

Key setup

Replicate (optional)

Image generation, image editing and background removal. This one has no Settings field by design — it must be set as REPLICATE_API_KEY in backend/.env, which means it is only available when you run from source.

What needs which key

Choosing models is part of Settings, not a Copilot-only extra. Settings → Models — and the compact picker beside the composer — group every model you can currently use under GitHub Copilot, OpenAI, Anthropic and Google Gemini. Tick as many as you like, across providers, and each run produces one option per selected model, up to 4 for a first generation and 2 for an update or a video; tick nothing and the choice stays automatic. Models that cannot read the input you gave — video in particular — are filtered out rather than offered and failed, deprecated models stay hidden unless you ask for them or already picked one, and a saved model that can no longer run is reported and skipped instead of silently deleted. A provider only appears once the app can actually see a credential for it.

Recently improved

The most recent work went into starting fast, letting you set how the workspace splits its width, and putting the guides and the log you need inside the app.

It starts in seconds

Only the core routes have to be ready before the window opens — generation, evaluation and project tooling load on first use, and the Chromium and Copilot checks run in the background. The shell demands a real health response rather than any reply, gives up after 90 seconds instead of hanging, and logs how long readiness took.

A workspace you can resize

Drag the divider between Chat and the preview, or between the file tree and the editor. Arrow keys move it, Shift moves it further, Home and End jump to the limits, Enter resets and Escape cancels a drag. Widths persist, clamp to the window, and never touch a project's versions.

Help, and the log, in the app

Ctrl+/ now opens a Help centre — Get started, Guides, Support and the full shortcut reference — linking the published guides rather than a private copy. In the desktop app it also opens the backend log folder, which is the first thing to attach to a bug report. Zoom is explicit too: Ctrl+=, Ctrl+- and Ctrl+0, in fixed steps between 50% and 300%.

Every version, its notes and all its files are on the releases page. The full history lives in the changelog.

Download

Windows 10/11 x64. Each build carries its own Python backend and a headless Chromium, so there is nothing else to install. latest is the current published build; every version this hub has published — with the files it actually carries — is on the releases page.

Installer (MSI)

Managed

Per-machine deployment. Self-update is disabled by design; upgrades stay with the administrator.

Download .msi

Portable

Unzip anywhere and run shot2code.exe — nothing to install, and easy to remove.

Download .zip

Checksums

Verify

SHA-256 hashes for every file in this release. The binaries are unsigned, so this is how you check what you downloaded.

SHA256SUMS

Compare the hash of the file you downloaded against the published list:

Get-FileHash .\shot2code-<version>-x64.exe -Algorithm SHA256

Only the per-user .exe updates itself: Settings shows the running version, the update state and Restart & install once a download is ready. Before anything is replaced, the installed backend is stopped and that shutdown is verified — by the app, and again by the installer itself, so an update that starts from an older build is protected too. The installer now stops the installed backend itself before replacing anything, matching processes by path under resources\backend, never by name, and if it cannot confirm they are gone the install stops rather than overwriting a running app. MSI upgrades stay with the administrator and portable builds do not update.

These builds are not code-signed. Windows will show “Windows protected your PC” the first time you run the installer, and downloaded files carry the mark of the web. That warning is expected and is not evidence that the download is good or bad — verify the SHA-256 hash first, then choose More info → Run anyway, or right-click the file → PropertiesUnblockApply. If a hash does not match, stop and report it.

What leaves your machine

Three things, all of them yours to control.

Local by default

Screenshots, generated code and project history stay on the device. The generation request goes to the provider you configured — and nowhere else. Keys are stored locally and are not sent anywhere but their own provider.

No telemetry

There is no analytics SDK in the app; nothing about your usage is collected. The remaining background call is the update check on per-user installs, and CodePen sharing only ever happens when you confirm it.

Untrusted input, treated as such

Imported projects are parsed, never executed. Previews run in an opaque origin with a restrictive CSP, a no-referrer policy, and camera, microphone, geolocation and display capture denied.

Documentation

Everything needed to install it, use it, work out what went wrong, and see what ships inside it.