How to Resize an Image in GIMP: 3 Methods (2.10.38)

GIMP gives you three distinct ways to resize an image, and picking the wrong one leads to blurry results or unexpected cropping. This guide covers all three — Scale Image for straightforward resizing, Canvas Size for adding or removing space around your image, and Script-Fu for batch resizing dozens of files at once — all tested on GIMP 2.10.38.

Need a quick resize without opening desktop software? Pixotter's browser-based resize tool handles it in seconds with no installation and no file uploads to external servers.

If you are new to GIMP, our complete GIMP photo editing guide covers the fundamentals before you dive into resizing specifics.

Methods at a Glance

Before walking through each method, here is a quick comparison to help you pick the right approach:

For general resizing principles that apply across all tools, see our how to resize a photo guide.

Method 1: Scale Image (The Standard Resize)

Scale Image is what most people mean when they say "resize." It changes the actual pixel dimensions of your image — making a 4000×3000 photo into a 1200×900 one, for example.

Step 1: Open Your Image

Launch GIMP 2.10.38 and go to File → Open (or press Ctrl+O). Navigate to your image and click Open. The current dimensions appear in the title bar — note them so you know your starting point.

Step 2: Open the Scale Image Dialog

Go to Image → Scale Image. This opens a dialog with two main sections: Image Size and Quality.

Step 3: Set Your Target Dimensions

In the Width and Height fields, enter your desired dimensions in pixels. By default, the chain link icon between width and height is locked — this preserves the aspect ratio. When you change the width, the height updates automatically.

To resize to a specific width and height independently (which will distort the image), click the chain link icon to unlock it. Only do this if you specifically need non-proportional scaling.

Tip: Use the dropdown next to the dimension fields to switch between pixels, inches, millimeters, and percentages. Percentage mode is useful when you want to scale to exactly 50% or 25% of the original.

Step 4: Choose an Interpolation Method

Under Quality, the Interpolation dropdown controls how GIMP calculates new pixel values:

• None — Fastest, but produces jagged edges. Only useful for pixel art where you want hard edges preserved.
• Linear — Decent quality, fast. Good for quick previews.
• Cubic — Best balance of quality and speed. This is the default and the right choice for most images.
• NoHalo / LoHalo — Designed to reduce halo artifacts around high-contrast edges. Use NoHalo for downscaling photographs. LoHalo works better for moderate size reductions.

For downscaling photos for web use, Cubic or NoHalo both produce sharp results. For upscaling, no interpolation method will add real detail — consider whether you actually need a larger image or if your layout can use the image at its native size.

Step 5: Apply and Export

Click Scale. GIMP resizes the image. Go to File → Export As (Shift+Ctrl+E) to save. GIMP's "Save" creates an .xcf project file — Export As gives you the JPEG, PNG, or WebP you actually need.

For lossy formats like JPEG, the export dialog lets you set quality (85-92 is the sweet spot for web images). For lossless formats like PNG, quality is preserved but file size is larger. Our resize without losing quality guide covers the tradeoffs in depth.

Method 2: Canvas Size (Add or Remove Space)

Canvas Size does not scale your pixels. It changes the working area around your image — like putting a photo in a larger frame or trimming the edges. The image itself stays at full resolution.

Step 1: Open the Canvas Size Dialog

With your image open, go to Image → Canvas Size. The dialog shows the current canvas dimensions and a preview.

Step 2: Set the New Canvas Dimensions

Enter your desired canvas width and height. If the new dimensions are larger than the current image, GIMP adds empty space. If smaller, it crops the edges.

The chain link icon works the same as in Scale Image — lock it to change both dimensions proportionally, unlock for independent control.

Step 3: Position the Image on the Canvas

This is the critical step most tutorials skip. The Offset values control where your original image sits within the new canvas.

• Click Center to place the image in the middle of the new canvas (equal borders on all sides).
• Manually enter X and Y offset values for precise placement. An offset of 0, 0 puts the image in the top-left corner.

The preview area below shows a thumbnail of the result. The dark area is the original image; the lighter area is the new canvas space.

Step 4: Resize and Flatten

Click Resize. The canvas changes, but the new space appears as transparent (shown by the checkerboard pattern in GIMP). To fill it with a color:

1. Set your desired background color in the toolbox.
2. Go to Image → Flatten Image — this replaces transparency with the background color.
3. Or use Filters → Light and Shadow → Drop Shadow if you want a bordered effect.

Step 5: Export

File → Export As to save. Same as Method 1 — "Export As" for final output, "Save" for the GIMP project file.

Common Canvas Size Use Cases

• Adding a white border for Instagram: Make canvas 100px wider and 100px taller than the image, center the image, flatten with white background.
• Converting landscape to square: Set canvas to a square matching the image height, center horizontally. The sides get filled with your background color.
• Cropping without the crop tool: Reduce canvas size and position the image so the part you want fills the canvas. More precise than the freehand crop tool for exact pixel-level control.

Method 3: Batch Resize with Script-Fu

When you need to resize 10, 50, or 500 images to the same dimensions, opening each one manually is not a realistic option. GIMP 2.10.38 includes Script-Fu, a Scheme-based scripting console that automates repetitive tasks.

The Batch Resize Script

Open Filters → Script-Fu → Console and paste:

(let* (
  (target-width 1200)
  (target-height 0)  ; 0 = auto-calculate from aspect ratio
  (source-dir "/home/user/images/originals/")
  (dest-dir "/home/user/images/resized/")
  (filelist (cadr (file-glob (string-append source-dir "*.jpg") 1)))
)
(while (not (null? filelist))
  (let* (
    (filename (car filelist))
    (image (car (gimp-file-load RUN-NONINTERACTIVE filename filename)))
    (drawable (car (gimp-image-get-active-drawable image)))
    (orig-width (car (gimp-image-width image)))
    (orig-height (car (gimp-image-height image)))
    (ratio (/ orig-height orig-width))
    (new-width target-width)
    (new-height (if (= target-height 0)
                    (inexact->exact (round (* target-width ratio)))
                    target-height))
    (dest-file (string-append dest-dir (car (last (strbreakup filename "/")))))
  )
  (gimp-image-scale-full image new-width new-height INTERPOLATION-CUBIC)
  (file-jpeg-save RUN-NONINTERACTIVE image
    (car (gimp-image-flatten image))
    dest-file dest-file
    0.85 0.0 0 0 "" 0 0 0 2)
  (gimp-image-delete image)
  )
  (set! filelist (cdr filelist))
))

What This Script Does

1. Sets a target width of 1200px (change this to your needs).
2. Calculates height automatically to preserve the aspect ratio (set target-height to a specific value to override).
3. Loops through every .jpg file in the source directory.
4. Scales each image using cubic interpolation.
5. Saves the result to the destination directory at 85% JPEG quality.

Customizing the Script

• Change the file format: Replace "*.jpg" with "*.png" or "*.webp" and use the corresponding save function (file-png-save or file-webp-save).
• Change JPEG quality: The 0.85 value controls quality (0.0 to 1.0). For web use, 0.85 gives excellent results at reasonable file sizes.
• Process subdirectories: Script-Fu's file-glob does not recurse into subdirectories. For nested folder structures, use GIMP's Python-Fu console or an external tool.

When Script-Fu Falls Short

Script-Fu is powerful for straightforward batch jobs but awkward for complex workflows. If you need conditional logic (resize landscape images differently from portrait ones), output format conversion, or metadata preservation, GIMP's Python-Fu or a dedicated batch tool is a better choice.

For batch resizing without scripting at all, Pixotter's resize tool handles multiple images through drag-and-drop — set your target dimensions once and process all files in your browser.

When to Use Each Method

Use Scale Image when you need to change the actual pixel dimensions of a single image. This covers 90% of resize tasks: making photos smaller for web use, preparing images for a specific platform requirement, or reducing file size through dimension reduction.

Use Canvas Size when you need the pixels to stay untouched but the image boundary to change. Social media templates, print borders, and precise cropping without the crop tool. The image quality stays identical because no pixel resampling happens.

Use Script-Fu when you have a batch of images that all need the same treatment. The setup time is higher, but it pays off at roughly 5+ images. Below that, manual Scale Image is faster.

If you frequently compare GIMP to other tools for these tasks, our Photoshop vs GIMP comparison breaks down where each tool excels.

Quick Decision Flowchart

1. How many images? → More than 5 of the same resize? Script-Fu. Otherwise, continue.
2. Do you need to change pixel dimensions? → Yes: Scale Image. No: continue.
3. Do you need to add/remove space around the image? → Yes: Canvas Size.

Frequently Asked Questions

How do I resize an image in GIMP without losing quality?

Downscaling (making an image smaller) preserves quality well — you are discarding pixels, not inventing them. Use Cubic or NoHalo interpolation for the sharpest results. Upscaling always degrades quality because GIMP must interpolate new pixel data that does not exist in the original. If you need a larger image, start with the highest resolution source available. See our resize without losing quality guide for format-specific advice.

Can GIMP batch resize images?

Yes. GIMP 2.10.38 includes Script-Fu (Scheme-based) and Python-Fu consoles that can process multiple images. The Script-Fu example in Method 3 above handles the most common batch resize scenario. For more complex workflows, Python-Fu offers better control flow and error handling.

What is the difference between Scale Image and Canvas Size in GIMP?

Scale Image changes pixel dimensions — your 4000×3000 image becomes a 1200×900 image with resampled pixels. Canvas Size changes the working area without resampling — your image keeps its original pixels, but the boundary around it grows or shrinks. Scale Image affects quality (especially when upscaling); Canvas Size never affects quality.

What interpolation should I use when resizing in GIMP?

Cubic is the default and works well for most cases. NoHalo is slightly better for downscaling photographs because it reduces halos around high-contrast edges. None is only useful for pixel art where you want hard edges. Avoid Linear for final output — it exists mainly for speed during previews.

How do I resize an image to an exact file size in GIMP?

GIMP does not have a "resize to X kilobytes" feature. Instead, resize to your target dimensions with Scale Image, then adjust the compression level during export. For JPEG, lower the quality slider until the file size target is met. For a tool that handles this automatically, Pixotter's compression tool lets you set a target file size and adjusts quality to hit it.

Does GIMP support WebP export after resizing?

GIMP 2.10.38 supports WebP export natively. After resizing, go to File → Export As, change the file extension to .webp, and click Export. The WebP options dialog lets you choose between lossy and lossless compression with a quality slider. WebP typically produces files 25-35% smaller than equivalent-quality JPEG.