Wheee! Week 1! This week turned out to be a sort of flying start of 2010 for Krita, with lots happening in the source, preparations being made for the February sprint and some work on the manual being done.

Code

There have been about 70 commits this week, which is kind of a record.

The week started with Cyrille Berger starting work on a new OpenEXR import/export plugin. OpenEXR is kind of a complex library, and the previous import/export plugin was using API's that made it impossible to handle multi-layer OpenEXR images. The new plugin has been designed from the start to do just that. While working on this plugin, Cyrille noticed that we are having some problems with memory consumption. This was partly caused by OpenGTL leaking memory, so Cyrille committed lots of fixes in that library as well. We're still not done, though: Dmitry is looking into some leakage problems in the tiles engine, and LLVM is still using way too much memory. Cyrille also fixed a number of crashes in the bracketing-to-hdr feature.

Boudewijn Rempt finished the import side of the new gif filter. Actually, I'm not sure whether Krita ever could load gifs -- I think the old GraphicsMagick-based filter only provided export for gif. Boudewijn is now working on making export to gif work again -- but it is a bit of a why-bother thing. Krita simply doesn't support and won't ever (probably...) support indexed images, so Krita will never be the tool of choice for creating animated smileys. But it's not much code, since we can follow the lead of Shawn Rutledge's read/write qimgio gif plugin. This code adds a new dependecy to Krita, namely giflib. Boudewijn also did some work on the Photoshop filter, but there's nothing finished there yet, and he implemented a unittest that shows that the mypaint-compatible brush engine is beginning to come together. (I still need to find a voice here... First person, third person...)

Adrian Page fixed a lot of problems with OpenGL on Windows. Krita now uses the OpenGL 2.0 core API for our shaders. Kai-uwe Behrmann started a discussion on the mailing list about why Krita doesn't use the full capabilities of the 30-bit displays that are becoming available. Boudewijn provided a first patch to make that work, which was reviewed by Adrian and needs more work. It looks like it will be possible, but it might cause OpenGL to take some slow paths: there's some more work to be done here. Adrian also did some much-needed janitorial work removing deprecated constructs from almost all Krita plugins.

Marc Pegon joined us on #krita and started working on a very annoying bug: drag and drop of images from konqueror would work, but if you tried to drag an image from Firefox, nothing would happen. Marc sleuthed his way through the code and managed to produce his first patch just in time for inclusion in this weeks' Last Week in Krita. It'll be committed today. Welcome to the team, Marc!

Adam Celarek came back from his holiday in Tyrol and committed a big cleanup of the selection tools. The selection and paint tools now share the same common behaviour and the settings for the selection tools are represented by nice new icons created by Enkithan. Note that the shortcut for hiding the dockers is now ctrl-h, not Escape, since Adam discovered that setting the shortcut to Escape hid the most obvious way to close a patch in the polygon tools.

Lukáš Tvrdý was busy with his exams, but still managed to commit a new brush engine, the Soft Brush, which gives a very nice cloudy and almost-wet effect when using the right settings.

Those brush settings... There are so many now that it might be easier to write your own brush engine than to discover the best settings for some engines. We've long wanted to introduce the concept of presets, so you can save and load particular settings for particular brush engines. Well, Sven Langkamp is this weeks hero because he started working on that and came a long way towards this goal. He cleaned out reams of duplicate code in the brush engines to begin with and then continued to make saving and loading of presets work. There is still a lot to do, but the progress is enormous.

Manual

A quality application needs a quality manual. Krita 1.6 had a pretty good manual, one that went beyond the usual listings of menu items and dialog screens. Unfortunately, Krita 2 is really and thoroughly a different application from 1.6: we might be able to salvage a paragraph here and there, but that's it. So I've started a new manual on Userbase, which is the current place for application documentation. And since userbase is a wiki, anyone can grab a chapter and write a few lines! The goal with this manual is once again to produce a useful manual that teaches people how to use Krita. Please go through the table of contents! We also want to integrate video tutorials in this manual, for instance by hosting the videos on vimeo or something like that, and embedding them in the manual.

I hardly dare to say this... But I really expect that by this time next year the first books about Krita will start being written.

Bugs

Erm... We're at 87 bugs at the time of writing, despite a good number being closed this week. And our unittests aren't too hot either... And, as said above, we have to watch our memory consumption a bit. But that's par for course in this stage of development: everyone is rushing to get the promised features (check it out, the plan has got colors now) in before the soft freeze hits us. (Which is a weird thing to say, since it's been a hard freeze all over Europe for weeks now!)

Sprint

Well, the sprint is coming closer and closer. I've booked accomodation now, since there's no way I can fit all the attendants in my house -- and for the vision session, we even might have to find an alternative to the kitchen table!

And since a good sprint is a sprint with a t-shirt, I've made a call for designs. Our webmaster Kubuntiac has replied with a very cool design, but the issue is still wide open, of course, and no artist should feel prevented from joining in the fray! Just a note: black t-shirts seem favoured by most hackers...

That all for now -- if you have comments, hie yourself to our forums> and discuss!

I have missed the last two weeks of "Last Week in Krita", but to make up, here's "Last Year in Krita". Trying to remember January 2009 is quite hard!

To begin with, there hadn't been a release since Krita 1.6.3 in June 2007. In 2009, both Krita 2.0 (let's call it a line in the sand for us developers) were released, as well as Krita 2.1 'the almost stable'.

In January 2009, there were four developers working regularly on Krita -- but in December 2009 we saw ten developers actively working on Krita, some of them completely new to the project, like Adam Celarek, Vera Lukman, Edward Apap or Dmitry Kazakov and some of them old hands who have recentely started working on Krita again like Casper Boemann and Adrian Page. Dmitry Kazakov was the 2009 Krita Google Summer of Code student and Vera Lukman the 2009 Krita Season of KDE student. Both have delivered excellent work, and more importantly: are still active developers.

In January, we didn't have a website, in December our website is almost taking over from koffice.org/krita as the starting point in Google searches. Yay for Kubuntiac, our webdesigner, webmaster and all-round forum activist! Congratulations also with the birth of his first daughter on Boxing Day! And let's also congratulate Cyrille Berger, who got his Phd near the end of 2009.

In January, We didn't have web forums, which are a preferred way of communication for many users: thanks to Lukáš Tvrdý and KDE forum admin Neverendingo, we've got our forums now, with a nice gallery, as well.

And in January, my own feeling was that we did not really have any clear direction. We started porting Krita to Qt 4 and KDE 4 in 2006, and three years is a long time. In the meantime, projects like MyPaint had started to come into their own, and Gimp has started integrating gegl and set huge strides towards usability. Was there are a niche left for Krita? But during 2009, we regained our focus and our direction. Both the excellent usecases written up by Enkithan and Lukáš Tvrdý's interest in making Krita useful for Blender led us to define a clear action plan. When I am writing this article next year, we want to be able to say that Krita is suitable for everyday usage, without any 'ehms' and 'yeah, buts' -- no apologies should be necessary.

To achieve that, we started a fund raiser campaign on pledgie. Our target was €3000 and we thought we'd need three months to get there -- it turned out to be three days. Thanks to the more than 170 sponsors, we are now at over €4500! We'll spend every cent of it on Krita development, and when we've spent all of it, I'll account for it on krita.org.

Now, on the cusp of 2010, Krita has 84 bugs reported against it, and 111 wishes. That's a far goal from my 2.2 release target of having only 20 bugs and no known crash bugs, but I'm happy with all those reports, because entering a report in bugs.kde.org is quite tiresome, and shows real dedication from our users and a real desire to help out. And we're returning the honor: we have fixed 211 bugs in 2009. I'm sure the number of fixed bugs will be higher in 2010!

It's almost impossible to enumerate the improvements that went into Krita in 2009. At a rough count, there have been 1850 commits to Krita alone in 2009, a number which excludes all the work that went into the KOffice libraries and plugins that form the base for Krita and extend Krita with functionality like the text shape. It is very hard for developers like us to actually look back on the work done, we are always focussing on the next issue. I can tell you that when the KOffice team assembled in Oslo right after the 2.1 release, there was no partying, no celebratory mood -- we seemed to have forgotten already about that achievement and were all gung-ho to go on to 2.2!

Highlights were of course the Summer of Code work by Lukáš Tvrdý and Dmitry Kazakov, who worked on new 3d brush visualization and canvas improvements and a new tile engine and mipmapping for the QPainter-based canvas, respectively. Vera Lukman's quick brush and color selection palette was developed as part of the Season of KDE and will help a lot in making Krita more usable for creative artists. We removed the troublesome dependency on GraphicsMagick -- Krita was originally designed to be just a gui layer over the ImageMagick library! -- and we started implementing our own xcf, ppm, gif and psd filters. Lukáš managed to convince his university that he could develop brush engines for his thesis, which has resulted in fun and useful brush engines like the deform, spray or the grid brush. But all parts of Krita have been continuously improved during 2009, and we ended up with a sort of a December sprint, with Adam Celarek improving the gui and the code sharing of the selection tools, Edward Apap has worked on making the convolution filters (like Gaussian blur) much faster, Sven Langkamp has started the long-awaited work to make it possible to load and save brush settings as presets, Casper Boemann has redone the image resize dialog based on Ellen's usability suggestions -- by now, Krita 2.1 feels so old!

One area where I suspect we will continue to lag are documentation -- we had a pretty good manual, but it was completely outdated so I had to remove it. We'll have to find a volunteer to write/record tutorials once our gui stabilizes -- which we hope to achieve in with the 2.3 release.

So, what's for 2010? There will be a Krita sprint in Deventer, the Netherlands, which will be attended by many Krita developers as well as Peter Sikking, the interaction designer who has helped Gimp's team find their way towards a high state of polish and usability. He will help us develop our vision and hopefully point us towards measures to improve Krita's usability for creative artists. Following that, there will be week long hacking session with part of the Krita team in Deventer. Lukáš Tvrdý will be working on Krita for three months following the action plan. And since our supporters have been so incredibly generous, it is possible for Lukas to work full-time on fixing bugs for at least a month after he finishes school as well. We have planned at least two releases: 2.2 and 2.3. While 2.2 should already contain many performance improvements, 2.3, planned four months after 2.2 according to the KOffice schedule, should be completely usable.

See you on our forums, #krita on irc.freenode.net or on our mailing list -- or the Libre Graphics Meeting in Brussels.

Krita is an application for image creation and image manipulation. We focus on painting, illustration, concept art and other creative work. Still, Krita has many features that are useful for image manipulation, like filter layers or RAW image import. This is a short an incomplete list of the most important features Krita provides. 

Krita provides an OpenGL based canvas in addition to an unaccelerated canvas. Krita's filters, histogram computation and image recomposion are multi-threaded and make use of multiple cores if available. The effect of filters is previewed on-canvas.

Scripting and recording are works in progress.

File Formats

Krita has support for a variety of file formats. Not all file formats are supported equally well, and for some there is only import, not export. Krita supports metadata for kra, ora, tiff, jpeg and png file formats.

• bmp: export only
  
• jp2: export, import
  
• jpeg: export, import
  
• ora: export, import
  
• pdf: import only
  
• png: export, import
  
• ppm: export, import
  
• raw: import only (based on dcraw)
  
• tiff: export, import
  
• xcf: import only
  

In preparation are support for gif, psd (only up to Photoshop 7) and eps.

Color models

Krita does not support indexed color models. In general, Krita does not support color models without an alpha channel. Krita supports different channel depths, from 8 bits integer to 32 bits floating point per channel.

• RGB: 8, 16 bits integer, 16, 32 bits floating point
• CMYK: 8, 16 bits integer
• Grayscale: 8, 16 bits integer
• La*b*: 16 bits integer
• YCbCr: 8, 16 bits integer
• XYZ: 16 bits integer, 16, 32 bits floating point
• Painterly colorspaces: colorspaces that represent 3-10 wavelength channels in 16/32 bits floating
  

Layer types

Krita supports the both layers and masks. Masks are associated with a single layer, while layers are grouped in a hierarchy.

• group layer: groups layers toegether in a hierarchy
  
• paint layer: contains raster image data
  
• filter layer: non-destructively filters all the layers underneath the filter layer in the current group
  
• clone layer: puts a duplicate of the original layer in a different place in the layer stack
  
• vector layer: contains vector data, such as vectors, text or complex objecs such as charts
  
• transparency mask: mask out parts of the associated layer
  
• filter mask: non-destructively filter parts of the associated layer
  
• local selection mask: make parts of the associated layer uneditable without masking those parts out

Tools

There are several types of tools: vector tools, raster tools, guidance tools, canvas tools and selection tools. Note some types of content are not implement as tools but as "shapes" that can be inserted, for instance richt text, text-on-a-path or geometric shapes.

Vector tools

• object manipulation tool
• connection tool
• path tool
• freehand path tool
• pattern tool
• vector shape filter tool
• calligraphy tool
• gradient tool
• zoom tool
• pan tool
  

Raster Tools

• freehand paint
• line
• rectangle
• ellipse
• polygon
• polyline
• start
• stroked path (non-editable)
• dynatool
• fill with pattern or color
  color selector
  gradient
  

Canvas Tools

• crop
• move layer
• transform tool
• distance calculation
  

Guidance Tools

• ruler assistant
• perspective grid
• grid

Selection Tools

• rectangle select
• elliptical select
• polygon select
• outline select
• fill select
• select similar colors
• path select

(There is no magnetic outline selection tool at the moment)

Brush engines

Krita is different from other applications in that it supports brush engine plugins. These brush engines are used in the pixel tools to stroke your painting.

• pixel brush: compatible with Gimp's .gbr and .gih brushes, as well as custom brush tips and text
• duplicate: duplicate pixels from the current or another layer
  
• deform: deform existing pixels
  
• dyna: paint with movement strength
  
• spray: spray pixels or images
  
• filter: paint with a filter
  
• sumi-e: model a hairy brush
  
• airbrush: deposit color at a rate
  
• smudge: smudge existing pixels
  
• eraser: erase pixels
  
• grid: paint a grid of pixels
  
• mixing: mix colors on the canvas
  
• curve: random jitter and curving along the stroke
  
• chalk: model drawing with chalk
  
• pencil: draw aliased lines
  

In preparation is a brush engine plugin that is compatible with MyPaint's brush definitions.

Filters

Krita provides filters that can be used directly, i.e. destructively on the pixels of a layer, when painting, or dynamically as a filter layer or filter mask.

• dodge, burn
• levels
• color adjustment curves
• brightness contrast curves
• desaturate
• invert
• autocontrast
• hsv adjust
• cubism
• pixelize
• raindrops
• oilpaint
• blur, gaussian blur
• color to alpha
• color transfer
• minimize, maximize channel
• top, left, bottom, right, sobel edge detection
• sharpen, mean removal, unsharp mask, gaussian and wavelet noise reducer
• various emboss
• small tiles
• bumpmap
• wave
• random noise
• lens correction
• random pick
• random
• OpenShiva-based filters
  

There are more filters available in the krita-plugins project.