A quick sketch of Krita 2.4

The painting application Krita is nearing its next point-release, 2.4. Because Krita is a component of the KDE-based office suite Calligra, its numbering scheme is synchronized to the larger project's. But despite the small increment it inherits this time, the new release incorporates a sizable number of important changes, including new artists' tools and a built-in network for sharing resources with other Krita users.

Thus far, the beta releases of Krita 2.4 have been made in source code packages only. However, there are volunteer-created builds for a variety of platforms and Linux distributions. When Krita and Calligra reach the 2.4 final stage, it is expected that most distributions will push out an updated package. I tested nightly binary builds from project NEON on Ubuntu 11.04, primarily because the machine in question is the one to which my Wacom tablet is attached.

This is vital, because Krita is increasingly geared towards tablet usage. While other graphics applications offer solid tablet support — pressure and tilt sensitivity for starters, button and key assignments in the advanced cases — Krita is steeped in tablet culture. The UI has been redesigned in recent development cycles to make it more touch-friendly (with fewer menus and more button and slider controls), and there are an increasing number of painting parameters that can be bound to tablet digitizer sensors. In fact, if you use Krita without a tablet these days, you almost risk being left out of important functionality. Tablet PCs with touch-screens make for a partial substitute, but do not offer as many touch parameters or levels of sensitivity.

Brushes and tools

Many of Krita's recent advances have been in the building new paintbrush engines, each of which simulates a different drawing tool or painting medium — paint, ink, chalk, etc. Obviously Krita is not bound by existing physical media, so some of the new and innovative brush engines are hard to describe.

2.4's "curve brush" is like this; the brush engine creates its own fills and flairs as you draw, which introduces some randomness into the final shapes, much like you would experience with natural media. An earlier incarnation of this technique debuted in 2.3, but this revision is based on an update of the original code, and in my experience is easier to work with. The "sketch brush" is also intended to emulate natural-media randomness, but the results are more straightforward (simulating pencil or ink drawing), as is the "color smudge" brush, which allows you to realistically smear and munge color already on the canvas while painting new strokes. All brushes have tablet sensor support, which allows you to (for example) vary the line width and "ink" density in response to pressure, tilt, and acceleration.

The list of paintbrush engines is always growing, but brushes are certainly not the only tools. New in 2.4 is a "multi-hand tool," which is an extension of the automatic mirroring introduced earlier this year. With the multi-hand tool, you can duplicate your brush strokes on the canvas as you paint, with your choice of reflections and planar translations applied. A few other tools have picked up additional features, including the line tool, which now has adjustable parameters (width, opacity, etc) that can be bound to tablet sensor values just like the paintbrushes.

Another new addition is called "pipe mode" for the text-painting tool. It allows you to "paint" text onto the canvas — you select the source text first, then as you draw, the text is rendered onto the canvas fitted to the curves of the stroke that you draw. It beats the alternative methods for splaying text in a creative fashion: creating "normal" blocks of text and subsequently trying to distort them with perspective adjustments.

Beyond the tools themselves, there is a substantial list of new "blending modes" supported in Krita 2.4's layers. The blending mode is the property of a layer that tells Krita how to combine its pixels with the pixels underneath it — which is particularly important for alpha-transparent regions. You may be familiar with Photoshop or GIMP's standard options, such as "Normal," "Multiply," "Subtract," "Hard Light," "Soft Light," and so on. Some these are simple descriptions of what math is applied to the pixels (e.g., "Multiply"), while others are designed to emulate real world media, such as transparency film physically overlaid.

The new Krita release adds more than twenty modes of both types; from "Geometric Mean" to "Grain Extract." Many of them are blending modes that artists are already familiar with from Photoshop (including Grain Extract), and Krita's implementations are identical. Ensuring this compatibility also entailed adjustments to some of the existing blending modes, which could theoretically be an annoyance to an artist with existing Krita documents making use of them, but is a far better approach in the long run.

In another multiple-tool change, all of the painting tools can now take the source color that they paint with not just from a single, pre-selected color value, but also from gradients, pattern images, or a randomized color source. That allows you to define more complex brush strokes that change color along the way — as well as to paint with random colors, although I have yet to see a truly awe-inspiring work of randomly-colored art.

Pre-sets: you versus the world

A lot of work has gone into enhancing the pre-set system in this new release, perhaps making it a more visible improvement for the average working artist than is any individual brush engine. The issue at hand is that all of Krita's brushes offer a glut of user-tweakable settings: there are always multiple tablet sensor mappings (pressure, tilt, etc), plus brush size, shape, and opacity, blending mode and color source, and there are parameters unique to each individual engine. There is no "best" combination of settings, even for a particular project. In practice, artists want to adjust the settings to fit the situation, and save the most useful combinations of settings for later use.

2.4 makes this substantially easier, with a "preset editor." Saved presets are accessible in the paintbrush drop-down menu at the top of the canvas, as well as in a dockable tool palette that you can place anywhere on the screen. You can assign names, keyword tags, and a short description to each pre-set to assist your memory later. The pre-set editor also has a small sample canvas onto which you can paint, either to test your settings as you make adjustments, or to save as a thumbnail for the pre-set browser.

Pre-sets are an invaluable feature — if you have ever worked with the dodge and burn tools in GIMP trying to freshen up a photograph, you may notice that it is easy to forget exactly what settings worked best. With the ability to save pre-sets, you have a recourse. But what is more intriguing is that Krita pre-sets can be shared with other users via the Get Hot New Stuff (GHNS) protocol. GHNS is supported in some other KDE applications, but its appearance in Krita is a first for the open source creative suite. Other applications have a web-based interface to GHNS "resource repositories," but Krita integrates GHNS brush pre-sets into the existing pre-set framework. You can choose to upload your own pre-sets and browse or download those shared by others.

It has long been possible to share brushes, gradients, and other resources between the major open source graphics applications, but it used to require downloading separate files and dropping them into the appropriate hidden directories in your home folder. GHNS offers is a far better experience — akin to Inkscape's built-in Open Clip Art Library downloader. I like the trend quite a bit; Michael Terry's AdaptableGIMP project (which we covered in May 2011) has a similar feature for retrieving GIMP task-sets (essentially macros), and Krita's menus have space for macros and tutorials, too. Together all of these features make a good argument that in-browser "web apps" are not the only viable approach to collaborative editing, and I hope that we will see more.

Finally, although it is not fully integrated with the brush pre-set system, 2.4 also introduces the ability to save and recall workspace layouts: task-centric arrangements of the Krita interface and its various docks and windows. That hints at more customizability in releases still to come.

UI and core changes

Speaking of such layouts, Krita adds several new dockable utility palettes in this release. Some, like the document undo/redo history and the channel mixer, are standard offerings in other raster editors, but others are more original. For example, there is an "image docker" in which you can open another image file to keep on-screen as a reference — think painting-from-a-photograph. There are also two new color-selectors, continuing Krita's tradition of offering artists multiple ways to approach paint color selection. The new selectors include an artist's color-wheel (which, despite being circular, is not identical to the triangle-inscribed-in-a-circle selector you have seen before), and a "specific color selector" for directly inputting hex color values.

A handful of other UI changes are designed to simply make Krita easier to use. This includes adding opacity, flow, and brush size sliders to the top toolbar, where the user can have one-click access to changing them with minimal interruption. There is also a new full-screen mode, which can be very helpful for tablet users. The active area of a graphics tablet is typically mapped to either the active window or to the entire X display; removing the non-image UI elements from the screen effectively removes dead zones from the outer borders of the tablet's active surface area.

Krita has always fired up a "new image wizard" whenever it is launched without opening an existing file. The wizard lets you choose the dimensions and color space of a new file, or to open up a template. I found several new templates in this release of Krita, although it is possible that some of them have been around longer and I just failed to find them before (perhaps due to my distribution's packaging). In any case, the new templates show off some interesting options, and highlight what Krita templates can do beyond standard flat images. Several are "comic" templates of differing sizes, and they are actually multi-layer documents, with masks and borders to mark off comic panels, and separate grayscale "ink" and RGB "paint" layers underneath, to reproduce a typical comic workflow.

Showtime

As always, there is a long, long list of smaller changes in the new version — better support for popular file formats (including OpenRaster, DNG, GIMP's XCF, and Photoshop's PSD), the ability to do incremental saves (automatically appending a version number to each save), and so on. It is hard to make a case for any particular new feature as a reason to rush out and upgrade, but that is probably not what most users are after anyway. Suffice it to say that the incremental improvements in the UI and painter's tools have made each Krita release better than the last for several development cycles in a row — and that kind of track record demonstrates that the team is paying close attention to what its users need. When you look at the Krita site now, it is filled with drawings and painted artwork, not test images or artificial samples to demonstrate features.

In the future, I am most interested to see where GHNS heads. Thanks to compatibility with GIMP, MyPaint, and other tools, brush pre-sets are not inherently limited to Krita, and sharing other types of content could prove valuable for many other applications. Consider the ability to directly retrieve task-sets and tutorials within applications — interesting in its own right; far more interesting when you imagine tutorials that span multiple applications and are accessible within each at the appropriate step.

There is also some interesting work coming to the Krita core in future releases, such as OpenCL support, which will allow offloading some operations to the GPU. Animation support has also been in the works for a while, through a plug-in to manage multiple frames. But big bullet-point features are always welcome, while adapting to better fit the users' needs is historically the bigger challenge for open source projects. It is good to see Krita managing both.