CS Map

Colour Management

Also known as: color management, ICC profile, colour space, sRGB, P3, colour calibration

supplemental intermediate concept 5 min read · Updated 2026-06-17

A system for ensuring colours reproduce consistently across devices — cameras, monitors, printers — by converting between device-specific colour spaces using ICC profiles and a device-independent reference space.

Primary domain
Graphics & Media
Sub-category
Photograph Manipulation & Image Compression

In simple terms

The value (255, 0, 0) for red does not describe an absolute colour — it means “maximum red according to this device.” Different devices define “maximum red” differently: a camera’s red is not the same red as a monitor’s, which is different again from a printer’s. Colour management solves this by labelling colours with their device-specific context (an ICC profile), then converting between devices through a device-independent reference (CIELAB or CIEXYZ), so a photo looks the same on a calibrated monitor as it will in print.

The Visual Map

graph LR
    cam["Camera RGB\n+ ICC profile"] --> ref["Device-independent reference\nCIEXYZ / CIELAB"]
    work["Working space\nAdobe RGB / ProPhoto"] --> ref
    ref --> disp["Display profile\nsRGB / Display-P3"]
    ref --> print["Printer profile\nCMYK"]
    cal["Calibration: colorimeter\nmeasures actual output → ICC"] --> disp
    de["ΔE: perceptual difference\nbelow 1 invisible, above 2 noticeable"] --- ref

More detail

The problem: every device has its own gamut (range of reproducible colours) and its own transfer curve. (255, 0, 0) in sRGB is a specific shade of red; the same value in Adobe RGB 1998 is a deeper, more saturated red. Display an Adobe RGB image on an sRGB monitor without conversion and the colours look wrong.

Common spaces: sRGB (the web/consumer default, ~35% of visible colours, gamma ≈ 2.2); Adobe RGB 1998 (wider, especially greens/cyans, for pro photography); Display-P3 (Apple’s display space based on DCI-P3, ~45% wider than sRGB in reds/greens, standard on Apple displays, with CSS color(display-p3 1 0 0)); Rec. 2020 (the HDR target, ~75% of visible colours); and CIELAB (a device-independent perceptual space used as the reference for conversions). ICC profiles (International Color Consortium) describe a device’s colour characteristics by mapping its RGB/CMYK to CIELAB; they’re embedded in images, attached to displays by OS calibration, and used by printers.

The workflow: a camera captures in its native space and tags an ICC profile; a colour-managed app converts to a working space; the display renders by converting from the working space to the display’s ICC profile (measured by a colorimeter); and at export/print another conversion targets the output device (sRGB for web, CMYK for press). Operating systems provide this (macOS ColorSync, Windows ICM/WCS), and Chrome/Safari colour-manage images with ICC profiles. ΔE (Delta E) quantifies perceptual difference — below 1 is invisible to most people, above 2 is noticeable, above 5 obvious; professional grading targets ΔE below 2 from source to output. Colour management is invisible when correct and catastrophic when wrong: a UI designed on a P3 MacBook looks oversaturated on an sRGB monitor if unmanaged.

Under the Hood

The reason (255,0,0) is ambiguous becomes concrete when you convert it to CIEXYZ (an absolute, device-independent space) through two different displays’ primaries. Same code in, different physical colour out — which is exactly what a colour-managed pipeline corrects for:

# Each row maps linear R,G,B → CIE XYZ for that display's primaries (D65)
SRGB = [[0.4124, 0.3576, 0.1805],
        [0.2126, 0.7152, 0.0722],
        [0.0193, 0.1192, 0.9505]]
P3   = [[0.4866, 0.2657, 0.1982],     # Display-P3: redder, wider gamut
        [0.2290, 0.6917, 0.0793],
        [0.0000, 0.0451, 1.0439]]

def to_xyz(M, rgb):
    return [sum(M[i][j]*rgb[j] for j in range(3)) for i in range(3)]

red = [1.0, 0.0, 0.0]                 # "maximum red" in linear RGB
print("pure red (1,0,0) as absolute XYZ:")
print("  on sRGB display  :", [round(v, 3) for v in to_xyz(SRGB, red)])
print("  on Display-P3    :", [round(v, 3) for v in to_xyz(P3, red)])
print("Different XYZ -> physically different reds for the SAME code.")

A colour-managed app reads each image’s ICC profile, converts its values into this shared XYZ/Lab reference, then out to the display’s profile — so the physical colour stays constant across devices.

Engineering Trade-offs

  • Wide gamut vs compatibility. P3/Rec. 2020 displays show richer colour, but content shipped untagged looks oversaturated on the sRGB devices that assume sRGB.
  • Accuracy vs cost. Hardware calibration with a colorimeter and factory-calibrated panels achieves ΔE below 2 but costs money; consumer panels vary by ΔE 3–10 uncalibrated.
  • Per-step management vs simplicity. Tracking and converting colour at every stage is correct but complex; assuming sRGB everywhere is simple and increasingly wrong on modern displays.
  • Tagging discipline vs convenience. Always embedding/declaring colour spaces guarantees fidelity but adds metadata and process; untagged files force software to guess (usually sRGB).

Real-world examples

  • Apple’s Photos on iOS is fully colour-managed: P3 images display correctly on P3 screens; sRGB images are converted up to P3.
  • Netflix masters in DCI-P3 (or Rec. 2020 for HDR); colour management keeps it correct on both SDR sRGB monitors and HDR P3 TVs.
  • Chrome on macOS applies colour management to images with embedded ICC profiles; untagged images are assumed sRGB.
  • Print production runs sRGB → Adobe RGB → press CMYK; mismanaged conversions cause expensive colour shifts.

Common misconceptions

  • “PNG and JPEG are always sRGB.” Only if tagged as sRGB. An untagged file has no declaration — software must assume a space (usually sRGB).
  • “Colour management is only for professionals.” Wide-gamut mobile displays (all recent iPhones, most flagship Androids) make it essential for app and web developers.

Try it yourself

Show that an RGB triplet is meaningless without a colour space — convert pure red through two displays’ primaries and get two different absolute colours (python3 only):

python3 - <<'EOF'
SRGB=[[0.4124,0.3576,0.1805],[0.2126,0.7152,0.0722],[0.0193,0.1192,0.9505]]
P3  =[[0.4866,0.2657,0.1982],[0.2290,0.6917,0.0793],[0.0000,0.0451,1.0439]]
xyz=lambda M,c:[round(sum(M[i][j]*c[j] for j in range(3)),3) for i in range(3)]
red=[1,0,0]
print("red on sRGB :", xyz(SRGB,red))
print("red on P3   :", xyz(P3,red), "<- same code, different real colour")
EOF

Learn next

  • Color space — the spaces colour management converts between
  • HDR — needs wide colour spaces and colour-managed tone mapping
  • Anti-aliasing — correct edge blending depends on the right colour space
  • Subpixel rendering — where managed colours meet physical subpixels

Neighborhood

A visual companion to the relationships above. Click any node to visit that topic.