> ## 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.

# BIMP for GIMP 3: batch resize images with Batcher
- URL: https://thegimp.net/batch-resize-gimp-bimp/
- Published: 2026-11-15T14:07:00.000Z
- Updated: 2026-11-18T13:35:03.000Z
- Description: Check BIMP compatibility, then set up Batcher for whole-image resizing with safe output settings and a small pilot batch.
- Author: Elena Morris
- Tags: Plug-ins and scripts

To batch resize images in GIMP 3, use **Batcher** and choose **File > Batch Convert…**. The original BIMP plug-in belongs to the GIMP 2 workflow and has no GIMP 3 version. I'd keep the source folder untouched and export copies: size limits, remembered actions and duplicate filenames can otherwise affect every file in the job. For a mixed folder, the settings below handle portraits, panoramas and already-small images separately from the simpler one-pass recipe.

- [Install the right plug-in](#install-batcher)
- [Choose inputs and a safe destination](#prepare-inputs)
- [Choose width, bounds or a fixed canvas](#choose-size)
- [Resize mixed sizes without enlargement](#mixed-sizes)
- [Set format, names and overwrite behaviour](#export-settings)
- [Check the pilot and finish the batch](#verify-batch)

## BIMP or Batcher: check the GIMP version first

The [original BIMP project](https://alessandrofrancesconi.it/projects/bimp/?ref=thegimp.net) adds **File > Batch Image Manipulation…** to the older GIMP workflow. Its Flathub package is explicitly retired because [BIMP has no GIMP 3 version](https://github.com/flathub/org.gimp.GIMP.Plugin.BIMP/blob/master/flathub.json?ref=thegimp.net). An old BIMP installer won't add the Batcher commands to GIMP 3.

If you deliberately retain GIMP 2.10, follow BIMP's own installation instructions for that copy. For GIMP 3, use the [maintainer's Batcher download and installation instructions](https://kamilburda.github.io/batcher/docs/installation/?ref=thegimp.net). The two plug-ins have different menus and saved settings; don't expect a BIMP tutorial's buttons to match Batcher.

This guide uses [Batcher 1.2.10](https://github.com/kamilburda/batcher/releases/tag/1.2.10?ref=thegimp.net), which added the **When to scale** choices used below. Batcher requires GIMP 3.0 or later; GIMP 3.2 needs Batcher 1.2.2 or later. Update an older Batcher installation to 1.2.10 before following the conditional-resizing recipe.

### Install the complete folder, then restart GIMP

1. Download the release ZIP from Batcher's installation page and extract it.
2. In GIMP on Windows or Linux, open **Edit > Preferences > Folders > Plug-Ins**. On macOS, open **GIMP > Preferences** (or **Settings**), then **Folders > Plug-Ins**.
3. Copy the complete `batcher` folder into the appropriate plug-ins folder. Keep `batcher.py` and all its companion files inside it; copying that Python file alone is insufficient.
4. Restart GIMP, then look for **File > Batch Convert…**.

```
plug-ins/
└── batcher/
    ├── batcher.py
    └── …other Batcher files and folders…
```

Use the paths shown by the GIMP copy you actually launch. Our [plug-in installation guide](https://thegimp.net/install-gimp-plugins/) explains folder structure and permissions when a plug-in doesn't appear.

__Platform conditions that can prevent Batcher loading__
| Installation              | Check                                                                                                                                                                                             |
| ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Windows                   | GIMP 3.0.0-1 or later is required, rather than the initial 3.0.0 package. Python plug-in support must be enabled in the gimp.org installer; the Microsoft Store version enables it automatically. |
| Linux Snap                | The Batcher maintainer lists this channel as unsupported. Use a documented installation route rather than copying a GIMP 2 BIMP binary into it.                                                   |
| Linux Flatpak or AppImage | Follow the channel-specific section of the installation page. Don't assume a different GIMP installation uses the same plug-ins directory.                                                        |
| Other Linux packages      | The maintainer lists Python 3.7+, Pycairo with GObject support, and GExiv2 GObject bindings. Check your distribution's dependencies if the command is missing.                                    |

## Add the files and choose a separate output folder

Use **Batch Convert** for files on disk. It doesn't require you to open every photograph on the GIMP canvas. Start with representative inputs: a landscape, a portrait, a narrow panorama and a small image. Include a transparent PNG if the real job contains transparency.

1. Choose **File > Batch Convert…**.
2. Press **+** beside **Input Images** to add files or folders, or drag them from your file manager into that area.
3. Under **Output Folder**, choose a new pilot destination such as `Pictures/Resized-pilot`. Keep it outside the input folder tree so a later run doesn't pick up its own previous outputs.
4. Leave **Match input folders** off. The [Batcher usage guide warns that it exports beside the inputs](https://kamilburda.github.io/batcher/docs/usage/?ref=thegimp.net), where matching names and extensions can overwrite originals.
5. Read the existing **Actions** and **Conditions**. Disable or remove remembered adjustments before building this job; don't leave an old Scale action running alongside a new recipe.

[![Batcher Batch Convert dialog in GIMP with the output folder C:\Users\User\Pictures\Resized, png as the file format, the Remove Folder Structure and Scale actions unchecked, the Recognized File Format condition, and Input Images listing a Holiday folder, harbour.jpg and lighthouse.jpg](https://storage.ghost.io/c/da/21/da2186e6-6044-4206-b621-584ed1984ab7/content/images/2026/11/24-gimp-ui-gimp-3-plugins-0-1863c93f7175.webp)](https://storage.ghost.io/c/da/21/da2186e6-6044-4206-b621-584ed1984ab7/content/images/2026/11/24-gimp-ui-gimp-3-plugins-0-1863c93f7175.webp?ref=thegimp.net)

Choose a separate output folder and review the inputs before configuring the resize actions; Scale is still disabled in this view. [Open the Batch Convert controls at full size](https://storage.ghost.io/c/da/21/da2186e6-6044-4206-b621-584ed1984ab7/content/images/2026/11/24-gimp-ui-gimp-3-plugins-0-1863c93f7175.webp?ref=thegimp.net).

Keep the pilot input list small. Batcher warns about accidentally adding very large folders, but that warning can't tell whether you've chosen the right photographs.

## Decide what the output dimensions should mean

“Resize to 1600” needs a second decision: is 1600 the width, the longest permitted side, or the size of a square canvas? These choices produce different files.

__Choose the geometry before entering dimensions__
| Required output                 | Batcher Scale choice                   | Consequence                                                                                                |
| ------------------------------- | -------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
| A consistent width              | Match width (keep aspect ratio)        | Height follows the original proportions; a portrait can be much taller than the entered width.             |
| No side beyond a bounding box   | Fit within bounds                      | Both limits are respected while preserving proportions; a square limit doesn't make every picture square.  |
| An identical rectangular canvas | Fit to canvas                          | The image fits proportionally and the remaining space uses Padding color and Position.                     |
| A filled frame with no borders  | Crop to the required ratio, then scale | Some picture content must be removed. Check the subject's position before applying one crop to many files. |
| Independent width and height    | Stretch                                | Proportions can change. A circle can become an oval.                                                       |

The [Scale, Crop and Resize Canvas reference](https://kamilburda.github.io/batcher/docs/actions/?ref=thegimp.net) defines these operations. **Resize Canvas** adds space or removes edges without resampling the picture. Use **Scale** to change its pixel dimensions; use our [cropping guide](https://thegimp.net/gimp-crop-image/) when each photograph needs its own framing decision.

### One pass for a folder of known large photographs

Add a fresh **Scale** action through **Add Action…**, and open its edit settings. Set **Apply to (image or layer)** to the current image, **How to scale** to **Fit within bounds**, and both dimensions to **1600 px**. For photographs, start with **Interpolation: Cubic**; the quality section below explains what to inspect.

With **When to scale: Always**, a 4000 × 3000 landscape fits at 1600 × 1200; a 3000 × 4000 portrait fits at 1200 × 1600\. This is a straightforward single resampling pass when all inputs need reducing. It can enlarge a small file, so don't use it unchanged for a mixed archive.

## For mixed sizes without enlargement, cap each axis separately

I'd use two conditional Scale actions for a folder that includes small files and unusually wide or tall images. The reason is a detail in [Batcher 1.2.10's Scale logic](https://github.com/kamilburda/batcher/blob/19fb92bfe8942bcd269099488fd45e87a204d743/batcher/src/builtin%5Factions/%5Fscale.py?ref=thegimp.net): **Larger than new dimensions** checks both entered dimensions before calculating the proportional fit. With a 1600 × 1600 box, a 4000 × 1000 panorama fails the height check and can be left at 4000 pixels wide.

The following setup compares one axis at a time. Create each action fresh, because its unused dimension must remain at **100%**. Don't duplicate an already-configured 1600 × 1600 action and assume its unused field resets.

### First action: limit the width

1. Add a fresh **Scale** action for the **current image**.
2. Before changing the scaling method, confirm the unused **Height** remains at its default **100%**.
3. Choose **Match width (keep aspect ratio)** and enter **Width: 1600 px**.
4. For photographs, choose **Interpolation: Cubic** and set **When to scale** to **Larger than new dimensions**.

The height comparison now uses the image's own height. The width is reduced only when it reaches or exceeds the specified limit; a narrower input isn't enlarged.

### Second action: limit the height

1. Add another **fresh Scale** action after the first.
2. Keep its unused **Width** at the default **100%**.
3. Choose **Match height (keep aspect ratio)** and enter **Height: 1600 px**.
4. Use the same interpolation method and **Larger than new dimensions** condition.

Leave both actions enabled and in that order. The second action sees the dimensions produced by the first, so it caps any remaining excess height. Export after both actions. This bounds both axes without enlarging small inputs; a large portrait may be resampled twice. For a known set of large photographs, the earlier one-pass fit avoids that extra resampling.

__Calculated checkpoints for the two-action, 1600-pixel recipe__
| Input       | Expected output | Check                                             |
| ----------- | --------------- | ------------------------------------------------- |
| 4000 × 3000 | 1600 × 1200     | Landscape fits proportionally.                    |
| 3000 × 4000 | 1200 × 1600     | Portrait reaches the height limit.                |
| 4000 × 1000 | 1600 × 400      | Narrow panorama isn't skipped.                    |
| 1000 × 4000 | 400 × 1600      | Narrow vertical image is reduced.                 |
| 600 × 800   | 600 × 800       | Already-small input retains its pixel dimensions. |

Other proportions can round to the nearest pixel. Confirm the actual exported files before committing the whole folder, especially after loading settings made with another Batcher version.

## Choose interpolation; don't confuse pixels with DPI

For ordinary photographs, I'd start with **Cubic**, then inspect fine edges and lettering in the pilot exports at 100%. Batcher 1.2.10's fresh Scale action defaults to **None**, so choosing a proportion-preserving method alone isn't a complete quality setup.

The [GIMP interpolation reference](https://docs.gimp.org/3.2/en/gimp-tools-transform.html?ref=thegimp.net#gimp-tool-interpolation) explains that None copies the nearest pixel and can produce stepped edges. Cubic, LoHalo and NoHalo use different resampling methods; judge them on the actual content rather than assuming one setting is best for every photograph.

For web dimensions, enter **px**. Changing only **Set image resolution in DPI** is not a substitute for reducing the pixel count. The [Scale Image manual separates pixel dimensions from printing resolution](https://docs.gimp.org/3.2/en/gimp-image-scale.html?ref=thegimp.net). A 4000-pixel-wide image doesn't become a 1600-pixel image merely because its resolution field says 72.

## Set the format, filename and collision rule before running

In the main dialog's **Filename and Format** area, choose or type the output extension. Open the gear button's **Export Options** to inspect the format settings and collision behaviour.

- **JPEG:** suitable for an opaque photograph. It cannot retain transparency; inspect the chosen background and compression in a real exported file.
- **PNG:** use it when the output needs transparency or lossless pixel storage. Keep an alpha-preserving layer-handling setting.
- **WebP:** useful when your destination accepts it; choose its lossy or lossless options according to the deliverable.

Resizing and compression are different controls. If a file must fit a byte-size limit, check the exported size and visual quality; the same pixel dimensions don't guarantee the same number of bytes across photographs. Keep the originals and XCF masters outside this derivative-file workflow.

### Make filenames unique, including across source folders

For recognisable derivatives, Batcher's [filename patterns](https://kamilburda.github.io/batcher/docs/renaming/?ref=thegimp.net) allow `[image name]-web`. Review the names in the input list. Two source folders can both contain `photo.jpg`, so that suffix alone doesn't prevent collisions in a flat destination.

Leave **Remove Folder Structure** unchecked if you need the input hierarchy. If you intentionally flatten it, a pattern such as `web-[001, %n]` continues numbering across folders instead of restarting in each one. Keep the input order and a record of the job if those generated names must be traceable to originals.

Under **If a file exists**, keep **Ask** for the pilot. The [export-options reference](https://kamilburda.github.io/batcher/docs/export-options/?ref=thegimp.net) explains that **Replace** automatically replaces every matching existing file. A separate destination protects the source folder, but it doesn't protect one output from another output with the same name.

### Check the less visible export options

Keep **Perform export** at **For each image** for separate resized photographs. Check **Use original file extension** as well: if enabled, it can override the extension you've chosen for individual inputs.

Under **Layer handling**, **Merge and add alpha** retains an alpha channel in the merged image. **Merge and remove alpha** fills it with the selected background colour. If the output must retain layers or filters in a supporting format, choose **Keep layers**; a finished JPEG or PNG isn't an editable XCF master.

Review EXIF, colour-profile and other metadata options for the destination. Batcher's **Rotate or flip image based on Exif metadata** option has a specific warning: enabling it while also saving EXIF can produce unexpected results. Include an orientation-tagged camera photograph in the pilot, decide whether EXIF is retained, and check the exported orientation. Don't enable both options blindly.

## Run the pilot, inspect the files, then process the remainder

Press **Run** and inspect the destination. The preview is useful for framing, but [Batcher describes it as an approximation](https://kamilburda.github.io/batcher/docs/usage/?ref=thegimp.net): a JPEG preview may show transparency and omit compression artefacts that the actual JPEG cannot avoid.

1. Open each pilot export and check its pixel dimensions, including the panorama and already-small file.
2. Inspect fine edges, text and colour at 100% zoom. Check orientation and any transparent boundary against a contrasting background.
3. Compare expected and actual filenames and counts, allowing for deliberately skipped files. Check the two same-name inputs if the real job contains them.
4. Confirm the originals still exist in their original location and retain their dimensions. Keep the pilot outputs separate from the final inputs.
5. Clear the pilot input list with **− > Remove All**, add the complete intended source set, and choose a separate final destination such as `Pictures/Resized`. Review the actions and collision rule, then run the full batch. Reconcile its count and inspect outputs from each input group.

Published [Batcher user checks on GimpChat](https://gimpchat.com/viewtopic.php?f=9&t=21588&ref=thegimp.net) confirm practical plug-in detection and saved-action workflows, while also documenting early-version settings defects and fixes. Review a loaded configuration before reusing it. I'd accept the batch from its exported files, rather than from a completed progress bar.

## If the command, files or dimensions are wrong

__Diagnose the failed stage before changing the whole recipe__
| Symptom                                         | Check first                                                                                                                                         |
| ----------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
| No Batch Convert command                        | Correct GIMP copy, complete batcher folder, supported installation channel and Python support. Restart after installation.                          |
| No When to scale setting                        | The recipe requires Batcher 1.2.10\. An earlier compatible release may load in GIMP 3.2 without having that setting.                                |
| A panorama stays too large                      | The single bounding-box condition checks both entered dimensions. For the two-action recipe, check the unused 100% fields and both enabled actions. |
| Pictures stretch or become unexpectedly huge    | Pixels versus percentages, How to scale, the current-image target and any later canvas/crop action.                                                 |
| Files are missing                               | Active conditions, Recognized File Format, collision choices and Settings > View Logs. A filter can exclude a file without a failed resize.         |
| An old adjustment or unexpected crop appears    | Remembered Actions and the order in which they're applied. Disable the unwanted action and repeat the pilot from originals.                         |
| Outputs are sideways or transparency disappears | EXIF orientation/saving, output format and Layer handling; inspect actual files instead of trusting the preview.                                    |

**Recognized File Format** filters unrecognised extensions by default. If you're using a documented third-party loader, the usage guide permits disabling that condition; it doesn't make an unsupported or damaged file readable. For failures, retain the exact error from **Settings > View Logs** and identify the input that caused it.

## Save the working configuration for the next batch

Use **Settings > Save Settings to File…** after the pilot succeeds. Batcher also saves settings automatically after successful processing, including the destination, extension, actions and conditions. Loading a configuration later doesn't establish that its paths or collision rules suit a new folder.

Keep the processing mode straight. **Batch Convert** reads disk files; **File > Export Images…** handles images already open in GIMP. **Edit and Save Images…** can save open images in place, so it serves a different purpose from making resized delivery copies.

For one photograph that needs its own crop or careful sharpening, I'd use the [single-image resize workflow](https://thegimp.net/gimp-resize-image/). Use the batch once the same sizing and export decisions are right for the group.