kokon

https://github.com/user-attachments/assets/8851c580-99b9-432a-82be-b6d42fa9a749

New in 0.12: split any image into layers

• Layers lab (experimental): click the things you want on their own layer. Kokon cuts each one out and paints the background behind it, so you can move, scale, hide or edit any piece, expand one that was cut off by the frame, and save one image or export a PSD for Photoshop, GIMP or Photopea.

• Blend into scene (experimental): after a move, Kokon redraws the shadows, or reflections on wet or shiny ground.

• Paint with colours: one colour per thing, and say what goes there, right on the picture; Select picks an object with one click.

• Prompt+ for painted areas and Expand, with a Standard or Detailed level.

• Kokon's own Mac engine is the default on Macs with 16 GB or more: about a minute for a new 1-megapixel image on an M2 Pro, four times faster than before.

• AI marking: every image says, in its file and in an invisible watermark, that it was made with AI (docs/ai-marking.md).

Related MCP server: postward-creative-mcp

Since 0.11: use it from your phone, or run it as a server

Your computer with the graphics card makes the images; your phone, tablet or laptop uses Kokon in a browser. Nothing goes through a cloud, and there is no account. ▶ Watch the 0.11 video (77 s)

• Other devices: open Settings → Other devices, set a password and scan the QR code with your phone. Add Kokon to the home screen and it opens like an app. Off until you turn it on; 5 wrong passwords make that device wait.

• From anywhere: connect your devices with Tailscale or another VPN. Never open Kokon's port on your router.

• As a server: kokon-service on a Linux box without a screen, or the Docker image for NVIDIA cards:

  curl -fsSLO https://raw.githubusercontent.com/GabrieleLozupone/kokon/master/docker/compose.yaml
  docker compose up -d
  docker exec -it kokon kokon-service --set-password

Step by step: kokon.app/self-hosted · full reference: docs/remote-access.md and docs/docker.md.

A local alternative to Nano Banana, without the node graph

Cloud editors made "edit a photo with a sentence" normal, but they upload your photos and limit how much you use them. Node-based tools run locally, but you build everything yourself. Kokon is simple and local: we make the technical choices (model, files, steps, memory), you make the edits.

Fair to say: cloud models run on data-center GPUs, so they can be faster and stronger on some edits. Kokon runs Qwen-Image 2.1, which leads the open-weights image-editing rankings, on the computer you already have. You need a 12 GB graphics card (8 GB in beta) or an Apple Silicon Mac, and the images are for non-commercial use because of the model's license.

Why Kokon

Examples

Every image below was made by Kokon itself (no stock photos), first try with that seed. Prompts, seeds and times are in marketing/showcase/PROMPTS.md.

Install

1. Download from the latest release:

• Windows: Kokon_<version>_x64-setup.exe. Run it. It installs for your user only, so you don't need administrator rights.

• Mac (Apple Silicon, beta): Kokon_<version>_aarch64.dmg. Open it and drag Kokon to Applications. The first time, macOS blocks it because the app is not notarized by Apple: open System Settings → Privacy & Security and click Open Anyway, or run one Terminal command if there is no such button (details).

• Linux (x86-64, beta): Kokon_<version>_amd64.deb for Ubuntu, Debian and Mint, or Kokon-<version>-1.x86_64.rpm for Fedora. Install it with your package manager, which also pulls in the few libraries it needs:

  sudo apt install ./Kokon_<version>_amd64.deb      # Ubuntu 22.04+, Debian 12+, Mint 21+
  sudo dnf install ./Kokon-<version>-1.x86_64.rpm   # Fedora 40+

  For NVIDIA cards you need the proprietary driver (the CUDA runtime comes with Kokon). AMD and Intel cards use Mesa's Vulkan driver, installed on most desktops already. If apt prints "Download is performed unsandboxed as root", that's harmless (apt can't read your home folder); copy the .deb to /tmp first to avoid it.

• Server or Docker (NVIDIA): Kokon without a window, used from a browser on any device. The image ghcr.io/gabrielelozupone/kokon is published with every release: see docs/docker.md, or run kokon-service from the Linux packages (docs/remote-access.md).

2. Set up models. On first launch Kokon shows your graphics card (or your Mac's chip and memory), recommends a preset and downloads everything it needs. The download resumes if it is interrupted and every file is checked against its SHA-256 checksum. On a fast connection the whole thing takes a few minutes, and the setup screen shows what Kokon can do while you wait.

3. Edit. Drop or paste a photo, describe the change and press Enter.

Requirements

Windows

Mac (beta)

Linux (beta)

Kokon measures your machine's speed with the first image and shows realistic time estimates from then on.

Model presets: what gets downloaded

The setup screen picks a preset from your VRAM. On a Mac the presets are named by unified memory (16–24 GB Mac, 32–36 GB Mac, 48 GB Mac, 64 GB+ Mac), because the graphics part can use only about two thirds of it and the text encoder shares the same memory. You can change the preset later from Settings → Models → Set up models…

Every preset also gets stable-diffusion.cpp (the CUDA 12 build on NVIDIA, the Vulkan build on AMD and Intel, the Metal build on a Mac), the Qwen-Image 2.1 VAE with madebyollin's texture fix (it removes the faint 2-pixel checkerboard of the original decoder; installs from 0.9.2 or earlier switch to it when you accept the update), the Qwen3-VL vision projector and, on a PC, the Superscale-SP upscaler (67 MB). The image model is Qwen's official 8-step Qwen-Image 2.1 Turbo through unsloth/Qwen-Image-2.1-Turbo-GGUF (installs from 0.11.0 or earlier keep their Q4_K file until you accept the update); the other sources are Qwen/Qwen3-VL-8B-Instruct-GGUF, madebyollin/texture-fix-vae-for-qwen-image-2.1 and Comfy-Org/Qwen-Image-2.1 (the original VAE).

Files go to %LOCALAPPDATA%\KokonData\sdcpp (Mac: ~/Library/Application Support/KokonData/sdcpp) by default. You can point the setup screen at an existing stable-diffusion.cpp folder instead; files that are already there are kept.

Already have Qwen-Image 2.1 files, for example in ComfyUI? Choose Use models I already have in the setup screen and pick the folder (such as ComfyUI\models): Kokon finds the image model, VAE, text encoder and vision projector by their contents, as GGUF or safetensors in any quantization, and downloads only the engine and any piece you don't have. Files stay where they are. Your own files are not tested by Kokon; you can switch to the official files at any time in Settings → Models.

What you can do

New to prompts? The prompt guide shows good and bad prompts side by side, with real results.

Every result can be edited again, varied, used as a reference, upscaled, saved, copied or opened in Explorer, Finder or your file manager. A few things make that loop fast:

• Before/after: compare with Slider, Flicker or Changes, or hold B to see the original.

• Undo/redo between versions with Ctrl+Z / Ctrl+Y (⌘ on a Mac). Undo returns to the version the current one came from, and nothing is ever deleted.

• Gallery: every image keeps its full recipe (prompt, seed, settings, pipeline) and reopens with one click. The recipe is also embedded in the PNG.

• Clean up in one go: press Select (or Ctrl/⌘-click, Shift-click for a range) to remove several projects or delete several gallery images at once.

• Quality presets: Fast (the default, ~1 MP), Balanced (~1.5K) and Quality (native 2K). All run Qwen's official 8-step Turbo model with its own schedule, so you never need to tune steps or guidance.

How it works

flowchart LR
    A["📷 Your photo<br>+ a sentence"] --> B["Planner<br><sub>mode · size · memory budget</sub>"]
    B --> C["Qwen-Image 2.1<br><sub>stable-diffusion.cpp<br>on your GPU</sub>"]
    C --> D["AI upscaler<br><sub>Superscale-SP, back to<br>full size</sub>"]
    D --> E["🖼️ Result<br><sub>gallery + recipe</sub>"]
    M["🤖 Claude · Cursor · scripts"] -. "MCP / local API" .-> B

The planner decides what kind of job your request is, picks a working size that fits your GPU and runs a single diffusion pass. When the result has to be larger than what the model rendered, it is enlarged with an AI upscaler instead of a plain resize. For brushed edits, Kokon marks the area on a second reference image so the model knows exactly where to work. Without that, Qwen-Image 2.1 cannot see the mask.

With Prompt+ on, the planner first asks the model's own text encoder (Qwen3-VL, already loaded to read your prompt) to write a detailed English prompt, looking at your photo for edits. It runs inside stable-diffusion.cpp, so there is no second language model in memory. The image then uses that prompt, and the result keeps both yours and the written one.

The engine

Kokon runs on stable-diffusion.cpp by leejet. Prompt+ needed something it doesn't have: a way for the Qwen3-VL text encoder, already loaded for the image, to write text. The easy route was a second language model next to it, but another 5 GB model doesn't fit beside Qwen-Image 2.1 on 8–12 GB cards or on most Macs. So since 0.10 Kokon runs its own build of stable-diffusion.cpp, from our fork, on Windows, macOS and Linux. It is upstream plus a few additions:

• Text generation on the loaded text encoder: a decoding loop with a KV cache, sampling, the chat template with image tokens, and a /sdcpp/v1/text_gen endpoint in sd-server. With greedy decoding it writes the same tokens as llama.cpp on the same GGUF.

• Room on small cards: while it writes, the diffusion model and the VAE wait in RAM if the GPU is short of memory, and come back in about half a second for the image. Prompt+ fits within 8 GB (tested on an 8 GB-capped card).

• Speed: the decoding step is reused from token to token and, on NVIDIA, replayed as a CUDA graph: about 127 tokens/s on an RTX 5070 Ti (llama.cpp: 133–145), so a prompt takes 1–2 s.

The image side is upstream's code, and our changes leave its images bit-identical. We proposed the text generation upstream (#2155); leejet prefers to keep text generation out of stable-diffusion.cpp, since llama.cpp already does it, which is fair. So it lives in our fork, which we keep close to upstream's master. Kokon still works with an official stable-diffusion.cpp release, just without Prompt+.

Want the details? The engineering notes cover the architecture, the measured backend settings and the reasons behind each default.

Use it from your AI agent

Kokon ships kokon-mcp, an MCP server. Register it once with Claude Code:

# Windows
claude mcp add --scope user kokon -- "$env:LOCALAPPDATA\Kokon\kokon-mcp.exe"

# Mac
claude mcp add --scope user kokon -- /Applications/Kokon.app/Contents/MacOS/kokon-mcp

Or, on either system with Node.js 22+, through npm (still needs the app installed):

claude mcp add --scope user kokon -- npx -y kokon-mcp

Then ask: “Generate a hero image for this README and save it in docs/” or “Remove the background clutter from screenshot.png”. The app doesn't need to be open, because the MCP server starts the engine on demand. The first call takes about a minute while the model loads.

Tools: generate_image · edit_image · edit_images · inpaint_image · outpaint_image · upscale_image · get_image_info · get_generator_status

Project-scoped .mcp.json, or any host that takes the standard format (on a Mac the command is /Applications/Kokon.app/Contents/MacOS/kokon-mcp):

{
  "mcpServers": {
    "kokon": {
      "type": "stdio",
      "command": "C:\\Users\\<you>\\AppData\\Local\\Kokon\\kokon-mcp.exe",
      "args": []
    }
  }
}

Same thing from the command line:

claude mcp add-json --scope user kokon '{"type":"stdio","command":"C:\\Users\\<you>\\AppData\\Local\\Kokon\\kokon-mcp.exe","args":[]}'

• Every result returns the absolute path of the saved file, its size, seed and generation metadata.

• Paths may be absolute or relative to the project (CLAUDE_PROJECT_DIR). Reads and writes are limited to the project folder, Kokon's output folder and folders listed in QLS_MCP_ALLOWED_DIRS (separated by semicolons). Existing files are never overwritten.

• Images are not sent back to the model by default; they stay on disk. Pass include_preview: true to include a small JPEG preview.

• upscale_image takes scale (default 2) or width/height (up to 8192 px).

• Progress is reported through MCP progress notifications. Claude Code's default tool timeout is 30 minutes (MCP_TOOL_TIMEOUT).

• After 10 minutes without work the model is unloaded, so the graphics card is free for other programs, also with the desktop window open; the next call loads it again (Settings → General, 0 keeps it loaded).

Base URL http://127.0.0.1:39151/api/v1. Every call except /ping needs Authorization: Bearer <token>, with the token from %LOCALAPPDATA%\KokonData\service.json (Mac: ~/Library/Application Support/KokonData/service.json, Linux: ~/.local/share/KokonData/service.json). Requests from web pages (a browser Origin header other than the app's own) are refused.

$i = Get-Content "$env:LOCALAPPDATA\KokonData\service.json" | ConvertFrom-Json
$h = @{ Authorization = "Bearer $($i.token)" }
Invoke-RestMethod -Method Post "http://127.0.0.1:$($i.port)/api/v1/generate" -Headers $h `
  -ContentType 'application/json' -Body '{"prompt":"a lighthouse at dusk, 16:9","quality":"fast"}'

On macOS or Linux (curl; on Linux the file is in ~/.local/share/KokonData/):

INFO="$HOME/Library/Application Support/KokonData/service.json"
TOKEN=$(sed -n 's/.*"token" *: *"\([^"]*\)".*/\1/p' "$INFO")
PORT=$(sed -n 's/.*"port" *: *\([0-9]*\).*/\1/p' "$INFO")
curl -s -X POST "http://127.0.0.1:$PORT/api/v1/generate" \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"prompt":"a lighthouse at dusk, 16:9","quality":"fast"}'

The full route list (status, jobs, gallery, inputs, models, LoRAs, LUTs and the internal routes), the gallery query parameters and the request fields are in docs/http-api.md.

Privacy

Kokon makes only two kinds of network request:

• Setup: github.com for the stable-diffusion.cpp release (and the MoSR upscaler, if the copy that comes with the app is missing) and huggingface.co for the models and the other upscalers. The AI watermark's models come with the app; Adobe's model host (cai-watermark.adobe.net) is contacted only if that copy is missing.

• Update check: at most once a day, the app fetches latest.json from this repository's latest GitHub release, a small file with the newest version number. Nothing about you or your images is sent. Turn it off on the welcome screen or in Settings → General. Updates are downloaded only when you click Update, and installed only if their signature matches the key built into the app.

Creating, editing, the gallery, the MCP server and the API talk to 127.0.0.1 only, unless you turn on access from other devices (Settings → Other devices, off by default, password required): then the browser interface is also reachable on your local network. Logs never contain your prompts.

You can check this yourself. While you work, watch Kokon, kokon-service and sd-server in Resource Monitor's Network tab on Windows (or run Get-NetTCPConnection -OwningProcess <pid>), or with lsof -i -P | grep -iE "kokon|sd-server" on a Mac.

Private mode (the eye icon in the top bar) keeps images and prompts out of the gallery, the output folder and the project list. They are deleted when you turn private mode off, close the window, or restart the service. Save as… still writes a copy wherever you choose.

How it compares

Against other local tools. Kokon does one thing: photo editing with the best open model we've tested (today Qwen-Image 2.1), with nothing to set up. If you want full control over every node, ComfyUI is the better tool.

FAQ

SmartScreen shows this for new apps that don't have a download history yet. Click More info → Run anyway. You can check the installer against the SHA-256 hash listed in the release notes, or build it yourself.

If the installer does nothing at all (the cursor spins for a second, then no window and no process), Windows blocked it silently, usually through Smart App Control on fresh Windows 11 installs. Right-click the downloaded .exe → Properties, tick Unblock at the bottom of the General tab, click OK and run it again.

Kokon is not notarized by Apple (that needs a paid Apple developer account), so macOS blocks it the first time. You only do this once; in-app updates don't trigger it again.

1. Open Kokon. macOS says “Kokon” Not Opened: click Done (not Move to Trash).

2. Open System Settings → Privacy & Security and scroll down to Security. Next to “Kokon” was blocked to protect your Mac, click Open Anyway, then confirm with your password or Touch ID.

3. Open Kokon again and click Open in the last prompt.

If macOS instead only says The application “Kokon” can't be opened, with just an OK button, and Privacy & Security shows no Open Anyway: open Terminal and run

xattr -dr com.apple.quarantine /Applications/Kokon.app

then open Kokon as usual. This removes the "downloaded from the internet" flag from Kokon only; Gatekeeper stays on for everything else.

You can also build it yourself.

Only to download the models. After that Kokon works fully offline. If you are online it checks once a day for a new version, which you can turn off on the welcome screen or in Settings → General.

Yes, in a browser. On the computer with the graphics card, open Settings → Other devices, set a password and open the address it shows on the other device, on the same network. Images are made and saved on that computer; the other device uploads photos and downloads results. From outside your home, use Tailscale or another VPN, never port forwarding. Kokon can also run without a window, on a Linux server or in Docker. Guide: docs/remote-access.md.

AMD and Intel: in beta. The setup screen installs stable-diffusion.cpp's Vulkan build for them, which uses the graphics driver you already have. A user's RX 9060 XT 16 GB made a 1080p image at Balanced in about 80 s (first image, model loading included); Intel Arc is still untested, and integrated graphics are not supported. Please open an issue with your card and how it went.

Mac: yes, in beta, on Apple Silicon (M1 or newer) with macOS 15 Sequoia or newer. Since 0.12 Kokon runs its own Mac engine by default on Macs with 16 GB or more: about a minute per new 1-megapixel image on an M2 Pro (about 106 s for an edit), four times faster than before. LoRAs and the upscaler model still use the standard engine (Settings → Performance). 32 GB or more and a Pro, Max or Ultra chip are recommended. See the requirements and docs/platforms.md.

Linux: yes, in beta, on x86-64 with a .deb (Ubuntu, Debian, Mint) or an .rpm (Fedora). NVIDIA cards run Kokon's own CUDA build of the engine, AMD and Intel cards its Vulkan build. Since 0.11 it also runs headless, with the interface in your browser, and as a Docker image for NVIDIA cards (docs/docker.md).

If the Kokon window stays blank on Linux, start it with WEBKIT_DISABLE_DMABUF_RENDERER=1 kokon (a known WebKitGTK issue; Kokon already does this by itself on NVIDIA drivers).

Yes, in beta since 0.9.3. Setup picks the 8 GB preset: the same files as the 12 GB one, with smaller working sizes, so images are made at about 1 megapixel (then enlarged). Users report it works on an RTX 3060 Ti and on an RTX 5050 Laptop, where an edit takes 1–2 minutes. The text encoder runs from system RAM, so 16 GB of RAM or more is recommended. If you try it, please tell us how it runs in an issue.

Not with the default model. Kokon's code is open source (see License), but the image model has its own license: Qwen-Image 2.1 and its Turbo model are released under the Qwen Research License, which allows research and evaluation only, no commercial use. That includes selling or using commercially the images you make with it. For commercial use, ask the Qwen team for a license (model-business@notice.qwencloud.com).

The Qwen3-VL text encoder is Apache-2.0. The default upscaler, Superscale-SP by Nmkd, is WTFPL, and the experimental MoSR by Philip Hofmann is CC BY 4.0: both allow commercial use. The optional UltraSharp upscaler is CC BY-NC-SA 4.0, non-commercial only.

HEIC/HEIF photos open like any other image. On a Mac they are decoded by macOS itself. On Windows, Microsoft's HEIF Image Extensions and HEVC Video Extensions must be installed.

iPhone photos with an HDR gain map (iOS 18+) show a Keep HDR switch in Advanced, which is on by default. Edits of such photos are saved as Ultra HDR JPEG: Chrome, Edge, Android and recent Apple systems show them in HDR, and every other viewer shows a normal JPEG. This needs ffmpeg 7.1+ on PATH; without it the result is saved in SDR and the job's notes say why.

By default Superscale-SP by Nmkd (ESRGAN), downloaded by the setup screen; on a Mac, Lanczos, because AI upscalers take minutes there (Superscale-SP: 5 min 45 s to enlarge a 1024×1024 image to 2048×2048 on an M2 Pro, against about a second). Pick another one in the Advanced menu next to the prompt, or in Settings → Models; Compare upscalers there shows each one on the same crops (a face, a JPEG photo, a night street, text, a landscape, a 4× upscale):

• Superscale-SP (default): sharp and natural on most images; on JPEG photos and dark areas it can draw a faint grid.

• MoSR (experimental, 17 MB, comes with the app): the fastest, good for 4× upscales, but on clean images enlarged less than about 3× it draws a fine grid. Kokon contributed it to stable-diffusion.cpp (pull request #2128, merged 2026-10-12).

• UltraSharp (optional download): very clean, but smooths skin into an artificial look and can invent lines. Non-commercial license.

• Lanczos: a plain resize, never invents anything.

Upscaler strength (0–100 %) mixes the upscaler's result with a plain resize, to tone down texture it invents. Settings → Models also has Shrink the image before upscaling, which gives the upscaler a smaller image, like the ones it was trained on.

Windows: Settings → Apps → Installed apps → Kokon → Uninstall. The uninstaller asks whether to delete the downloaded models and app data too (%LOCALAPPDATA%\KokonData).

Mac: drag Kokon from Applications to the Trash. Linux: sudo apt remove kokon (or dnf). On both, the models and app data stay in your home folder until you delete them.

Step by step, with every folder to delete on each system: kokon.app/uninstall. Your images stay in your Pictures folder.

If a download fails, the setup screen shows the file's download page and target folder so you can fetch it by hand. For anything else, please open an issue with your GPU (or Mac model), driver or macOS version and the log from KokonData/logs (see the table above).

Roadmap

• Create, edit, combine, brush edits, expand, upscale

• First-run setup with GPU detection and verified, resumable downloads

• MCP server and local HTTP API

• Before/after, version undo, private mode, HEIC and HDR

• macOS on Apple Silicon (beta, Metal)

• One-click in-app updates on Windows, Mac and Linux

• Linux (.deb and .rpm, beta)

• Colour LUTs: built-in looks and your own .cube files

• Qwen's official 8-step Turbo model for every preset

• Prompt+: the prompt enhancer on the model Kokon already has (0.10.0)

• Your own LoRA files, per project (0.10.0, beta)

• New images from reference photos (a person, a product, a style), with Prompt+ (0.10.2)

• AMD GPUs through Vulkan (beta; RX 7900 XTX and RX 9060 XT reported working, RX 6000 cards still slow)

• 0.11: the interface in a browser on your other devices, served by Kokon itself, with a password, and a Docker image for NVIDIA (#15)

• Docker image for AMD and Intel (Vulkan); the desktop app as a client of a Kokon server elsewhere

• Kokon's own engine for Apple Silicon (GPU, CPU matrix unit and Neural Engine together; 0.11.1, the default on Macs with 16 GB or more since 0.12: text to image about 4× faster on an M2 Pro)

• 0.12: the Layers lab (split an image into layers, the background filled, PSD export; experimental), paint with colours, AI marking (metadata and an invisible watermark)

• Intel GPUs through Vulkan (to verify)

• Background removal and transparent cutouts

• Batch edits: one instruction for a whole folder

• Plugins for Krita, GIMP and Photoshop through the local API

What is in progress right now, known issues and where help is welcome: docs/STATUS.md. Have an idea? Start a discussion or 👍 an existing one. Press, creators and anything that isn't a bug: hello@kokon.app (press kit: kokon.app/press).

Build from source

Windows: Rust (stable, MSVC), Node 22+, Visual Studio Build Tools and WebView2.

npm install
cargo test -p qls-core            # core unit tests
npx vitest run                    # UI logic tests
cd mcp; npx vitest run; cd ..     # MCP tests (includes a stdio protocol test)
npx tauri dev                     # run the desktop app in development
powershell -ExecutionPolicy Bypass -File scripts\build-release.ps1   # installer

Mac (Apple Silicon, macOS 15+): Xcode Command Line Tools, Rust and Node 22+.

bash scripts/dev/mac-dev.sh --check   # check the prerequisites
bash scripts/dev/mac-dev.sh           # build and run the app in development
bash scripts/build-release-mac.sh     # Kokon.app + .dmg in dist-release/

Linux (x86-64): Rust (stable, via rustup), Node 22+ and Tauri's system packages. Build on the oldest distribution you want to support (releases are built on Ubuntu 22.04).

bash scripts/build-release-linux.sh --setup   # once: system packages
bash scripts/build-release-linux.sh           # .deb + .rpm in dist-release/

Publishing a release (signed in-app updates for every platform) is described in docs/releasing.md.

flowchart TB
    UI["<b>Kokon</b><br>Tauri 2 + React"]
    MCP["<b>kokon-mcp</b><br>MCP over stdio"]
    S["Scripts and other apps"]
    SVC["<b>kokon-service</b><br>planner · preprocessing · job queue · gallery<br><code>127.0.0.1:39151/api/v1</code>"]
    SD["<b>sd-server</b><br>stable-diffusion.cpp (CUDA · Vulkan · Metal)<br><code>127.0.0.1:39150</code>"]
    UI -- "HTTP + SSE, token" --> SVC
    MCP -- "HTTP, token" --> SVC
    S -- "HTTP, token" --> SVC
    SVC -- "native async API" --> SD

The Rust core (crates/qls-core) holds all the logic: geometry, image processing, planning, the inference adapter, the job queue and the gallery. The service, the desktop app and the MCP server are thin layers on top. See the engineering notes for a module map and the backend facts each default is based on.

Support Kokon

Kokon is free and open source, and everything that runs on your computer stays free: no account, no credits, no limits. It's built by one person. If it's useful to you, a tip on Ko-fi helps keep it that way; a star on GitHub helps other people find it. Tips are gifts and don't unlock anything.

Contributing

Bug reports, translations, example prompts and pull requests are all welcome. Issues tagged good first issue are a good place to start. Please run the tests above before opening a pull request.

Responsible use

Kokon edits real photos. Don't use it to deceive, harass or impersonate people, or to make images of someone without their consent. You are responsible for what you create and share.

Every image Kokon makes or changes with AI is marked as such, as the EU AI Act asks: in the file's metadata (IPTC Digital Source Type) and with an invisible watermark (TrustMark, the text Kokon-AI) that survives JPEG, resizing and screenshots. Please don't remove these marks. If you publish a realistic image of real people, places or events, say that it was made or changed with AI. Settings → General → Check an image reads the marks of any image; docs/ai-marking.md has the details.

License

Kokon's source code is released under the GNU Affero General Public License v3.0 (AGPL-3.0-only). You can use, study, change and share it freely. If you distribute a modified version, or offer one as a network service, you must publish its source under the same license. The license covers the code, not the images you make with it.

Want to ship Kokon inside a closed-source product or service? A commercial license is available: open a discussion or write to hello@kokon.app.

Model weights and the upscaler are downloaded from their authors and keep their own licenses (see the FAQ).

Kokon builds on stable-diffusion.cpp by leejet (since 0.10 through our fork, kept close to upstream), Qwen-Image 2.1 and its Turbo model by the Qwen team, Unsloth's Turbo GGUF files, Tauri and the upscalers by Nmkd (Superscale-SP), Philip Hofmann (4xNomos2 MoSR) and Kim2091 (UltraSharp). Thank you.