# OpenVINO AI plugins for GIMP: Stable Diffusion inside the editor

> intel/openvino-ai-plugins-gimp is a set of GIMP plugins that run Stable Diffusion, FastSD, semantic segmentation and super resolution on Intel hardware through OpenVINO. It targets GIMP 3 with Python 3, and its stated purpose is both practical, adding AI to routine image editing, and pedagogical, serving as reference code for inferencing inside GIMP.

**intel/openvino-ai-plugins-gimp** — GIMP AI plugins with OpenVINO Backend

- Repository: https://github.com/intel/openvino-ai-plugins-gimp
- Stars: 809 · Forks: 86
- Language: Python
- License: Apache-2.0
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/intel-openvino-ai-plugins-gimp

## AI inside GIMP rather than beside it

The repository provides GIMP plugins built on the OpenVINO runtime, dedicated for GIMP 3, Python 3 and OpenVINO. The description calls it a set of plugins that add AI features to GIMP, and the three stated objectives make the intent clear: provide OpenVINO based plugins that add AI features to GIMP, serve as reference code for how to make use of OpenVINO in a GIMP application for inferencing on Intel devices, and add AI to routine image editing workflows.

The second objective is the one that distinguishes this from a collection of scripts. The plugin architecture was inspired by GIMP-ML, and the project explicitly positions itself as something to read as well as something to install. For a team building a GIMP-adjacent tool, the value is as much in seeing how the inference pipeline is wired into the editor as in the four plugins themselves.

The plugin is reached from the layers menu in GIMP, under OpenVINO-AI-Plugins, and from there the same panel handles model selection, device selection and generation. The four plugin families are super resolution, semantic segmentation, Stable Diffusion and FastSD, and they share the pattern of compiling a model onto a chosen device and then running inference against the current image.

## What is in the model catalogue

The plugin list is long enough that the naming conventions matter more than usual, because the model identifiers are what you actually select in the interface.

The Stable Diffusion family covers SD 1.5 and its LCM variant, SD 1.5 Inpainting, three SD 1.5 Controlnet variants for OpenPose, CannyEdge and Scribble, SDXL in both Turbo and Base forms, SDXL Inpainting, SD 3.0 Medium and SD 3.5 Medium Turbo.

FastSD is the second generative family, and it is described as a faster version of stable diffusion based on Latent Consistency Models and Adversarial Diffusion Distillation, supporting CPU, GPU and NPU inference through OpenVINO. Its model list is longer and includes several int8 and int4 variants: rupeshs/sd-turbo-openvino, rupeshs/sdxs-512-0.9-openvino, rupeshs/SDXL-Lightning-2steps-openvino-int8, rupeshs/sdxl-turbo-openvino-int8, rupeshs/LCM-dreamshaper-v7-openvino, rupeshs/sd15-lcm-square-openvino-int8, OpenVINO/FLUX.1-schnell-int4-ov and rupeshs/sana-sprint-0.6b-openvino-int4.

Two details in that list are worth noting. FastSD models can be edited using the FastSD Model Manager, and the README singles out one model for NPU usage, namely rupeshs/sd15-lcm-square-openvino-int8. Since the first use of a FastSD model downloads it at runtime, the initial generation is slower than the ones after it.

## Load models once, then run inference

The interactive flow is short and the ordering matters.

For prompt to image, you start with a blank canvas or create or choose a layer, select Stable Diffusion from the drop down list in layers, then choose the desired model and Power Mode from the drop down list. The next step is the one people get wrong the first time: you click Load Models to compile and load the model on the device, and you only need to do this if you change the model or the device or both. For any subsequent runs you just click Run Inference.

After that you enter the prompt and the other parameters and click Generate, waiting for the total inference steps to complete.

Image to image follows the same steps, with the addition of a Use Initial Image option. By default the image opened in the canvas is used as the initial image, and you can also select a different image by browsing from files.

Power Mode is enabled for int8 Stable Diffusion models and for systems that have an NPU only, which is the setting that decides how aggressively the hardware is used. The plugin builds a native bridge between the editor and the runtime, which is where the first objective becomes visible in practice.

## Inpainting and Controlnet need their own setup

Two of the workflows have prerequisites that the README is careful about, and both produce confusing failures if you skip them.

For inpainting with SD 1.5 or SDXL, the model has to be downloaded and converted during the install process. You choose a layer or open an image of size 512x512, with the README noting that it currently works best at that resolution. You then use the Free select tool to select the area you want to change, right click on the image and click Add layer mask, then choose Selection in the Initialize layer Mask to field. The mask is what makes the rest work: you will only see the inpainting models in the drop down menu if you added a mask layer to your image.

The three Controlnet modes, OpenPose, CannyEdge and Scribble, each have the same shape. Open an image with the pose or the edges or the scribble you want to use, select the Controlnet model and the device from the drop down list, and then follow the same load and generate steps. The critical instruction is repeated for all three: make sure to select the Use Initial Image option from the GUI, and if it is not selected the run will fail.

The guidance scale constraints are model specific as well. For SD 3.5 Medium Turbo the guidance scale should be between 0.0 and 1.0, since anything greater will result in a failure, and the Turbo version can generate valid images in as few as 4 iterations. For SDXL Turbo the guidance scale is again 0.0 to 1.0 and the number of inference steps should be between 2 and 5 for the best result.

## Installing on Windows and Linux

Installation is documented per platform, with the repository carrying install.bat, install.ps1 and install.sh alongside the Docs/ directory.

For Windows, the README points to a user guide for Windows users in Docs/user_guide_for_windows_users.md. For Linux, the details are in the Linux Installation Guide.

The Linux section carries the constraints that decide whether this works for you at all. The plugin is tested on Ubuntu 24.04, building GIMP from source is recommended, and Flatpak is not supported. The recommendation to build GIMP from source is worth pausing on, because it means the supported path on Linux is not the packaged GIMP most users have, and the flatpak build is ruled out entirely.

The rest of the tree supports the installation story. There is a model_setup.py, which is the model download and conversion step referenced by the inpainting and Controlnet instructions, a weights/ directory, a thirdparty/ directory, a gimpopenvino/ directory holding the plugin package itself, testcases/ and sampleinput/ directories, and a security.md alongside the CODE_OF_CONDUCT.md and CONTRIBUTING.md files.

## The version number comes from a git tag

The packaging has one detail that is genuinely instructive rather than incidental, and it is in setup.py.

The plugin version is not hard coded. A helper function retrieves it through git, running the describe command against the tags and falling back to a development string when git is unavailable:

```python
        raw_version = subprocess.check_output(
            ["git", "describe", "--tags"],
            cwd=file_dir,
            encoding="utf-8"
        ).strip()
```

The output of that command is a tag optionally followed by the number of commits since the tag and an abbreviated commit hash, and the code then normalises it into a PEP 440 compliant string. The docstring explains the reasoning in the maintainer's own terms, with an example showing how a commit exactly at tag 1.0.0 produces 1.0.0, while a commit ten later produces something like 1.0.0-10-g3ab12ef.

The effect is that a build from a tagged commit carries that tag, and a build from a working tree says how far it is from the last tag. For a plugin that people install by copying files into a GIMP directory rather than through a package index, having the version reflect the exact source is the difference between a reproducible install and a mystery.

## Where this plugin set is the wrong tool

Three cases point elsewhere.

The first is a workflow that is not GIMP. The plugins are GIMP plugins, they appear in the layers menu, and the objective list says the goal is to add AI to routine image editing workflows within GIMP. If you generate images in a browser tab or a dedicated application, this is a detour with a heavyweight runtime attached.

The second is a machine without the right hardware, or a Linux setup that does not match the tested configuration. The plugin compiles models onto a CPU, GPU or NPU through OpenVINO, and the NPU guidance in the README is specific to Intel hardware with particular models. On Linux the tested configuration is Ubuntu 24.04 with GIMP built from source, and Flatpak is not supported, so a distribution packaged GIMP or a flatpak install is outside what the project has verified.

The third is a need for a stable, versioned dependency. The releases move, 3.3.0 dated 2026-06-23 after 3.2.1 and 3.2.0, but a plugin installed by copying files carries no dependency resolution, and the README does not document an upgrade procedure or a compatibility matrix across GIMP versions.

There is one more cost that the README states plainly and that is easy to underestimate. The very first time you do Load Models it may take a few minutes, with subsequent runs much faster once the model is cached, and FastSD models are downloaded at runtime the first time they are used. For a plugin whose whole point is interactive editing, the first run of each new model is a wait, and the cache that removes it is per machine.

## Conclusion

Adopt these plugins if you run GIMP 3 on a machine with Intel hardware and want Stable Diffusion, FastSD, semantic segmentation or super resolution available from inside the editor without leaving it for a separate web interface. Do not adopt them if you need a general purpose image editor with AI anywhere, since the plugins are bound to GIMP 3 and Python 3, or if you are on Linux and rely on a Flatpak GIMP, which the README states is not supported. Verify three things first: which model and device combination you intend to use, since the guidance scale limits differ across SD 3.5 Turbo and SDXL Turbo and the Controlnet modes fail if the Use Initial Image option is not selected; that you can tolerate the first model load, which the README warns can take several minutes before the model is cached; and which install script suits your platform, with install.sh, install.bat and install.ps1 in the tree and separate guides for Windows and Linux. The licence is Apache-2.0, the newest release is 3.3.0 dated 2026-06-23, and the last push was on 2026-10-12.

## FAQ

### What AI features do the OpenVINO GIMP plugins add?

The plugin set covers super resolution, semantic segmentation, Stable Diffusion and FastSD. The Stable Diffusion family includes SD 1.5 variants, SDXL, SD 3.0 Medium, SD 3.5 Medium Turbo, inpainting and three Controlnet modes for OpenPose, CannyEdge and Scribble.

### How do I run a Stable Diffusion generation in the plugin?

Select Stable Diffusion from the drop down list in layers, choose the model and Power Mode, and click Load Models to compile and load the model on the device, which you only need to repeat if you change the model or device. Then enter the prompt and parameters and click Generate.

### Why does the inpainting model not appear in the model list?

The README says you will only see the inpainting models in the drop down menu if you added a mask layer to your image. The sequence is to select the area with the Free select tool, then add a layer mask and choose Selection in the Initialize layer Mask to field, on a 512x512 image.

### What are the requirements for installing the plugins on Linux?

The plugin is tested on Ubuntu 24.04, building GIMP from source is recommended, and Flatpak is not supported. Detailed steps are in the Linux Installation Guide in the Docs directory.

### How does FastSD differ from the other Stable Diffusion models here?

FastSD is a faster version of stable diffusion based on Latent Consistency Models and Adversarial Diffusion Distillation, supporting CPU, GPU and NPU inference through OpenVINO. Its models can be edited with the FastSD Model Manager and are downloaded at runtime the first time they are used.

## Sources

- [intel/openvino-ai-plugins-gimp on GitHub](https://github.com/intel/openvino-ai-plugins-gimp)
- [Issues](https://github.com/intel/openvino-ai-plugins-gimp/issues)
- [License: Apache-2.0](https://github.com/intel/openvino-ai-plugins-gimp/blob/main/LICENSE)
- [README](https://github.com/intel/openvino-ai-plugins-gimp/blob/main/README.md)
- [Releases](https://github.com/intel/openvino-ai-plugins-gimp/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/intel-openvino-ai-plugins-gimp