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

# Krita vs GIMP: choose by the painting, photo and handoff
- URL: https://thegimp.net/krita-vs-gimp/
- Published: 2026-11-13T14:07:00.000Z
- Updated: 2026-11-18T15:41:01.000Z
- Description: Krita suits a page built from brush strokes; GIMP suits a photo that needs repair. The native master and the file you must send decide the workflow.
- Author: Elena Morris
- Tags: Drawing and design

Choose Krita for drawing, painting, comics and hand-drawn animation; choose GIMP for photo repair, cutouts and composites. I'd learn Krita first if the brush marks are the work, and GIMP if the work is changing an existing photograph while protecting its texture and edges. Both can do parts of the other's job, so a mixed project needs a clear working master and a deliberate handoff.

## Choose by the change you'll need to make next

| Your main job                                    | My starting point                            | What to keep editable                                        |
| ------------------------------------------------ | -------------------------------------------- | ------------------------------------------------------------ |
| Sketch, ink or paint an illustration             | Krita                                        | Paint layers and masks in a KRA master                       |
| Retouch a photograph or isolate a product        | GIMP                                         | Photo layers, corrections and edge masks in XCF              |
| Draw comic panels or successive animation frames | Krita                                        | The drawing structure; for animation, its frames and timing  |
| Put a title over a corrected photograph          | GIMP                                         | Photo, text layer and mask separately                        |
| Paint over a repaired photograph                 | GIMP for the repair, Krita for the painting  | Both native masters and a separate exchange copy             |
| Supply an editable PSD                           | Check the recipient's required objects first | The native master plus a PSD checked in the receiving editor |

A drawing that will become a website image still belongs in Krita if painting is the substantial task. Equally, a photograph doesn't need a trip through Krita merely to become a PNG. Choose the tool for the edit, then choose an export for the destination.

## Krita has the stronger painting workspace; GIMP can draw too

Krita's [painting tools include specialised brush engines, stabilisers and drawing assistants](https://krita.org/en/features/?ref=thegimp.net). Color Smudge and Shape engines give different kinds of marks; the Dynamic Brush tool adds drag and mass. Vector tools support comic panels and speech bubbles alongside the painted artwork. These are useful reasons to start a drawn page there.

GIMP supports pressure-sensitive painting, custom dynamics and MyPaint brushes. Its [3.2 MyPaint update uses the v2 API and adds 20 brushes](https://www.gimp.org/release-notes/gimp-3.2.html?ref=thegimp.net), with support for canvas rotation and stylus barrel rotation where the hardware supplies it. Calling GIMP a mouse-only editor or saying it can't smooth a line gives the wrong answer.

For occasional line work, open the Paintbrush Tool Options and enable **Smooth stroke**. Its [Quality and Weight settings](https://docs.gimp.org/3.2/en/gimp-tools-paint.html?ref=thegimp.net) control the smoothing. Keep an arrow or a painted correction in the existing photo project when that avoids an unnecessary file exchange.

![GIMP 3.2 Paintbrush tool options with Smooth stroke checked, showing Quality 20 and Weight 50.0, and Pressure Size dynamics beside a yellow stroke on a photo](https://storage.ghost.io/c/da/21/da2186e6-6044-4206-b621-584ed1984ab7/content/images/2026/11/24-gimp-ui-krita-vs-gimp-0-60819cf183fa.webp)

Enable Smooth stroke in the Paintbrush Tool Options to reveal Quality and Weight, while paint dynamics connect brush parameters to input such as pen pressure. [Open the Paintbrush tool options at full size](https://storage.ghost.io/c/da/21/da2186e6-6044-4206-b621-584ed1984ab7/content/images/2026/11/24-gimp-ui-krita-vs-gimp-0-60819cf183fa.webp?ref=thegimp.net).

The larger difference is how much of the session involves choosing and controlling marks. Krita keeps that work central. I'd choose it for sustained inking and painting; the availability of a brush in GIMP doesn't make the two drawing workflows interchangeable.

## Separate a stabilised line from a slow brush

Krita's [Freehand Brush Tool smoothing](https://docs.krita.org/en/reference%5Fmanual/tools/freehand%5Fbrush.html?ref=thegimp.net) offers several behaviours. **No Smoothing** follows the input directly; **Basic Smoothing** makes a small correction; **Weighted smoothing** adds controls for distance, stroke ending and pressure. **Stabilizer** averages input and deliberately draws the line behind the cursor.

In Krita 5.3, the stabiliser's old distance control is replaced by **Sample Count at Max Speed** and **Sample Count at Min Speed**. The manual recommends less smoothing for fast strokes and more for slow strokes. **Delay** controls the dead zone around the cursor, while **Finish Line** completes the line. Increasing smoothing can therefore make an otherwise responsive brush feel detached from the pen.

For a fine detail that needs a direct response, I'd reduce smoothing before blaming the computer. For a long ink contour, some trailing distance is useful. Change one setting and compare the same kind of line, rather than switching brushes and smoothing together.

A stroke that updates in chunks on a large canvas is a different problem. [Krita's Instant Preview](https://docs.krita.org/en/reference%5Fmanual/instant%5Fpreview.html?ref=thegimp.net) draws feedback on a reduced canvas while calculating the full stroke in the background. It requires OpenGL 3.0 support and must be enabled in the View menu and the brush settings. At 100% zoom on a 4K image displayed on a 4K screen, the manual's example gets no speed-up because there is no smaller view to exploit.

Some brush operations disable Instant Preview; others can make the completed stroke appear to pop into place. Hover over the marked Instant Preview checkbox in the brush settings for its specific limitations. A complex brush, a long smoothing delay and missing tablet input need different fixes, and none establishes a universal speed winner.

## Check pressure input before changing applications

A constant-width line doesn't prove that pressure is unsupported. The application needs tablet events, and the selected brush must use pressure for something visible.

In Krita, use **Tablet Tester** in Tablet Settings. The [red line represents mouse events and the blue line represents tablet events](https://docs.krita.org/en/reference%5Fmanual/preferences/tablet%5Fsettings.html?ref=thegimp.net). With no blue line, Krita can't access the tablet. When blue events are present, check the preset's pressure response and the global pressure curve instead. The tester shows raw events, so it doesn't reflect changes to that curve.

On Windows, Krita's manual recommends **WinTab** for most Wacom tablets and suggests **Windows 8+ Pointer Input** for N-Trig devices or tablets that work poorly with WinTab. GIMP has its own advice: its [Pointer Input API preferences](https://docs.gimp.org/3.2/en/gimp-prefs-input-devices.html?ref=thegimp.net) favour **Windows Ink** for newer devices, with **Wintab** as the fallback. Don't copy an input recommendation from one application to the other.

![GIMP 3.2 Preferences on Windows at Input Devices with the Pointer Input API drop-down open, listing Wintab and Windows Ink under Extended Input Devices](https://storage.ghost.io/c/da/21/da2186e6-6044-4206-b621-584ed1984ab7/content/images/2026/11/24-gimp-ui-krita-vs-gimp-1-25fcd440759c.webp)

On Windows, GIMP's Input Devices preferences offer Windows Ink and Wintab under Pointer Input API, so try Wintab if Windows Ink doesn't work with your drawing device. [Open the Input Devices preferences at full size](https://storage.ghost.io/c/da/21/da2186e6-6044-4206-b621-584ed1984ab7/content/images/2026/11/24-gimp-ui-krita-vs-gimp-1-25fcd440759c.webp?ref=thegimp.net).

In GIMP, enable dynamics and choose a preset that connects pressure to size or opacity. The [Paint Dynamics matrix](https://docs.gimp.org/3.2/en/gimp-tool-dynamics.html?ref=thegimp.net) can map several brush parameters to pressure, velocity and tilt; a mouse can supply velocity but can't supply pen pressure.

## For photo repair, follow the source pixels and the edge

GIMP is my default for retouching and cutouts because the job centres on selecting, masking and borrowing existing texture. Its [Heal tool combines source pixels with the destination's surroundings](https://docs.gimp.org/3.2/en/gimp-tool-heal.html?ref=thegimp.net); Clone is useful when you need to copy the source more directly. Keep the original photo and make the repair on a duplicate you can compare with it.

For a cutout, use a [layer mask to control the visible edge](https://thegimp.net/gimp-layer-mask/), so the original pixels remain available when you reconsider the boundary. Look at both the edge and the nearby texture at the delivered size. Repeated patches, colour bleeding and an unnaturally hard outline matter more than whether the tool has a longer feature list.

Krita can repair images too. Its [Smart Patch tool fills a marked area using patterns already in the image](https://docs.krita.org/en/reference%5Fmanual/tools/smart%5Fpatch.html?ref=thegimp.net). Accuracy changes the amount of sampling and computation; Patch size changes the size of the reused pattern. I'd keep a small correction to a painted reference in Krita when that avoids moving an otherwise self-contained project. Smart Patch's existence doesn't settle which editor handles a particular photograph better.

For a camera RAW file, begin with a suitable RAW developer rather than choosing between these two by file extension. GIMP supports [external RAW editors including darktable, RawTherapee and ART](https://www.gimp.org/release-notes/gimp-3.2.html?ref=thegimp.net). Develop the RAW image there, then bring the rendered picture into GIMP for masking or retouching.

## Both can keep corrections reversible

Krita has two particularly useful filter arrangements. A [Filter Layer affects the layers beneath it](https://docs.krita.org/en/reference%5Fmanual/layers%5Fand%5Fmasks/filter%5Flayers.html?ref=thegimp.net); putting those layers into a group limits that scope. A [Filter Mask applies a change to its own layer through a mask](https://docs.krita.org/en/reference%5Fmanual/layers%5Fand%5Fmasks/filter%5Fmasks.html?ref=thegimp.net), with white including an area and black excluding it. Double-click the layer or mask to revise the filter settings.

That makes a practical difference when a painting needs a colour or blur adjustment after more strokes have been added. Krita's Filter Layers use native filters; the documentation explicitly excludes externally integrated G'MIC filters from that mechanism.

GIMP's [non-destructive GEGL filters can stay editable in XCF](https://www.gimp.org/release-notes/gimp-3.0.html?ref=thegimp.net). GIMP 3.2 also lets a [filter on an empty Pass through group affect the layers below](https://www.gimp.org/release-notes/gimp-3.2.html?ref=thegimp.net), providing an adjustment-style workflow. Group position determines what receives the correction. Describing current GIMP as permanently destructive misses both routes.

Keep a correction editable where possible, then check that it remains editable after saving and reopening the native project. A filter's editability inside one program doesn't guarantee that another program can retain it.

## Keep KRA and XCF, then choose an exchange copy

[KRA preserves Krita's supported project features](https://docs.krita.org/en/general%5Fconcepts/file%5Fformats/file%5Fkra.html?ref=thegimp.net). In GIMP, [Save keeps the project as XCF and Export creates another format](https://docs.gimp.org/3.2/en/gimp-images-out.html?ref=thegimp.net). Keep those native masters before any conversion.

| What the next application needs                   | Exchange choice               | What to check                                                                               |
| ------------------------------------------------- | ----------------------------- | ------------------------------------------------------------------------------------------- |
| The rendered picture, including transparent edges | PNG                           | Pixel dimensions, colour and alpha; the editable stack isn't included                       |
| Separate raster layers                            | Consider ORA                  | Layer order, blending and appearance; native filters, text and vectors need separate checks |
| A Photoshop document                              | PSD, checked by the recipient | Appearance and the particular objects that must stay editable                               |

[PNG is lossless and supports full alpha transparency](https://docs.krita.org/en/general%5Fconcepts/file%5Fformats/file%5Fpng.html?ref=thegimp.net). It is a useful handoff when Krita needs a repaired photo as one image, or GIMP needs the finished painting as one layer. It doesn't carry the project's editable layer stack.

![GIMP 3.2 Export Image as PNG dialog on Windows with Pixel format Automatic, Compression level 9, the metadata options and the Help, Export, Reset and Cancel buttons](https://storage.ghost.io/c/da/21/da2186e6-6044-4206-b621-584ed1984ab7/content/images/2026/11/24-gimp-ui-krita-vs-gimp-2-dd095f63c20d.webp)

Keep the XCF master and export a separate PNG when the next program only needs the rendered picture, then check its dimensions, colour and transparent areas. [Open the PNG export dialog at full size](https://storage.ghost.io/c/da/21/da2186e6-6044-4206-b621-584ed1984ab7/content/images/2026/11/24-gimp-ui-krita-vs-gimp-2-dd095f63c20d.webp?ref=thegimp.net).

[OpenRaster stores its layers as PNG images](https://docs.krita.org/en/general%5Fconcepts/file%5Fformats/file%5Fora.html?ref=thegimp.net), and GIMP documents [exporting an ORA copy](https://docs.gimp.org/3.2/en/file-ora-export.html?ref=thegimp.net). Use it when the separate raster layers are useful; it isn't a promise that all KRA or XCF features will survive. Inspect the transferred stack before relying on it.

For a photo-to-painting project, the sequence is straightforward:

1. Complete the photo repair in GIMP and save the XCF master.
2. Export a separate PNG, or an ORA copy if individual raster layers matter.
3. Open the copy in Krita. Compare the composite and inspect any transferred layers, then save a new KRA master.
4. Continue the painting there and export the delivery image. Keep both native masters if either part may need revision.

Only add the second editor when its tools solve a real part of the project. A finished painting can be exported directly from Krita; opening it in GIMP adds no automatic improvement.

For ordinary painted game assets, I'd keep the KRA or XCF master and export a PNG into the game project: that keeps the artwork editable without making the engine depend on the painting application. [Unity re-imports changes saved in its Assets folder](https://docs.unity.com/en-us/engine/6000.0/manual/assets-and-media/import-assets/importing-assets?ref=thegimp.net), while [Godot automatically reimports changed source assets in the project folder](https://docs.godotengine.org/en/stable/tutorials/assets%5Fpipeline/import%5Fprocess.html?ref=thegimp.net). After revising a character or sprite sheet, save the master, export over the same PNG and inspect the updated asset in the engine. Recheck the dimensions, sprite boundaries and transparent edges; editing the master alone doesn't update an unchanged PNG.

## PSD results: opening is different from preserving editable objects

Krita's [PSD support includes several layer and mask types](https://docs.krita.org/en/general%5Fconcepts/file%5Fformats/file%5Fpsd.html?ref=thegimp.net), but its manual recommends another exchange format where possible. The useful question is whether the recipient can still edit the text, adjustment or object that matters.

In the [Testy PSD benchmark published by Patchy developer Seth Robinson](https://github.com/SethRobinson/Patchy/blob/c7faab76fe287f6248db3d75acc04b5be1666b2f/docs/psd-compatibility-benchmark.md?ref=thegimp.net), GIMP 3.2.6 opened all 309 PSD and PSB files; Krita 5.3.4.1 opened 273\. This single Windows run, dated 29 October 2026, used small single-feature files. Photoshop 27.11.0 inspected the saved PSDs, with Krita driven through its Python runner and GIMP through headless Script-Fu.

| Result in that run               | Krita 5.3.4.1 | GIMP 3.2.6 |
| -------------------------------- | ------------- | ---------- |
| Files opened                     | 273 / 309     | 309 / 309  |
| Saved PSDs rejected by Photoshop | 7             | 0          |
| Text objects retained            | 12 / 12       | 0 / 43     |
| Adjustment layers retained       | 0 / 165       | 0 / 183    |
| Native Smart Objects retained    | 0 / 172       | 0 / 172    |
| Live effects retained            | 134 / 135     | 0 / 181    |

Krita retained text and nearly all live effects that Photoshop could inspect, while GIMP retained none; neither retained adjustment layers or native Smart Objects. The denominators differ because objects can only be inspected in saves Photoshop can reopen. Krita's failed opens and rejected saves reduce that inspected set, so 12 / 12 doesn't mean it preserved all text across the original corpus.

These are one developer's PSD interoperability results, not a measure of painting quality or brush speed. They support a specific decision: check the required editable objects in the recipient's editor, even when the composite looks correct. The [GIMP PSD guide](https://thegimp.net/gimp-open-psd/) explains the distinction in more detail.

## Choose Krita for drawn animation

Krita's [Animation workspace provides a timeline and onion skinning](https://docs.krita.org/en/user%5Fmanual/animation.html?ref=thegimp.net), keeping adjacent drawings and timing beside the canvas. I'd use it for a character blink or a short drawn loop. GIMP's [animated GIF export uses layers as frames](https://docs.gimp.org/3.2/en/file-gif-export.html?ref=thegimp.net), with delay and disposal controls; it doesn't support layer groups. The [GIMP layer-animation route](https://thegimp.net/gimp-animation-layers/) suits a small GIF assembled from existing images.

Plan longer Krita work as separate shots. Its animation manual warns that frames consume working memory, and recommends smaller clips and incremental backups. Save a milestone before merging layers or cropping them to reduce memory use.

For delivery, [File > Render Animation](https://docs.krita.org/en/reference%5Fmanual/render%5Fanimation.html?ref=thegimp.net) can create a PNG sequence and encode an animated file. Since Krita 5.2, a bundled part of FFmpeg supplies some desktop encoding options; a separate installation isn't always necessary. Android uses its operating system's encoder instead. For transparent animation, retain the PNG frames: the manual warns that video rendering turns transparent areas black.

## Match the package to your device

Both applications offer free desktop downloads for Windows, macOS and Linux. [Krita's desktop page](https://krita.org/en/download/?ref=thegimp.net) lists 5.3.4.1, Windows 8.1 or later, macOS 10.15 or Linux, with 4 GB RAM minimum and 16 GB recommended. Paid store versions add automatic updates and support development after the store's fee; payment isn't required for the direct desktop download.

[GIMP's current packages](https://www.gimp.org/downloads/?ref=thegimp.net) list 3.2.8\. Its Windows installer requires Windows 10 1903 or later, while the Microsoft Store route has stricter requirements. The macOS package requires macOS 11 or later. On Linux, choose a package compatible with the distribution rather than assuming every download runs everywhere.

For Android tablets and Chromebooks, Krita has an [official Google Play build labelled beta](https://play.google.com/store/apps/details?id=org.krita&ref=thegimp.net); the listing warns that it isn't suitable for real work yet and excludes phones. GIMP's desktop download list doesn't include Android; a Chromebook uses its [Linux environment for GIMP](https://thegimp.net/gimp-on-chromebook/). Krita explicitly excludes iPads and iPhones, and GIMP doesn't provide an iPad build.

## Learn one complete project first

For drawing, begin in Krita with separate sketch, ink and colour layers, choose a pressure-responsive preset and adjust smoothing for the marks you need. Save the KRA and export a PNG, then reopen both to check what each contains. That gives the first project a useful end point before adding animation or complicated exchanges.

For photo work, start in GIMP with one repair or masked cutout, keep an XCF and export the delivery copy. Learn to inspect the edge and revise the correction before adding more filters. If the real task is a reusable logo or an interface layout, the [Inkscape comparison](https://thegimp.net/inkscape-vs-gimp/) or the task-based [GIMP alternatives](https://thegimp.net/gimp-alternatives/) will point you towards a more suitable editor.