Revision as of 19:21, 28 June 2014 by Timothée (Talk | contribs) (Color profiles)

Jump to: navigation, search
Under construction.png
Under Construction
This is a new page, currently under construction!

This manual is a rewrite of the 1.6 manual. It is not complete.

Color and Color Management

You may have understood that Krita has something called color-management. Or maybe you just wondered what all these 'color model' and 'color profile' things you can find in the menus mean. Color management is pretty useful for people who work in digital imaging proffesionaly, and hopefully this page will explain why.

Basic default info

So, before we dive into the theory, let's first go over a few practical points.

  • If you've never worked with color management before, and have no clue what it is, then know that you've probably been working in the 8bit RGB colour space with the sRGB profile. We'll go into what these terms mean in the theory, but if you're here only for trying to figure out which is the default, you now know it.

So, what exactly are color spaces?

You know those images of really old computers? The ones that could only display black and green? Or perhaps you may have noticed that really expensive screens in the shops have much better color than cheap screens.

This has to do with color spaces.

The really old computer screens could only display two colors physically. Newer computer screens became able to display more colors by having a set of tiny lights for each pixel that could have different amount of brightness. By combining lights of different brightnesses, they can 'mix' the colors. To have the most efficient amount of mixable colors from the least amount of physical colors(called a gamut), screen manufacturers chose to have a red, green and blue light per pixel. Modern screens have 256(8bit) values of brightness for red, green and blue per pixel. This is called the 8bit RGB color space.

So, a color space is a method for describing colour by coordinates. In the RGB color space, the color red is described as R=1, G=0, B=0. Similarly, if you mix red and green, you get yellow. And thus the coordinate of Yellow is R=1, G=1, B=0.

Thus, you computer, which can't actually see color, can store a coordinate of which exact color is on the screen. This matters because the coordinate system of the screen(RGB) is different from the coordinate system of the printer(CMYK), which are both different from optimal human perception(XYZ).

Krita's Color Management main focus is to allow you to switch these coordinate systems, the color spaces, with as little amount of hassle as possible.

Furthermore, Krita's Color Management allows you to use ICC profiles. ICC profiles are, plainly put, descriptions of how much your screen or printer deviates from the ideal color space. Using them to your advantage can allow you to have less hassle with color varieties, like printed images turning out too dark or with a yellowish cast.

No amount of color management in the world can make the image on your screen and the image out of the printer have 100% the same color.

Different colour spaces and models

Krita has many different color spaces and models. Following here is a brief explaination of each, and their use-cases.


Red, Green, Blue.

These are the most efficient primaries for light-based color mixing, like computer screens. Adding Red, Green and Blue light together results in White, and is thus named the adative color wheel.

RGB is used for two purposes:

Images that are meant for viewing on a screen: So that could be images for the web, buttons, avatars, or just portefolio images. Or for Video games, both sprites and textures are best in RGB there. Or for 3d rendering, visual effects and cg animation.

And for the working space. A working space is a RGB gamut that is really large and predictable, meaning it's good for image manipulation. You use this next to a profiled monitor. This way you can have precise colours while also being able to view them correctly on multiple screens.

RGB models: HSV, HSL, HSI and HSY

These are not included as their own color spaces in Krita. However, they do show up in the blending modes and color selectors, so a brief overview:

--Images of relationship rgb-hsv etc.

The tint of a color, or, whether it's red, yellow, green, etc. Krita's Hue is measured in 360 degrees, with 0 being red, 120 being green and 240 being blue.
How vibrant a color is. Saturation is slightly different between HSV and the others. In HSV it's a measurement of the difference between two base colors being used and three base colors being used. In the others it's a measurement of how close a color is to grey, and sometimes this value is called Chroma. Saturation ranges from 0(grey) to 100(pure color).
Sometimes known as Brightness. Measurement of how much the pixel needs to light up. Also measured from 0 to 100.
Where a color aligns between white and black. This value is non-linear, and puts all the most saturated possible colors at 50. Ranges from 0 to 100.
Similar to lightness, except it acknowledges that yellow (1,1,0) is lighter than blue (0,0,1). Ranges from 0 to 100.
Similar to lightness and Intensity, except it weights the red, green and blue components based real-life measurements of how much light a color reflects to determine it's lightness. Ranges from 0 to 100. Luma is welknown for being used in film-colour spaces.


This color space only registers grey-values. This is useful, because by only registering grey values, it only needs one channel of information, which in turn means the image becomes much lighter in memory consumption!

This is useful for textures, but also anything else that needs to stay grayscale, like Black and White comics.


Cyan, Magenta, Yellow, Key

This is the color space of printers. Unlike computers, printers have these four colors, and adding them all adds up to black instead of white. This is thus also called a 'subtractive' color space.

While CMYK has a smaller 'gamut' than RGB, however, it's still recommended to use a RGB working space profile to do your editing in. Afterwards, you can convert it to your printer's CMYK profile using either perceptual or relative colorimetric intend. Or you can just give the workspace rgb image to your printer and let them handle the work.


Luminosity, Red-chroma, Blue-chroma

YCrCb stands for

Luma/Luminosity, thus, the amount of light a color reflects.
Red Chroma. This value measures how red a color is versus how green it is.
Blue Chroma. This value measures how blue a color is versus how yellow it is.

This color space is often used in photography and in (correct) implementations of JPEG. As humans you're much more sensitive to the lightness of colors, and thus JPEG tries to compress the Cr and Cb channels, and leave the Y channel in full quality.

Krita doesn't bundle a ICC profile for YCrCb on the basis of there being no open source ICC profiles for this color space. It's unusable without one, and also probably very untested.


Back in 1931, the CIE(Institute of Color and Light), was studying human color perception. In doing so, they made the first color spaces, with XYZ being the one best at approximating human vision.

It's almost impossible to really explain what XYZ is. Y is in this case supossed to be the luminosity. Z is almost equal to human cone-response to blue. X is supossed to be the rest.

XYZ is used as a baseline reference for all other profiles and models. All color conversions are done in XYZ, and all profiles coordinates match XYZ.


Stands for:

Lightness, similar to luminosity in this case.
a* in this case is the measurement of how magenta a color is versus how green it is.
b* in this case is a measurement of how yellow a color is versus how blue a color is.

L*a*b* is supossed to be a more comprehensible variety of XYZ and the most 'complete' of all color spaces. It's often used as an in between colour space in conversion, but even more as the correct color space to do color-balancing in. It's far easier to adjust the contrast and color tone in L*a*b*.

L*a*b* is technically the same as Photoshop's LAB. Photoshop specifically uses CIELAB d50.

L*a*b* is a little broken. Many Blending modes don't work as expected, pure grey is off, exporting doesn't work right, and 32bit float gives black bars

Color depth and HDR(High Dynamic Range)

Indexed color

Indexed color is not supported by Krita, but mentioned here for extensiveness. Indexed color is a limited amount of colors per an image. These images often have a palette which tells the computer which index related to which color.

Only two colours in total, usually black and white.
4bit(16 colors)
16 colors in total, these are famous as many early games were presented in this color palette.
256 colors in total. 8bit images are commonly used in games to save on memory for textures and sprites.

Direct color

Direct color makes use of a more proper coordinate system and color models. It's measured these days in bits per channel.

4bit per channel(not supported by Krita)
Also known as Hi-color, or 16bit color total. A bit of an old system, and not used outside of specific displays.
8bit per channel
Also known as "True Color", "Millions of colors" or "24bit/32bit". The standard for many screens, and the lowest bit-depth Krita can handle.
16bit per channel.
One step up from 8bit, 16bit per channel allows for colors that can't be displayed by the screen. However, due to this, you are more likely to have smoother gradients. Sometimes known as "Deep Color".
16bit float
Similar to 16bit, but with more precision. Where 16bit only allows coordinates like [1, 4, 3], 16bit float has coordinates like [0.15, 0.70, 0.3759] . Required for HDR images.
32bit float
similar to 16bit float but with even higher precision. The native color depth of OpenColor IO, and thus faster than 16bit float in HDR images, if not heavier.


HDR stands for High Dynamic Range. HDR images are images that acknowledge that your screen's white is not the whitest white possible. For example, an HDR image of a sunny day with clouds in the sky can see that the areas around the sun has many more whites than the areas around the shadows. Where a normal image would say that those whites around the sun are the same color, HDR images try to define it as different colors, which is invaluable for Photographers and Computer graphics artists.

Krita supports HDR images through OpencolorIO and the LUT docker. You'll need to use the scRGB working space in either 16bit float or 32bit float to work with HDR imaging.

Color profiles

So to make it simple, a color profile is just a file defining a set of colors inside a pure XYZ color cube. This "color set" can be used to define different things:

-the colors inside an image

-the colors a device can output

Choosing the right workspace profile to use depends on how much colors you need and on the bit depth you plan to use. Imagine a line with the whole color spectrum from pure black (0,0,0) to pure blue (0,0,1) in a pure XYZ color cube. If you divide it choosing steps at a regular interval, you get what is called a linear profile, with a gamma=1 curve represented as a straight line from 0 to 1. With 8bit/channel bit depth, we have only 256 values to store this whole line. If we use a linear profile as described above to define those color values, we will miss some important visible color change steps and have a big number of values looking the same (leading to posterization effect). This is why was created the sRGB profile to fit more different colors in this limited amount of values, in a perceptually regular grading, by applying a custom gamma curve (see picture here: to emulate the standard response curve of old CRT screens. So sRGB profile is optimised to fit all colors that most common screen can reproduce in those 256 values per R/G/B channels. Some other profiles like Adobe RGB are optimised to fit more printable colors in this limited range, primarily extending cyan-green hues. Working with such profile can be useful to improve print results, but is dangerous if not used with a properly profiled and/or calibrated good display. Most common CMYK workspace profile can usually fit all their colors within 8bit/channel depth, but they are all so different and specific that it's usually better to work with a regular RGB workspace first and then convert the output to the appropriate CMYK profile.

Starting with 16bit/channel, we already have 65536 values instead of 256, so we can use workspace profiles with higher gamut range like Wide-gamut RGB or Pro-photo RGB, or even unlimited gamut like scRGB.

But sRGB being a generic profile (even more as it comes from old CRT specifications..) , there is big chances that your monitor have actually a different color response curve, and so color profile. So when you are using sRGB workspace and have a proper screen profile loaded (see next point), Krita knows that the colors the file contains are within the sRGB color space, and converts those sRGB values to corresponding color values from your monitor profile to display the canvas.

Note that when you export your file and view it in another software, this software has to do two things: -read the embed profile to know the "good" color values from the file (which most software do nowadays; when they don't they usually default to sRGB, so in the case described here we're safe ) -and then convert it to the profile associted to the monitor (which very few software actually does, and just output to sRGB.. so this can explain some viewing differences most of the time).

Krita uses profiles extensively, and comes bundled with many.

The most important one is the one of your own screen. It doesn't come bundled, and you have to make it with a color profiling device. In case you don't have access to such a device, you can't make use of Krita's color management as intended. However, Krita does allow the luxury of picking any of the other bundled profiles as working spaces.

Profiling devices

Profiling devices, called Colorimeters, are tiny little cameras of a kind that you connect to your computer via an usb, and then you run a profiling software(often delivered alongside of the device).

If you don't have software packaged with your colorimeter, or are unhappy with the results, we recommend Argyllcms

The little camera then measures what the brightest red, green, blue, white and black are like on your screen using a predefined white as base. It also measures how grey the color grey is.

It then puts all this information into an ICC profile, which can be used by the computer to correct your colors.

It's recommended not to change the "calibration"(contrast, brightness, you know the menu) of your screen after profiling. Doing so makes the profile useless, as the qualities of the screen change significantly while calibrating.

To make your screen display more accurate colors, you can do one or two things: profile your screen or calibrate and profile it.

Just profiling your screen means measuring the colors of your monitor with its native settings. and put those values in a color profile, which can be used by color-managed application to adapt source colors to the screen for optimal result. Calibrating and profiling means the same except that first you try to calibrate the screen colors to match a certain standard setting like sRGB or other more specific profiles. Calibrating is done first with hardware controls (lightness, contrast, gamma curves), and then with software that creates a vcgt (video card gamma table) to load in the GPU.

So when or why should you do just one or both?

Profiling only: -with a good monitor: you can get most of the sRGB colors and lot of extra colors not inside sRGB. So this can be good to have more visible colors. -with a bad monitor: you will get just a subset of actual sRGB, and miss lot of details, or even have hue shifts. Trying to calibrate it before profiling can help to get closer to full-sRGB colors.

Calibration+profiling: -bad monitors, as explained just before. -multi-monitor setup: when using several monitors, and specially in mirror mode where both monitor have the same content, you can't have this content color-managed for both screen profiles. In such case, calibrating both screens to match sRGB profile (or another standard for high-end monitors if they both support it) can be a good solution. -soft-proofing: when you need to match an exact rendering context for soft-proofing, calibrating can help getting closer to the expected result. Though switching through several monitor calibration and profiles should be done extremely carefuly.

Krita color management workflow

So how are you going to use this to your advantage? First, it's best to try and get your screen profiled for this. It allows you to see the colors more accurately. After that, you'll want to pick your favourite working space profile to work in and set that in the preferences. Once you finish your image, you'll consider how to export it.

But first let's explain what working profiles are.

Screen Profiles vs Working Profiles

If you have your screen profiled, it's not the best idea to work in said profile. This is because your screen shows red green and blue at different intensities. This means, that performing mathematics on the colours(which is done very often in image manipulation software) is difficult, and does not always have the expected result.

You're actually better off using a working space profile.

A working space profile is an icc profile that is well behaved. This means that the middle point of the three colour channels is a middle grey. This makes it easier to do image manipulation on them, and get the desired effect.

Examples of working spaces are:

  • Adobe RGB or Adobe RGB 1998 compatible
  • ProPhoto RGB
  • Wide Gamut
  • scRGB/sRGB. The former is intended for HDR imaging.

You can also consider to work in 16bit or higher. This allows for more precise gradations and color calculations, though it makes your files rather heavy.


You can change the color profile used by Krita in the preferences. You can pick the default color model, the color profile for correcting your screen and the color profile assumed when pasting images in from another application.

Color model per layer or per image.

You can decide upon a color profile per image, changing them using image-> convert color space. However, you can also have different color profiles per layer, set in Layer ->Convert Layer Color Space.

Converting color space

Using Image->convert image color space or Layer->Convert Layer Color Space, you can convert the color space of the whole image or a signle layer respectively.

The dialogue contains the following:

Choose the color space that you want to convert to.
Choose the bit depth you wish to convert to.
Choose the profile you wish to convert to. Using the icon next to this drop down, you can browse your filesystem for an ICC profile not in the list. After selecting it, Krita will add it to the list for use in Krita.

Rendering Intent How the colors should be converted.

Perceptual(Recommended in most cases)
Will try to convert the colors in such a manner that their relative contrast to each other is maintained.
Relative Colorimetric(Recommended as well)
Will maintain all the colors where the new and old color-space intersect. However, colors in the old colorspace that are outside the new color space will be pushed to the closest 'edge' of the new color space. This method is recomended if you need to have some colors absolutely accurate at the cost of others.
Here the 'saturation' of the color will be maintained at all costs, even if the hue has to be shifted. Useful for images where saturation is more important than hue, like infographics.
Absolute Colorimetric
This one tries to reproduce the exact colors of the original image. However, it can fail badly, leading to awful looking results. Recommended only for reproduction work, like scans.
Black-point compensation
This adjusts the whites and black to match up between the old color-space and the new color space.
Allow Little-cms optimisations
Allows optimisations. May not always be beneficial.

For more info on the subject, please do visit this website.


when you finished you image and are ready to export it, you can modify the color space to optimise it:

If you are preparing an image for the web:

  • If you use 16bit color depth or higher, convert the image to 8bit color depth. This will make the image much much more smaller.
  • If it's a grayscale image, convert it to grayscale.
  • If it's a color image, keep it in the working space profile: Many web browsers these days support color profiles embedded into images. Firefox, for example, will try to convert your image to fit the color profile of the other's monitor(if they have one), that way, the image will look near exactly the same on your screen and other profiled monitors.

If you are preparing for print:

  • You hopefully made the picture in a working space profile, if not convert it to something like adobe rgb.
  • Check with the printer what kind of image they expect. Maybe they expect RGB color space, or perhaps they have their own profile.

Filters and blending modes.

Maybe you have noticed that blending modes in LAB don't work like they do in RGB or CMYK. This is because the blending modes work by doing a bit of maths on the color coordinates, and because color coordinates are different per color space, the blending modes look different.

To make your life more easy, the Krita developers try to adjust each blending mode to work the same in each color space. File a bugreport, so they are aware of the blending mode not working expectedly in a color space.

Content is available under Creative Commons License SA 4.0 unless otherwise noted.