Color Management Decision

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

Optional inputs

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

Runtime status: Not Run | Attempted | Produced | Verified | Failed | Blocked / Not Run
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

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

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

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

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