> ## Content Index
> Fetch the complete content index at: https://thegimp.net/llms.txt
> Use this file to discover other available public pages before exploring further.

# Does GIMP have AI? Tools, plug-ins and version limits
- URL: https://thegimp.net/gimp-ai-tools/
- Published: 2026-11-17T14:07:00.000Z
- Updated: 2026-11-17T21:41:16.000Z
- Description: Choose an AI route by the edit you need, then check the GIMP version, backend and image-transfer conditions.
- Author: Elena Morris
- Tags: Plug-ins and scripts

GIMP AI tools come through plug-ins and their processing backends; standard [GIMP 3.2](https://www.gimp.org/release-notes/gimp-3.2.html?ref=thegimp.net) doesn't include a built-in, prompt-based Generative Fill service. For a small photographic correction, I'd start with Heal or Clone because they let you choose existing source detail. For generated content, choose a compatible local-model bridge or a hosted API plug-in, then check its GIMP version, hardware, file handling and running costs.

The important distinction is where the image goes. A menu inside GIMP can send pixels to another application on your computer or to a remote provider. An active selection doesn't establish which pixels leave the document, and a free plug-in doesn't make its API calls free.

- [Choose by the editing task](#choose)
- [Compare actual plug-in requirements](#plugins)
- [Complete a ComfyUI round trip](#comfy)
- [Check cloud inputs, keys and costs](#cloud)
- [Review the returned layer](#review)
- [Diagnose menus, models and failed requests](#fix)

## Choose the operation before choosing an AI plug-in

Generating a replacement object, extracting a foreground and enlarging a photograph solve different problems. Pick the smallest operation that produces the image you need.

| What needs changing                               | A sensible starting route                                                                                                         |
| ------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------- |
| A blemish, dust spot or small distraction         | Heal or Clone with suitable source pixels. Use a compatible texture-synthesis extension when it helps fill a surrounding pattern. |
| A foreground needs separating from its background | Foreground Select and a refined layer mask; consider a segmentation model if its output makes the edge work easier.               |
| A small image needs more pixels                   | Compare ordinary scaling with a dedicated upscaling model. Judge both at the same intended output size.                           |
| An object or scene must be invented               | Inpainting or image generation through a compatible model backend or hosted API.                                                  |
| Only noise, tone or contrast needs correcting     | Start with the relevant correction. A generative replacement can change details that were already right.                          |

The [Heal tool uses a chosen source area and the destination's surroundings](https://docs.gimp.org/3.2/en/gimp-tool-heal.html?ref=thegimp.net). It doesn't interpret a text prompt. [Foreground Select builds a selection from your rough boundary and foreground strokes](https://docs.gimp.org/3.2/en/gimp-tool-foreground-select.html?ref=thegimp.net); it isn't an instruction to generate a new background. The [object-removal guide](https://thegimp.net/remove-object-gimp/) covers the choice between Heal, Clone and texture-based removal.

For a cutout, inspect hair, glass, motion blur and translucent edges rather than accepting the first opaque silhouette. A segmentation result is a starting boundary. Keep the original layer and refine its visibility with a [layer mask](https://thegimp.net/gimp-layer-mask/) so you can recover a missed edge.

## Compare named projects and their real requirements

“GIMP AI” isn't one standard extension. These projects have different maintainers, installation methods and processing routes. Match the repository name to the instructions you're following; an old tutorial for a similarly named plug-in can lead to the wrong Python API or service.

### GIMP Upscale: a focused Windows or Linux enlargement route

[Nenotriple's GIMP Upscale](https://github.com/Nenotriple/gimp%5Fupscale?ref=thegimp.net) provides separate packages for GIMP 2.10 and GIMP 3.0\. It uses RealESRGAN through NCNN/Vulkan, lists Windows and Linux support, and requires a Vulkan-compatible GPU. GIMP running on a Mac doesn't make this package a documented Mac option.

Use the GIMP 3 package for GIMP 3\. The documented entry is **Filters → Enhance → AI Upscale…**. Custom models must be a matching NCNN `.param` and `.bin` pair with the same filename stem; the project supports native 4× models, not a loose `.pth` file. Its output scale control and a model's native scale are different settings.

I'd compare the result with **Image → Scale Image…** at the same final dimensions. [GIMP's ordinary scaling changes the pixel dimensions using interpolation](https://docs.gimp.org/3.2/en/gimp-image-scale.html?ref=thegimp.net). A learned model can produce convincing texture, but convincing texture isn't proof that the original contained that detail. Keep lettering, faces and product markings under particular scrutiny.

### GIMP Comfy Tools: a bridge for an existing ComfyUI setup

[GIMP Comfy Tools connects GIMP 3 to a running ComfyUI instance](https://github.com/nchenevey1/gimp-comfy-tools?ref=thegimp.net). Its Generation Studio can send image layers and selection masks, import workflows in **API format**, and return generated images as new layers. The project excludes GIMP 2.10.

This is my choice when the required model already works in ComfyUI: it keeps the editing and generation stages connected. It doesn't install ComfyUI or obtain the right checkpoint merely by appearing in GIMP. A workflow can also require custom nodes or LoRAs, so a working backend and a complete workflow are separate requirements.

The documented default address is `http://127.0.0.1:8188`. Check the configured address in your installation. A remote address sends work to that remote system; a loopback address refers to the environment making the connection, which matters when containers or separate machines are involved.

### OpenFill: fill, remove and expand through ComfyUI

[OpenFill adds generative fill, object removal and canvas expansion to GIMP](https://github.com/beckettharriman/openfill?ref=thegimp.net), returning results on new layers. Its GIMP plug-in is a beta; the separate PhotoCraft version has a different version number and feature set. I'd shortlist OpenFill for these specific operations because it manages the ComfyUI backend from the editor, while Comfy Tools suits an existing workflow you want to import.

The [OpenFill installation requirements specify GIMP 3.2 or newer](https://github.com/beckettharriman/openfill/blob/main/docs/install.md?ref=thegimp.net) on Windows, Linux or macOS. Start from its Releases page, install the GIMP package and restart GIMP. Open **Filters → OpenFill → Generative Fill…**, connect the intended ComfyUI installation and use the Models tab to obtain a suitable model. Windows offers a ComfyUI download route; Linux and macOS have separate setup instructions. Check graphics memory and disk space for the chosen model before downloading.

Check the processing setting before using a private image: [OpenFill also supports an optional cloud service](https://github.com/beckettharriman/openfill/blob/main/docs/security.md?ref=thegimp.net), which sends the request to that provider. A remote GPU is another computer, even when you own it. For commercial work, check the [individual model licences](https://github.com/beckettharriman/openfill/blob/main/docs/models.md?ref=thegimp.net); MAT and FLUX.1 Fill models have non-commercial restrictions. Inspect the returned edges and detail before accepting the layer.

### OpenVINO AI plug-ins: choose the Intel and package route together

[Intel's OpenVINO AI plug-ins](https://github.com/intel/openvino-ai-plugins-gimp?ref=thegimp.net) target GIMP 3 and provide generation, inpainting, semantic segmentation and super-resolution. Their upstream Linux README says testing is on Ubuntu 24.04 and explicitly excludes Flatpak. The Windows guide specifies Intel devices and doesn't support non-Intel GPUs or NPUs; check its requirements for the particular device and model.

There is also a current [OpenVINO content snap for the GIMP snap](https://github.com/canonical/openvino-ai-plugins-gimp-snap?ref=thegimp.net). This is a separate integration, rather than evidence that a normal GIMP installation already contains the AI menus. Its Stable Diffusion plug-in requires an Intel GPU or NPU; its FastSD plug-in can also use a CPU. The upstream [Linux guide includes installing and connecting the two snaps](https://github.com/intel/openvino-ai-plugins-gimp/blob/main/Docs/linux%5Finstall%5Fguide.md?ref=thegimp.net).

I'd follow that documented Snap route when the hardware and installed GIMP package fit. Don't copy a native-build installer into Flatpak or combine an older release-candidate announcement with current packages. Preserve your resources before changing the installation route; a blanket deletion of GIMP's configuration directory can remove preferences and custom resources as well as a broken setting.

### GIMP-ML: check the current project, not an old feature list

The current [GIMP-ML project generates and edits images in GIMP 3 through Gemini models on Google or OpenRouter](https://github.com/kritiksoman/GIMP-ML?ref=thegimp.net). It requires a separate Python 3.10 or newer installation, internet access and a funded API account. This is an external-provider route, even though it doesn't require a local model or GPU.

Don't follow an old GIMP-ML denoising or super-resolution tutorial and expect it to describe these commands. The current menus distinguish **Generate Image…**, **Edit Selected Layer…** and **Edit Visible Canvas…** under **Filters → GIMP-ML**. The input choice changes what is sent. Keep the output as a new layer while assessing the edit.

### lukaso/gimp-ai: an OpenAI-connected beta

[lukaso's GIMP AI Plugin beta](https://github.com/lukaso/gimp-ai?ref=thegimp.net) specifies GIMP 3.0.4 or newer, internet access and an OpenAI API key. Its README identifies `gpt-image-1` support; don't assume every newly announced image model can be selected. Its documented menu is **Filters → AI**, with separate Settings, Inpainting and Image Generator commands.

Choose this route for its documented provider and features, after checking the current release and account access. An OpenAI-compatible label elsewhere doesn't establish compatibility with this particular extension. Provider model availability, permissions and billing still apply.

## Complete one ComfyUI image round trip before a larger edit

A successful installation ends with a returned, usable layer. I'd establish that with a copy of an ordinary image and the project's supplied workflow before adding custom nodes or a complicated composition.

1. **Identify the GIMP copy.** Read its version in Help → About on Windows/Linux, or GIMP → About on macOS. Find the user plug-ins directory through Preferences → Folders → Plug-ins. Follow the [GIMP plug-in installation guide](https://thegimp.net/install-gimp-plugins/) if you have more than one package.
2. **Keep the downloaded project structure intact.** The Comfy Tools README places the shared `modules` directory alongside `gimp-generate-pers` and `gimp-metadata-viewer` in the plug-ins directory. Copying just the visible generation script omits its shared code. Fully quit and restart GIMP after installation.
3. **Establish the backend.** Start the intended ComfyUI instance and confirm that the chosen workflow and model work there. Check the plug-in's backend address before sending a private image. Use the project's current instructions for model and node dependencies.
4. **Open a practice copy and save an XCF.** Keep the original layer. Make the intended source layer clear; don't send a complex layer stack while you're still checking how the bridge handles its input.
5. **Open Generate Panel → ComfyUI Studio.** Select the target image and a supplied workflow. For a custom workflow, import the API-format export, rather than the normal node-graph JSON. Match the checkpoint and any LoRAs to files available in the backend.
6. **Choose the operation deliberately.** For inpainting, make a selection around the intended change; the bridge converts an active selection into a mask. Confirm that you've selected an inpainting workflow. A selection alone doesn't turn every text-to-image graph into an inpainting graph.
7. **Generate and inspect the returned layer.** Check the backend console if generation fails. When the result arrives, verify its position, dimensions and edge alignment against the original before saving.

The [Comfy Tools usage instructions also document a Metadata Viewer](https://github.com/nchenevey1/gimp-comfy-tools?ref=thegimp.net#usage), which can retain a generated layer's prompt, seed, sampler and workflow in XCF metadata. Record the model and workflow used so you can understand a revision later. Remove sensitive prompt or workflow information from a copy before sharing an editable project.

A seed is useful context, not a promise that a different model, node version or backend will reproduce the same image. Keep the accepted result as well as its settings.

## Check the upload boundary, credentials and cost before generating

Read the input contract for the exact command. In [GIMP-ML's current editing instructions](https://github.com/kritiksoman/GIMP-ML?ref=thegimp.net#use), selected-layer editing uploads that layer's pixels, including pixels outside the canvas, without its mask, opacity or blend mode. Visible-canvas editing uploads the visible composite within the canvas bounds. Text-only generation doesn't upload an image. Prompts still go to the selected provider.

This matters for a hidden face, a cropped document or information covered by a mask. Hiding pixels in the working document isn't the same as removing them from the input. Export a separate PNG showing only the permitted content, inspect it, then reopen that export as a new document for the request. Check its metadata too. [Shrinking the working canvas can leave layers extending outside it](https://docs.gimp.org/3.2/en/gimp-image-resize.html?ref=thegimp.net), and a mask can retain hidden content in the original layer.

The [lukaso plug-in's inpainting notes](https://github.com/lukaso/gimp-ai?ref=thegimp.net#ai-inpainting) likewise say that surrounding context can be considered and pixels outside the selection changed before the returned result is masked. Don't infer “only the selection was uploaded” from an output that appears confined to the selection.

For a hosted route, check the selected model's current price, the account's access and limits, and the provider's retention and use terms. Set a spending limit where the service offers one. A small image trial should establish the request path before repeated generations. Keep API keys out of XCF files, support posts and screenshots; inspect configuration backups before sharing them.

Credential handling varies by plug-in. [GIMP-ML documents macOS Keychain settings and provider environment variables](https://github.com/kritiksoman/GIMP-ML?ref=thegimp.net#credentials); saving a key doesn't verify available credits. Its privacy notes also warn that cancelling local work may not stop processing or billing at the provider. If a request times out, inspect its state before immediately sending another billable request.

For local inference, check that the workflow uses the intended local backend and nodes. Downloading models still needs connectivity, storage and a model licence suitable for the intended use. The open-source licence of the plug-in and the licence of its model weights are separate questions. “Local” describes a configured processing path, not a quality rating or a licence.

## Accept the returned pixels only after checking the composition

I'd keep the original below a separate returned layer until the image survives an edge check. A new layer gives you a straightforward way to compare and revise; flattening the only copy makes that harder.

[![GIMP Layers dock with Result above Original, both visible, and the Result mask thumbnail active with a white border.](https://storage.ghost.io/c/da/21/da2186e6-6044-4206-b621-584ed1984ab7/content/images/2026/11/gimp-ai-tools-imagefix-ui-20261117.webp)](https://storage.ghost.io/c/da/21/da2186e6-6044-4206-b621-584ed1984ab7/content/images/2026/11/gimp-ai-tools-imagefix-ui-20261117.webp?ref=thegimp.net)

Toggle Result's eye to compare it with Original; choose the white-bordered mask thumbnail when refining visibility. [Open the result layer and active mask at full size](https://storage.ghost.io/c/da/21/da2186e6-6044-4206-b621-584ed1984ab7/content/images/2026/11/gimp-ai-tools-imagefix-ui-20261117.webp?ref=thegimp.net).

1. **Check the input and output bounds.** Look for a shifted layer, unexpected crop, changed proportions or transparent padding. Verify the actual pixel dimensions rather than trusting a “4K” description.
2. **Toggle the returned layer's visibility.** Compare the object, background and supposedly unchanged regions. Check writing, faces, repeated patterns, straight lines and small product details against the source.
3. **Inspect the boundary at 100% and at delivery size.** Look for halos, duplicated texture, mismatched grain and a sudden change in focus or lighting. Upscaling should earn its place at the size you'll use.
4. **Mask and refine the result.** [GIMP's layer-mask controls](https://docs.gimp.org/3.2/en/gimp-layer-mask-add.html?ref=thegimp.net) can initialise a mask from the selection: white reveals the layer and black hides it. Check that you're painting the mask thumbnail when changing visibility. If the integration already supplied a mask, inspect that existing mask first.
5. **Save and check both deliverables.** [Save the layered XCF, then export a separate PNG or JPEG](https://docs.gimp.org/3.2/en/gimp-images-out.html?ref=thegimp.net). Open the export outside GIMP and check its dimensions, colour and edges. Retain the source and accepted XCF for revisions.

A generated repair can be visually useful while changing what the photograph records. For restoration, documents or product evidence, don't accept invented lettering or structural detail as recovered fact. Choose a conventional correction or keep the source visible when factual fidelity is the job.

## Diagnose the failing stage instead of reinstalling everything

| What fails                                       | Check next                                                                                                                                                                                                                                                                                                                                                                                  |
| ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| The AI menu never appears                        | Check the exact GIMP branch, the directory reported by that running copy, required sibling files and executable permissions where required. Fully restart GIMP and read its startup error. [GIMP 3 changed the plug-in API and moved to Python 3](https://www.gimp.org/release-notes/gimp-3.0.html?ref=thegimp.net#api-updates); moving a GIMP 2.10 script to a new folder doesn't port it. |
| The menu opens, but the backend won't connect    | Confirm that the intended backend is running and that the configured address is reachable from the plug-in's environment. Check package/container boundaries before changing unrelated network settings.                                                                                                                                                                                    |
| A workflow JSON won't import                     | For Comfy Tools, export API format. Check the workflow's nodes and their current names; ordinary graph JSON is a different format.                                                                                                                                                                                                                                                          |
| Checkpoint, model or node is missing             | Read the backend's full error and compare it with installed model filenames and node versions. For GIMP Upscale, check the matching NCNN pair rather than supplying a .pth file.                                                                                                                                                                                                            |
| OpenVINO doesn't offer the expected device       | Check the integration's Intel-device requirements, drivers, model and package route. CPU support in FastSD doesn't make every Stable Diffusion model a CPU option.                                                                                                                                                                                                                          |
| The API rejects a request or times out           | Check the provider response, key access, credits, limits and supported model/input. Remove credentials from logs before sharing them. Establish whether the request is still processing before retrying.                                                                                                                                                                                    |
| The model finishes, but no layer returns         | Inspect the backend's output and plug-in errors. Confirm the target document is still open and that the workflow matches the bridge's current instructions.                                                                                                                                                                                                                                 |
| The result is wrong despite a successful request | Check source layer, selection/mask, dimensions, chosen model and workflow. Request success doesn't establish correct content or alignment.                                                                                                                                                                                                                                                  |

Record the GIMP version and package, plug-in release, operating system, backend/model and exact error when asking for help. Keep the successful workflow and accepted image before updating any one component. If an extension causes startup trouble, save your work and quit, then move only that extension out of the plug-ins search path while preserving a backup. Don't erase the whole profile to troubleshoot one menu.

For a small retouch, return to the built-in tools and finish the image while the AI setup remains a separate task. For generation, keep the route whose compatibility, data path and returned layers you can identify. That's a more useful choice than collecting every extension with “AI” in its name.