# Comfy Desktop: one app that installs, updates and isolates ComfyUI setups

> Comfy Desktop is the official desktop application for ComfyUI, an Electron and Vue 3 app that provisions self-contained GPU-ready ComfyUI installs with prebuilt PyTorch wheels, keeps them updated in place, snapshots them for rollback, and can adopt an existing installation. The point is to remove the Python, CUDA and pip setup work, not to add features to the node editor itself.

**Comfy-Org/Comfy-Desktop** — The desktop app for ComfyUI

- Repository: https://github.com/Comfy-Org/Comfy-Desktop
- Stars: 609 · Forks: 82
- Language: TypeScript
- License: NOASSERTION
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/comfy-org-comfy-desktop

## The problem is the environment, not the editor

The tagline is the whole argument: install, run and manage ComfyUI from one app, with no dependency hell. The README makes the same point in its own words, saying that Comfy Desktop installs ComfyUI into a self-contained, GPU-ready environment, lets you run multiple independent setups side by side, and keeps them updated, so you spend your time building workflows instead of fighting Python, CUDA and pip. ComfyUI itself is the node-based engine for generative AI, and this application is the official desktop front end for it. The primary language is TypeScript, the app is Electron with Vue 3 and TypeScript built with electron-vite, and the licence is a custom one GitHub cannot classify, with the full text in the LICENSE file at the repository root. It is a packaging and lifecycle tool rather than a modelling tool, and the distinction matters when you judge it, because almost none of its value is in the workflow canvas.

## Multiple isolated installs, each with its own models

The first feature listed is multiple installs, side by side, where you run as many independent ComfyUI setups as you like, each with its own version, models and custom nodes, and you switch between them without conflicts. This is the feature that has no equivalent in a hand-rolled setup, because a hand-rolled setup is one virtual environment with one set of models and one set of custom nodes, and any of them can be broken by any other. The second feature explains why the isolation is possible: each install ships a relocatable Python with PyTorch and GPU wheels prebuilt, so there are no pip or uv failures and no CUDA roulette at install time. The trade-off is disk. Each install is a separate multi-gigabyte environment, which is also why the third feature, one-click updates, matters so much, since updating an install in place is what makes having several of them affordable. The README also notes that a dedicated GPU from NVIDIA or AMD, or Apple Silicon, is recommended for good performance but is not required.

## Updates, snapshots and adopting an install you already have

The lifecycle features are the third group. One-click updates update ComfyUI and its custom nodes to the latest version in place, with no terminal, no git and no re-downloading the multi-gigabyte environment. Snapshots and rollback let you back up an install and restore it if an update or a custom node breaks something, which is the direct answer to the fear that made people avoid updating in the first place. Bring your existing setup means the app can adopt and migrate existing ComfyUI installations, whether portable, git-based or a previous desktop install, in place. The last small feature is quietly the one that makes adoption possible on a fresh machine: it works without system Git, bundling a tiny Python and pygit2 bootstrap so clones work on a clean machine. Built-in auto-updates mean the app keeps itself current, and cross-platform support covers Windows, macOS and Linux.

## Downloading and installing on each platform

There is one download link, at dl.todesktop.com/241130tqe9q3y, and the README says it auto-detects your platform. The per-platform instructions are folded into a details block. On Windows you run the NSIS installer, an .exe, and launch from the Start Menu or a desktop shortcut. On macOS you open the .dmg, drag Comfy Desktop to Applications and launch it from there, and the requirements specify macOS on Apple Silicon. On Linux there are two package formats, a .deb for Debian and Ubuntu and an AppImage, and the README gives the commands for each:

```bash
sudo apt install ./*.deb
```

```bash
chmod +x ./*.AppImage
./*.AppImage --no-sandbox
```

The AppImage needs the executable bit and the no-sandbox flag, and after that you launch from your application menu. A new user is told to just download, install and open the app, because it walks you through creating your first setup and no terminal is required.

## The first launch, and the settings you can change

The Getting Started section is four steps. You download and install Comfy Desktop for your operating system, launch the app, and create a new install, where you pick a standalone, GPU-ready environment and Comfy Desktop downloads and provisions it for you, or import an existing ComfyUI install if you already have one. Then you hit launch, and the app starts ComfyUI and opens it ready to build. After that you can add more installs, take snapshots before risky changes, and update ComfyUI or its custom nodes per install. The distinction between a new install and an imported one is the one practical decision here, because the import path is what the bring your existing setup feature is for, and the new path is what the prebuilt environment story is for. The rest of the workflow, the node graph itself, is ComfyUI's, not this app's.

## How the desktop app is developed

The development setup is documented for contributors and it is conventional. The prerequisites are Node.js v22 LTS or later and pnpm v10 or later via Corepack, and the two commands to get there are shown in the README:

```bash
nvm install 22 && nvm use 22   # recommended — https://github.com/nvm-sh/nvm
corepack enable                # enables pnpm (bundled with Node)
```

Setup is a clone plus a single init command:

```bash
git clone https://github.com/Comfy-Org/Comfy-Desktop.git
cd Comfy-Desktop
pnpm run init
```

The README explains what init does: it runs pnpm install with the postinstall and husky hooks, and pnpm run bootstrap to build the bundled bootstrap Python. In development, pnpm run dev starts the app on Windows and macOS while Linux uses a separate script, ./linux-dev.sh, and the README also mentions pnpm run init:dev to set up a fresh clone and start the app in one command. The package scripts add a guard: a predev hook checks for a platform-specific bootstrap-python directory and prints a warning if it is missing, telling you to run pnpm run bootstrap for pre-install git support.

## The test matrix, and the build tooling behind it

The Common tasks table is the most informative part of the development documentation, because it shows that this is a project with a real test taxonomy. Unit tests run under Vitest, there is a separate integration suite, end-to-end tests run under Playwright, and a lifecycle Playwright project that uses real installs and downloads, with its own README. There is a typecheck script that covers node, web, e2e and integration, a lint script using ESLint with a fix variant, a format script using Prettier, and per-platform build scripts for win, mac and linux that output distributables to dist. The manifest backs this up. The engine field requires node 22 or later and pnpm 10 or later, the package manager is pinned to pnpm@10.28.1, the build script runs the typecheck before electron-vite build, and the todesktop hook scripts show the app is distributed through the todesktop service rather than a plain release asset. The repository also carries an electron-builder.yml, a playwright.config.ts, separate vitest configs for unit and integration tests, and several tsconfig files for the different targets.

## Where the desktop app is the wrong choice

Three limits are clear. The first is that this is a desktop application with a window, so it does nothing for a headless server, a container or a pipeline, and a team already running ComfyUI on a Linux box with a working virtualenv gains nothing from wrapping it in an Electron shell. The second is that the isolation model has a real cost, since each install is a separate multi-gigabyte environment, and the snapshot and rollback features exist precisely because updates to a shared environment are where things break. A team with one environment and one set of models gets less from this app than a team experimenting with several incompatible custom node sets. The third is the licence, which GitHub classifies as Other, so a custom licence rather than a recognised one, and the package manifest field reads SEE LICENSE IN LICENSE. If you intend to redistribute the application or build on its internals, read that file rather than assuming the ComfyUI project's terms carry over.

## Conclusion

Comfy Desktop suits someone who wants to run ComfyUI without managing Python environments, CUDA versions and pip resolution, and the multi-install model is the feature that separates it from a single global setup. It is the wrong tool if you already have a working command line ComfyUI and like it, since the app takes over that workflow rather than improving it, and it is the wrong tool if you need a headless server, since this is a desktop application. Verify first which platforms you are on, because the requirements list Windows, macOS on Apple Silicon and Linux, with the Linux build delivered as a deb package or an AppImage that has to be made executable, and note that the newest published release is v1.1.7 from 2026-10-13 with a v1.1.8 release candidate from 2026-10-20.

## FAQ

### What does Comfy Desktop actually do?

It is the official desktop application for ComfyUI, and it installs ComfyUI into a self-contained, GPU-ready environment, lets you run multiple independent setups side by side, and keeps them updated, so the Python, CUDA and pip setup work is done for you.

### What are the system requirements for Comfy Desktop?

Windows, macOS on Apple Silicon, or Linux. A dedicated GPU from NVIDIA or AMD, or Apple Silicon, is recommended for good performance but is not required.

### How do I install Comfy Desktop on Linux?

Either install the deb package with sudo apt install ./*.deb, or make the AppImage executable and run ./*.AppImage --no-sandbox, then launch from your application menu.

### Can Comfy Desktop update an existing ComfyUI installation?

Yes. You can adopt and migrate existing ComfyUI installations, whether portable, git-based or a previous desktop install, in place, and there is an import option when creating a new install.

### How do I set up Comfy Desktop for development?

Clone the repository, then run pnpm run init, which runs pnpm install with the postinstall and husky hooks and pnpm run bootstrap to build the bundled bootstrap Python. You need Node.js v22 LTS or later and pnpm v10 or later via Corepack, and pnpm run dev starts the app on Windows and macOS while Linux uses ./linux-dev.sh.

## Sources

- [Comfy-Org/Comfy-Desktop on GitHub](https://github.com/Comfy-Org/Comfy-Desktop)
- [Issues](https://github.com/Comfy-Org/Comfy-Desktop/issues)
- [README](https://github.com/Comfy-Org/Comfy-Desktop/blob/main/README.md)
- [Releases](https://github.com/Comfy-Org/Comfy-Desktop/releases)

---

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