# PicGo: a desktop image uploader that puts the link on your clipboard

> PicGo is an Electron app that uploads an image to a host you configure and copies the resulting URL, so a screenshot becomes a Markdown link without leaving your editor. It is aimed at writers, note-takers and docs authors; the trade-off is that every host is a plugin you have to set up yourself.

**Molunerfinn/PicGo** — :rocket: The Ultimate Image Uploader for Efficient Creators. Supports Obsidian, Typora, VS Code etc. and 60+ image hosting services  (S3, GitHub, Cloudflare R2, Imgur, Aliyun OSS...). Paste, upload, done.

- Repository: https://github.com/Molunerfinn/PicGo
- Website: https://picgo.app/
- Stars: 27,272 · Forks: 2,330
- Language: TypeScript
- License: MIT
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/molunerfinn-picgo

## The gap PicGo fills between a screenshot and a published URL

Writing with images has a boring middle step. You take a screenshot, it lands in a folder, you open a browser, log into your object storage or image host, drag the file in, wait, copy the URL, switch back to the editor, and paste. PicGo exists to delete that loop. The README describes the goal as making image uploading part of the creative workflow: you upload in one step and the resulting link is copied to the clipboard automatically.

The audience is narrow and specific. People who write blog posts, keep notes, or author developer documentation, and who already pay for or run some place to store images. The README names Obsidian, VS Code, Typora, Neovim, MarkText and SiYuan as editors that can drive the upload through native support or community plugins. If your images live in a CMS that handles uploads for you, PicGo solves a problem you do not have.

The project is an Electron desktop application written in TypeScript, MIT licensed, with the default branch named dev. The most recent release listed is v3.0.2 on 2026-08-14, and the last push to the repository was on 2026-09-01.

## How the upload actually travels: clipboard in, link out

The mechanism is deliberately shallow. PicGo holds a configured image host and its credentials, accepts an image from one of several entry points, sends it to that host, and writes the returned URL to the system clipboard in a format you chose (Markdown, HTML, plain URL or a custom template). The entry points listed in the README are drag and drop, paste from the clipboard, a global hotkey, and a right-click context menu on macOS and Windows. The global hotkey defaults to Command+Shift+U on macOS and Ctrl+Shift+U on Windows and Linux, and the README states it can be customized.

Hosts are the part that is not built in. The README lists Qiniu, Tencent Cloud COS, UPYUN and Alibaba Cloud OSS as China cloud vendors, plus GitHub, SM.MS (S.EE) and Imgur as international options. Everything else, including AWS S3, Cloudflare R2 and MinIO, is described as arriving through plugins. That is a design decision with a cost: the application ships small and the plugin ecosystem carries the long tail, but a host with no maintained plugin is effectively unsupported. The README is explicit that PicGo itself will no longer add new third-party image hosts by default and points readers at PicGo-Core for building one.

There is also an HTTP API for uploading via HTTP requests, marked as available from v2.2.0, which is the hook other tools use to drive PicGo rather than reimplementing upload logic.

## Installing PicGo and uploading your first image

The README's download table points at GitHub Releases for all platforms, with a Shandong University mirror at mirrors.sdu.edu.cn/github-release/Molunerfinn_PicGo for people who find GitHub downloads slow in mainland China. Install the build for your platform from one of those two places, then open the app.

The first real use is configuration, not upload. Open the image host settings, pick a host, and fill in its credentials. The exact fields depend on the host and are not enumerated in the README, so treat the host's own console as the reference for keys and bucket names. Once a host is set as default, the upload paths are all shortcuts to the same action.

If you are wiring PicGo into an editor rather than clicking the app, the README gives the Obsidian-style route through the skills package:

```bash
npx skills@latest add PicGo/skills
```

That command installs the official Agent Skills, which the README says teach an AI tool when and how to upload, reusing the hosts and plugins you already configured. For the DeepSeek Harness route, the README gives this instead:

```bash
dsh plugin --profile web add @picgo/dsh-plugin
```

After either route, the reader should expect the same outcome as a manual upload: the image goes to the host you configured and the link comes back. Neither command configures a host for you.

For anyone building on top of PicGo rather than using the GUI, the repository is a pnpm workspace. The package.json scripts show the shape of local development: dev runs electron-vite dev, build runs electron-vite build, and test runs vitest run. The postinstall and postuninstall hooks both call electron-builder install-app-deps, which means a plain install step will try to rebuild native dependencies for Electron.

## Where PicGo stops helping: hosts, plugins and the v3 line

The honest limitation is the one the README states outright. PicGo will no longer add new third-party image hosts by default. If your storage is not Qiniu, Tencent COS, UPYUN, Alibaba OSS, GitHub, SM.MS or Imgur, your setup depends on a plugin that someone else maintains, and the README does not promise anything about plugin compatibility across major versions. The v3.0.0 release on 2026-07-01 is a major version bump, and the README does not document a rollback path or a migration guide for plugin authors in the text available here.

The second limitation is that PicGo is a client, not a service. It has no server component, so there is no shared configuration for a team, no upload history you can query from elsewhere, and no way for a colleague to use the same host settings without repeating the setup. The HTTP API changes that only in the sense that another program on the same machine can trigger an upload.

The third is the platform surface. The right-click context menu is documented for macOS and Windows, not Linux. If your workflow depends on that entry point, Linux is the wrong platform for this tool regardless of how well the rest of it fits.

Finally, the AI-facing features are new and depend on external projects. The skills package and the dsh plugin are separate repositories, and the README links a blog post rather than documenting their behaviour in place. Treat them as conveniences layered on top of a configured host, not as a reason to choose PicGo.

## PicGo against a hosted image CDN

The obvious alternative for a team is a hosted image service: you upload through the provider's dashboard or API, and the provider owns storage, delivery and resizing. The difference in approach is where the credentials and the files live. With PicGo, the image goes straight from your machine to a bucket you control, and the app is a thin client in front of it. With a hosted service, the image goes to the vendor, and you get a CDN and a management UI instead of a plugin you have to keep working.

That trade-off cuts both ways. PicGo gives you no delivery network, no automatic format conversion, and no dashboard listing what you have uploaded; those are your host's problem. In exchange, the URL in your Markdown points at infrastructure you already pay for, and removing PicGo from your machine does not break a single existing link. A hosted service is the better choice when nobody on the team wants to own bucket permissions.

Within the same category, the README's own note about PicGo-Core matters. PicGo-Core is the underlying engine that plugin authors build against, and it is a different product from the desktop app: it is what you reach for when you want uploads inside a script or CI job rather than behind a hotkey. Choosing between them is a question of whether a human is pressing the key.

## Licence, maintenance and what an upgrade costs you

PicGo is MIT licensed, which permits commercial use, modification and redistribution provided the copyright notice and permission notice are retained. That is a permissive licence and it places no obligation on your own code. The practical implication is not legal but operational: because the licence allows forks, a plugin you depend on can be forked and maintained by someone else if the original author stops, and nothing in the licence prevents that.

Maintenance signals here are concrete. The last push was on 2026-09-01, and the release history shows v3.0.0 on 2026-07-01, v3.0.1 on 2026-07-12 and v3.0.2 on 2026-08-14. That is a steady cadence through the v3 line rather than a burst and a silence.

The upgrade cost is the part to plan for. v3.0.0 was a major bump, and the README does not describe what plugin authors had to change or whether older plugins keep working. If you run PicGo with a plugin for S3, R2 or MinIO, the thing to check before upgrading is that plugin's own release notes, not PicGo's. The desktop app can be reinstalled from GitHub Releases at any version, but a plugin that has not been updated for the v3 API is a different problem, and the README does not address it.

## Conclusion

Adopt PicGo if you publish images often and are willing to configure one host plugin, because the clipboard-copy step is the whole product and it removes a browser round trip from every post. Skip it if you need a hosted service or a zero-configuration install, since the README states PicGo will no longer add third-party image hosts by default and everything beyond Qiniu, Tencent COS, UPYUN, Alibaba OSS, GitHub, SM.MS and Imgur arrives as a plugin. Before committing, verify that a plugin exists for your host, that it has been updated for the v3 line, and that your credentials work through the app rather than only through the provider's own console.

## FAQ

### Is it safe to use an AI photo generator?

The README does not discuss AI image generation. PicGo uploads images you already have to an image host; it does not create images.

### What image generator can I use for free?

PicGo is not an image generator, and the README does not list or compare any generator. It is an uploader that sends an existing image to a host you configure.

### What is image gpt?

The README does not mention an image gpt feature. PicGo's AI-facing work is the skills package and the dsh plugin, which let an agent upload images using hosts you already configured.

### Where do AI image generators get their images?

The README does not cover how AI image generators source images, and it makes no claim about training data. PicGo's own flow starts from an image on your disk or clipboard.

## Sources

- [License: MIT](https://github.com/Molunerfinn/PicGo/blob/dev/LICENSE)
- [Molunerfinn/PicGo on GitHub](https://github.com/Molunerfinn/PicGo)
- [Project website](https://picgo.app/)
- [README](https://github.com/Molunerfinn/PicGo/blob/dev/README.md)
- [Releases](https://github.com/Molunerfinn/PicGo/releases)

---

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