Krita

Krita is a free and open source digital painting application designed from the ground up for professional creative work. Unlike general-purpose image editors, Krita is purpose-built for artists — providing a complete toolkit for concept art, comic book illustration, matte painting, texture work, and 2D animation within a single application. It runs natively on Linux, Windows, and macOS and is available as an AppImage, native installer, or from source.

At its core, Krita delivers a highly customizable brush engine with over 100 brush presets, support for pressure-sensitive stylus input, and advanced dynamics including tilt, rotation, and tangential pressure. The layering system supports 60+ blend modes, layer groups, filter layers, and non-destructive adjustment layers. Full HDR painting with 16-bit and 32-bit per channel color depth is supported, along with professional color management using ICC profiles and OpenColorIO integration.

Krita is built on C++ and Qt/KDE Frameworks, with a modular plugin architecture that enables the community to extend functionality without forking the core. A Python scripting API (libkis) exposes the document model to automation and batch processing, while QML-based components power portions of the UI. The project is developed transparently on KDE’s GitLab with active CI pipelines covering Linux, Windows, macOS, and Android builds.

The application is sustained by donations and sales on Steam, itch.io, and the Windows Store — keeping it entirely free for download from krita.org. With over 9,900 GitHub stars and a mirror of the primary KDE GitLab repository, Krita enjoys a large global community of artists and developers contributing brushes, presets, and code.

What You Get

• Customizable Brush Engine - Over 100 built-in brush presets with a fully configurable engine supporting pressure, tilt, rotation, and tangential pressure inputs from stylus hardware, enabling realistic simulation of oil, watercolor, airbrush, and dry media.
• Advanced Layer System with 60+ Blend Modes - Full layer stack with groups, filter layers, clone layers, fill layers, and adjustment layers — all with non-destructive editing and an extensive set of compositing blend modes including color dodge, luminosity, and hard mix.
• HDR Painting and Color Management - Support for 16-bit and 32-bit per channel color depth, ICC color profiles, softproofing, and OpenColorIO integration for precise color-managed workflows in film and VFX pipelines.
• Vector Layers and Shape Tools - Create and edit SVG-compatible vector shapes, paths, and text directly within the painting workflow without switching to a separate application.
• Built-in 2D Animation Timeline - Frame-by-frame animation with onion skinning, a timeline docker, and export to GIF, MP4, and PNG sequences via FFmpeg integration.
• Python Scripting API - Full document model exposed through libkis, enabling batch export, automation, custom dockers, and workflow scripts without recompiling the application.
• SeExpr Fill Generator - Integration of Disney’s SeExpr mathematical expression language for procedural fill generation directly inside the canvas.
• Wrap-Around Canvas Mode - Tile-based canvas preview that makes designing seamlessly tiling textures and patterns intuitive without post-processing tricks.

Common Use Cases

• Creating concept art for game and film production - Artists use Krita’s HDR painting, professional color management, and customizable brush engine to produce high-resolution concept sheets and mood boards deliverable directly to production pipelines.
• Illustrating comic books and graphic novels - Comic artists use Krita’s layer system, vector tools, and panel layout tools to draft, ink, and color pages from pencils to final output in a single application.
• Painting PBR textures for 3D models - VFX and game artists paint albedo, roughness, normal, and emissive maps in high bit-depth color spaces using Krita’s wrap-around canvas mode and precise brush control.
• Producing frame-by-frame 2D animation - Indie animators and studios use Krita’s timeline, onion skinning, and FFmpeg export to create short films, game sprite sheets, and motion graphics.
• Batch processing artwork with Python scripts - Technical artists use the libkis Python API to automate export of multiple artboards, apply consistent adjustment layers, or integrate Krita into asset pipeline scripts.
• Digital portrait and character painting - Illustrators leverage Krita’s pressure-sensitive brush dynamics, color smudge engine, and reference image docker to produce finished character artwork.

Under The Hood

Architecture Krita is organized as a layered system with clear boundaries between the image processing core, the compositing pipeline, and the UI shell. The KisImage class acts as the root of the document model — it manages a tree of KisNode-derived objects (layers, masks, generators, filters) and coordinates all asynchronous mutations through a stroke queue and background worker threads. Compositing is handled by a projection system where each node computes its contribution to a tile-based paint device, and the canvas widget observes update rectangles to schedule efficient redraws. The plugin architecture uses a KDE plugin factory pattern: paint operations, file format importers/exporters, filters, and dockers are all independently loadable modules registered at startup, allowing feature extension without touching the core. Dependency injection is achieved through factory registries (KoColorSpaceRegistry, KisFilterRegistry, KisPluginRegistry) that decouple consumers from concrete implementations.

Tech Stack Krita is written in C++17, built with CMake, and targets Qt5 (with experimental Qt6 support). The KDE Frameworks layer supplies KCoreAddons, KI18n, KGuiAddons, and plugin infrastructure. Color management is handled through LCMS2 and OpenColorIO; high-dynamic-range image I/O through OpenEXR and libjxl; animation export through an FFmpeg wrapper. The brush engine interacts with hardware via Qt’s tablet event system augmented by platform-specific backends (WinTab on Windows, Apple Pencil on macOS). Python scripting is exposed through a sipbuild-generated binding over the libkis API layer. CMake manages an extensive third-party dependency tree including Eigen, Boost, GSL, and MyPaint libmypaint, with CCache configured for incremental compilation. CI pipelines run on KDE Invent’s GitLab covering Linux AppImage, Windows installer, macOS bundle, and Android APK targets.

Code Quality Krita has extensive test coverage distributed across every major library — libs/image, libs/pigment, libs/flake, libs/ui, and most plugins each carry a tests/ subdirectory with QTest-based unit tests covering color management, geometric operations, layer operations, filter output, and file I/O. Core headers carry thorough Doxygen-style comments documenting class invariants and method contracts, and the HACKING file establishes clear coding standards for Qt class preference, C++ feature use, and naming conventions. Error handling leans on Qt assertions and direct comparison checks rather than exceptions, which keeps the deterministic painting pipeline stable. Naming conventions are consistent throughout (kis_* for image types, Ko* for shared KDE/pigment types, Kis* for Krita-specific types), and the SPDX license identifiers are applied uniformly across all source files. The main gap is the steep entry barrier — the CMake build system orchestrating dozens of optional third-party dependencies can be daunting for new contributors.

What Makes It Unique Krita’s most distinctive technical contribution is its tile-based asynchronous compositing pipeline with Level of Detail (LOD) support, which lets artists paint on a downscaled preview while the full-resolution composite renders in the background — a feature borrowed from professional production software but implemented in open source. The SeExpr procedural fill generator embeds Disney’s expression language directly into the canvas as a first-class fill layer type, enabling mathematical pattern generation without leaving the application. The color space architecture (Pigment library, KoColorSpace) implements a full ICC-profile-aware color pipeline with pluggable color space factories, supporting LAB, CMYK, YCbCr, and XYZ color models natively alongside RGB — a level of color management depth unusual in open-source creative tools. The wrap-around canvas mode, combined with the Python scripting API’s full document model access, gives texture artists a workflow that competes directly with dedicated texturing applications.

Self-Hosting

Krita is licensed under the GNU General Public License version 3 (GPL-3.0), with individual files carrying compatible licenses including GPL-2.0-or-later and LGPL variants as documented in the LICENSES directory. For self-hosters and internal deployments, the GPL-3.0 means you can use, modify, and distribute Krita freely — including in commercial art production environments — as long as any distribution of modified binaries is accompanied by the corresponding source. There is no open-core model, no enterprise edition, and no feature gating: every capability in the publicly released binaries is equally available from the source code.

Running Krita for a team or studio is straightforward in operational terms because Krita is a desktop application, not a server-side service. There is no database to manage, no web tier to secure, and no persistent daemon to monitor. Deployment involves distributing the application binary to workstations via your preferred software management tooling — AppImage on Linux, an MSI/installer on Windows, or a DMG on macOS. The project provides nightly builds from KDE’s CDN for teams that want access to the latest features before a formal release, including debug-symbol builds and ASAN-instrumented builds for developers tracking down memory issues. The operational burden is limited to maintaining the desktop installations and ensuring the optional external dependencies (FFmpeg for animation export, OpenColorIO configs for color-managed pipelines) are present in the environment.

The trade-off versus a commercial painting application is primarily support and training, not functionality. Krita is sustained by community donations and commercial sales on Steam, itch.io, and the Windows Store rather than by a paid subscription that includes support contracts or SLAs. Professional support must be sourced from the community forums at krita-artists.org, the IRC channel on Libera.Chat, or from third-party consultants. There is no managed cloud sync for brush presets or project files, no enterprise license management dashboard, and no guaranteed response time for bug reports. For studios requiring formal support agreements, this is the gap to plan around.