git:20260509.0ccc4f7 to git:20261014.1cb9fe7

---

name: color-management-decision

description: Pick the right color management config (sRGB / Filmic / ACEScg / Standard) per output context before render, so colors travel correctly to the consumer.

---

# color-management-decision

## Purpose

Avoid the most common Blender color mistake: rendering with the wrong color space and then "fixing" it in post. Pick the color management strategy upfront based on the consumer's color pipeline.

## Quick start

- name the consumer (web / print / video / game engine / film)

- pick one of: sRGB / Filmic / Standard / AgX / ACEScg

- pin per-output transform (display + view transform + look)

- emit a 4-line config record + handoff

## When to use

- before render / lookdev pass

- when consumer color pipeline is known

- when a previous render had unexpected color shifts

## When not to use

- post-render color grading (handled by compositor / DCC after render)

- raw modeling without lookdev (color management does not affect model accuracy)

## Trigger phrases

- "what color space"

- "Filmic vs Standard"

- "ACEScg for our pipeline"

- "colors look weird"

## Prerequisites / readiness

- consumer pipeline known

- target output format known (PNG / EXR / video / GLB)

## Input schema

### Required inputs

| Input | Why it is required |

|---|---|

| Consumer pipeline | sRGB web vs ACEScg film |

| Target output format | PNG/EXR drive different transforms |

### Optional inputs

| Input | Use |

|---|---|

| Reference image color | Match calibration |

| Brand color spec | Verify primary brand colors render correctly |

### Assumptions to confirm

- The user knows the consumer pipeline (or willing to ask).

- "Just looks good" is not a target; explicit pipeline match is.

## Output schema

### Primary output

A 4-line config record: Display Device, View Transform, Look, Sequencer.

### Secondary output

- per-output transform if multiple outputs (PNG + EXR + GLB)

- caveats per choice

- evidence label

### Evidence / caveat output

```txt

Artifact status: Not Run | Not Produced | Produced | Verified | Failed

Evidence used: <links, paths, logs, or "none">

Limitations: <known gaps>

```

## Required laws

- `../../laws/evidence-before-done.md`

- `../../laws/non-blender-user-language.md`

- `../../laws/no-arbitrary-python-interface.md`

- `../../laws/official-runtime-only.md`

## Official runtime boundary

Decision skill — does not run Blender. Pins config; operator applies in scene render properties.

## Operating procedure

1. Identify consumer pipeline.

2. Map to color management config (see `references/pipeline-mapping.md`).

3. Pin Display Device + View Transform + Look + Sequencer.

4. Document per-output transform if multiple outputs.

5. List caveats.

## Decision tree

```txt

Web (sRGB)?

→ Display sRGB, View Filmic (or Standard for pure flat color), Look None

Film / VFX with ACES (linear)?

→ Display sRGB, View AgX or Filmic, Look None; render output as EXR linear

Game engine (linear / sRGB textures)?

→ Display sRGB, View Standard; export textures as PNG sRGB / Linear per channel

Print?

→ Display sRGB; soft-proof to CMYK in compositor; usually delegate to print prep tool

```

## Playbooks

### Playbook A: Web hero (sRGB PNG)

Display: sRGB. View Transform: Filmic. Look: None or Medium High Contrast. Sequencer: sRGB. Output: PNG 8-bit sRGB.

### Playbook B: Film / VFX EXR

Display: sRGB. View Transform: AgX. Look: None. Sequencer: sRGB. Output: OpenEXR Linear 16-bit half float.

### Playbook C: Game engine (Unity / Unreal)

Display: sRGB. View Transform: Standard. Look: None. Output: per-texture rules (color textures sRGB, data textures Linear).

### Playbook D: GLB for web (Three.js)

Display: sRGB. View Transform: Filmic. Look: None. GLB embedded textures: color = sRGB, data = Linear. Three.js renderer.outputColorSpace = SRGBColorSpace.

## Mode handling

### Text-only mode

Config record only.

### Runtime-ready mode

Config record + verified by render preview cross-check (Filmic looks darker than Standard for lit scenes; verify intent).

### Blocked runtime mode

Config record only.

## Validation checklist

- [ ] Consumer pipeline identified

- [ ] Display Device + View Transform + Look + Sequencer pinned

- [ ] Per-output transform if multiple outputs

- [ ] Caveats listed

- [ ] No "looks good" verdict

## Pass / Warn / Fail rubric

| Verdict | Criteria |

|---|---|

| Pass | Pipeline-correct config; all 4 lines pinned; per-output rules explicit. |

| Warn | Config pinned but caveat for one output type missing. |

| Fail | Wrong pipeline match (e.g. Filmic for ACES VFX); skipped per-output rules; "looks good" verdict. |

## Failure handling

- Pipeline unknown → ask once; default to sRGB+Filmic for web.

- Mixed pipelines (web preview + VFX EXR from same scene) → set per-output, render multiple times if needed.

## Troubleshooting

| Problem | Response |

|---|---|

| Colors washed out | Verify View Transform is not Standard for HDR scenes; Filmic is better. |

| Colors too contrasty | Try Look = None; or use AgX. |

| Brand color reads wrong | Verify color picker is in linear vs sRGB intentionally. |

| Texture appears too bright | Verify color texture is loaded sRGB; data texture loaded Linear. |

## Best practices

- One config per render, not "default and hope".

- Verify with a known reference (color chart or brand color).

- Document choices in scene metadata.

- Avoid post-process color grading inside Blender for web — let the consumer do it.

## Good examples

- "Consumer: web hero PNG. Display: sRGB. View Transform: Filmic. Look: None. Sequencer: sRGB. Output: PNG 8-bit sRGB."

## Bad examples

- "Use Filmic." — no pipeline context.

## User-facing response template

```txt

Consumer pipeline: <web / VFX-ACES / game-engine / print / GLB-Three.js>

Output(s): <list>

Color management config:

Display Device: <…>

View Transform: <…>

Look: <…>

Sequencer: <…>

Per-output rules:

<output>: <transform / file format>

Caveats: <list>

Limitations: <gaps>

Next: render-export-evidence

```

## Anti-patterns

- "Just use Filmic" without pipeline context.

- Mixing color spaces between scene textures and view transform without intent.

- Post-render color grading inside the same render pass.

## Cross-skill handoff

- Render evidence → `../render-export-evidence/SKILL.md`

- Material check → `../material-quality-checker/SKILL.md`

- Output format → `../output-format-decision/SKILL.md`

- Engine choice → `../cycles-vs-eevee-decision/SKILL.md`

## Non-goals

- Color-grade in post.

- Run Blender.

- Calibrate a monitor.

## References

- `references/pipeline-mapping.md`

- `references/per-channel-rules.md`

- `references/look-comparison.md`

- `../../docs/skill-system.md`