| 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
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
- Identify consumer pipeline.
- Map to color management config (see
references/pipeline-mapping.md).
- Pin Display Device + View Transform + Look + Sequencer.
- Document per-output transform if multiple outputs.
- 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
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
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.mdreferences/per-channel-rules.mdreferences/look-comparison.md../../docs/skill-system.md
