Choosing Bit‑Depth Precision in GIMP 2.10+: 8‑bit, 16‑bit, or 32‑bit Float for Your Workflow

Decision and constraints

GIMP 2.10 and later route all pixel operations through GEGL, which lets you pick a per‑image precision of 8‑bit integer, 16‑bit integer (linear or perceptual), or 32‑bit floating‑point linear. The choice affects memory use, processing speed, filter availability, and what you can export without data loss. Decide early—changing precision later forces a conversion that may clip or dither data.

Supported precision options at a glance

Precision	Typical use case	Memory (24 MP RGBA)	Filter support	Export formats that keep depth	Key limitation
8‑bit integer	Web graphics, quick edits, low‑RAM machines	~92 MB	All legacy plug‑ins + GEGL filters	JPEG, WebP, sRGB PNG (native)	Banding on strong curves; no HDR headroom
16‑bit integer (linear / perceptual)	Print work, wide‑gamut (Rec.2020, ACES), non‑destructive grading	~184 MB	All GEGL‑based filters; legacy plug‑ins force 8‑bit conversion	PNG, TIFF, OpenEXR (16‑bit)	Still integer – extreme exposure pushes may clip
32‑bit float linear	HDR compositing, scientific imaging, maximum latitude	~370 MB	All GEGL filters; some ops fall back to generic float loops	OpenEXR, TIFF (float), PNG (16‑bit only)	Highest RAM/CPU; OpenCL often disabled; 32‑bit builds can’t address >2 GB

Trade‑offs explained

Memory and performance

Memory scales linearly with bit‑depth. A 24 MP image at 32‑bit float RGBA consumes roughly 370 MB versus 92 MB at 8‑bit. Gaussian Blur at radius 50 on a 24 MP canvas shows the same scaling: CPU time roughly doubles from 8‑bit to 16‑bit and again to 32‑bit float because GEGL processes more data per pixel. OpenCL acceleration in GIMP 2.10.x is experimental; even when enabled, many 32‑bit float ops fall back to the CPU.

Filter compatibility

All filters under Colors, Filters → Generic, Blur, and Enhance are GEGL‑native and honor the current image precision. Legacy Script‑Fu scripts and some third‑party plug‑ins (e.g., older GMIC builds, Resynthesizer) internally down‑convert to 8‑bit, discarding high‑bit data. Always check the plug‑in release notes for “GEGL‑native” or “high‑bit support” before committing to a 16/32‑bit workflow.

Export constraints

PNG and TIFF can store 16‑bit per channel; OpenEXR and TIFF (float) store 32‑bit float. JPEG, WebP, and sRGB PNG require an 8‑bit conversion. GIMP offers Floyd‑Steinberg dithering or no dithering on that conversion—global only, not per‑channel. ICC profiles are embedded at the chosen precision, and soft‑proofing (lcms2) operates at image precision, so 32‑bit float linear avoids gamut clipping during proofing transforms.

Concrete validation workflow

Follow these steps to verify which precision meets your quality and performance needs. Run them on a 64‑bit GIMP build (Help → About shows “64‑bit” and GEGL ≥ 0.4.x).

1. Create a gradient test image

1. File → New → 24 MP (e.g., 6000 × 4000), RGB, 8‑bit integer.
2. Filters → Render → Gradient → choose “FG to BG (RGB)”, linear, full canvas.
3. Image → Precision → set to 16‑bit integer linear (repeat later for 32‑bit float linear).

2. Apply an extreme tonal curve

1. Colors → Curves → add a 5‑point S‑curve that pushes shadows to near‑black and highlights to near‑white.
2. Open Window → Dockable Dialogs → Histogram (set to “RGB” and “Linear”).
3. Observe banding: 8‑bit shows visible steps; 16‑bit and 32‑bit float should appear smooth.

3. Export round‑trip and inspect metadata

# Export as 16‑bit PNG (preserves depth)
gimp -i -b '(file-png-save2 RUN-NONINTERACTIVE image drawable "grad16.png" "grad16.png" 0 9 0 0 0 0 0 0 0)' -b '(gimp-quit 0)'
# Export as 8‑bit PNG with Floyd‑Steinberg dithering
gimp -i -b '(file-png-save2 RUN-NONINTERACTIVE image drawable "grad8.png" "grad8.png" 0 9 0 0 0 0 0 0 1)' -b '(gimp-quit 0)'

Then verify with ImageMagick and ExifTool (run in a terminal):

identify -verbose grad16.png | grep -E "Depth|Type|Colorspace"
identify -verbose grad8.png  | grep -E "Depth|Type|Colorspace"
exiftool grad16.png | grep -i "ICC"
exiftool grad8.png  | grep -i "ICC"

Expect Depth: 16-bit for the first file and Depth: 8-bit for the second; both should list an embedded ICC profile.

4. Measure memory pressure during a heavy filter

1. Open system monitor (htop, Task Manager, Activity Monitor).
2. With the gradient image at each precision, run Filters → Blur → Gaussian Blur radius 50.
3. Note peak RSS: ~180 MB (8‑bit), ~360 MB (16‑bit), ~720 MB (32‑bit float) plus GIMP overhead.

5. Test a third‑party plug‑in

1. Install a recent GMIC build (≥ 3.0).
2. On a 16‑bit image, run GMIC → Details → Sharpen (Deblur).
3. After the filter, check Image → Precision – it should still read “16‑bit integer linear”. If it reverted to 8‑bit, the plug‑in down‑converted.

Limitations and practical checks

• OpenCL is off by default; enabling it (Edit → Preferences → System Resources) may speed 8‑/16‑bit ops but rarely helps 32‑bit float.
• 32‑bit GIMP builds cannot address images larger than 2 GB; use the 64‑bit installer.
• Dithering on 8‑bit export is global; smooth gradients may show noise. If that’s unacceptable, stay in 16‑bit and deliver TIFF/PNG‑16.
• XCF saves the precision setting, but GIMP < 2.10 discards high‑bit data. For cross‑version exchange use OpenRaster (.ora) or layered TIFF.

Quick decision checklist

• Need HDR headroom or scientific dynamic range? → 32‑bit float linear.
• Print or wide‑gamut work, moderate RAM? → 16‑bit integer linear.
• Web output, limited RAM, many legacy plug‑ins? → 8‑bit integer.

Run the gradient‑curve‑histogram test once per project to confirm the chosen precision behaves as expected before committing to a full edit session.