Writing
Colour Management Is a Pipeline Contract
Blender 5.0 reads as better display options. Giving a file an explicit working colour space is an architectural change.
Notes
Blender 5.0 arrived two days ago with a colour-management change that looks, at first, like a collection of better display options: ACES 1.3 and 2.0 views, ACEScg, Linear Rec.2020, Rec.2100 PQ and HLG, HDR and wide-gamut output.
I think the larger change is architectural.
Blender now gives each blend file an explicit working colour space. That space affects materials, lights, rendering and compositing. Blender's own release notes recommend choosing it at the beginning of a project and using it across the project files.
That turns colour management from a viewing preference into part of the production contract.
Colour is data before it becomes an image
It is easy to think about colour management at the end of the pipeline.
A render looks different on another monitor, so we change the view transform. An image looks washed out in another application, so we check whether it was tagged as sRGB. HDR delivery needs another export setting.
Those are output symptoms. The problem can begin much earlier.
A texture has a colour encoding. A material interprets those values inside a working space. Lighting produces scene-linear values. Compositing combines them mathematically. A view transform maps that scene-referred result toward a display. The exported file then needs enough information for the next application to interpret it correctly.
If two stages disagree about any of those assumptions, the numbers can remain valid while the appearance changes.
This is why I think colour space belongs in the same category as units, coordinate systems or frame rate. It is metadata with consequences.
The working space is not the look
Blender 5.0 makes a useful distinction more visible: working space and view transform are not the same thing.
The working space defines the scene-linear RGB representation used for rendering, compositing and colour data inside the file. Blender 5.0 keeps Linear Rec.709 as the default and adds Linear Rec.2020 and ACEScg as wider-gamut options.
The view transform answers a different question: how should those scene values be mapped for a particular display?
Blender now includes ACES 1.3 and ACES 2.0 views alongside AgX and Filmic, with SDR and HDR options. It adds Rec.2100 PQ and HLG displays and an AgX HDR view.
That separation matters in production because changing the view should not redefine the scene.
If I build a product material in ACEScg, the material should not become a different material because I preview the scene on an SDR monitor today and an HDR display tomorrow. The scene-referred values are the asset. The display transform is the interpretation required by the target.
Conflating those layers makes a pipeline fragile.
ACES matters because projects cross applications
ACES is often discussed as a cinema or VFX standard, but the part I care about is less glamorous: interoperability.
Blender is rarely the whole production pipeline.
A product visualisation may begin with textures from Substance, move through Blender, produce OpenEXR files for compositing, pass through After Effects or another grading environment, then end as sRGB web images, Display P3 assets or video.
Game production has another path. Source textures may be authored in one application, reviewed in Blender, imported into an engine and viewed through a completely different display pipeline.
If each application has a different definition of what the RGB values mean, visual consistency depends on manual fixes.
OpenColorIO exists to make those transformations explicit and shareable across applications. Blender has used OCIO for years, but Blender 5.0 improves ACES 2.0 compatibility and warns when a blend file was created with a different OCIO configuration.
That warning is a small UI feature with a large implication: the configuration is part of the project state.
A file created under one colour pipeline cannot always be interpreted safely under another without knowing that the change happened.
HDR exposes assumptions that SDR could hide
HDR makes this problem harder to ignore.
For SDR work, many pipelines have survived with an informal assumption that the final image ends up in something close to sRGB or Rec.709. That can hide mistakes because most tools and monitors are built around similar expectations.
Blender 5.0 can now display and export HDR and wide-gamut images and video. The release adds Rec.2100 PQ and HLG targets, Display P3 and wider internal working spaces.
Once output may be sRGB, P3, Rec.2020 or HDR, there is no single implicit "correct" display anymore.
A value that produces an acceptable highlight on a normal monitor can map very differently on an HDR display. A saturated material that fits inside Rec.2020 may fall outside the gamut of an sRGB target. Tone mapping and gamut mapping become delivery decisions rather than cosmetic options.
ACES 2.0 itself reflects this problem. Its revised output transforms were designed to provide more consistent rendering across different display targets, with updated tone scale and gamut mapping behaviour.
This is why a production pipeline needs to know its target before the final export dialogue.
This changes how I would structure 3D production
For Blender work, I would now treat working colour space as a project-level decision.
It should sit beside units, render engine, output resolution, asset naming and frame rate in the initial setup. Templates should define it. Automated scene validators should check it. Render jobs should record it. Export scripts should know which target they are producing.
I would not let individual artists quietly change the working space halfway through production because one image looks better.
Blender can convert between working spaces, but its documentation warns that those conversions are approximate and can require manual fixes.
Product visualisation makes this especially visible.
A client may provide brand colours as sRGB values. The scene may render in ACEScg. The compositor may work on floating-point OpenEXR. The web deliverable may return to sRGB while a display campaign needs P3 or HDR.
The same red can pass through several representations without any one of them being "the red." What matters is preserving its intended appearance and meaning through known transforms.
That is a pipeline problem.
Automation needs colour metadata
This becomes even more important as production becomes automated.
A script can batch-convert hundreds of textures very efficiently and still destroy a project if it guesses the input colour space incorrectly. An AI agent can export every requested image and still deliver the wrong result if it does not know whether the target expects display-referred sRGB, scene-linear EXR or ACEScg.
Colour therefore needs to be represented as machine-readable state.
Blender 5.0 moves in that direction. OpenEXR files gain Colour Interop ID metadata support for automatic colour-space detection. The working space is stored with the blend file. Linked and appended data can be converted to match the current file's working space.
Those mechanisms reduce hidden assumptions.
For an automated production pipeline, I would want every asset entering the system to answer three questions: what colour space is this data in, what space should computation happen in, and what transform is expected at delivery?
If the system cannot answer those questions, automation only makes the mistake faster.
My takeaway: colour management is an interface contract
I think colour management will move further away from being an artist preference and closer to being infrastructure.
The reason is not ACES by itself. It is that production is becoming more distributed: more applications, more automated tools, more display classes and more generated intermediates.
Every boundary needs a shared interpretation of colour.
A Blender scene needs to know how textures enter the working space. A compositor needs to know how render data should be read. An engine needs to know how authored assets map into its rendering pipeline. The delivery system needs to know whether it is targeting SDR, P3, PQ or HLG.
Once these assumptions are explicit, the creative choices become safer because the pipeline stops changing underneath them.
Blender 5.0 is a useful marker for this shift. ACES support and HDR are the visible features. The more important change for me is that the working colour space has become a first-class property of the file and the production process around it.
The renderer produces numbers.
The pipeline has to agree on what those numbers mean.
Sources
- Blender Foundation, Blender 5.0 Release, 18 November 2025.
- Blender Developer Documentation, Blender 5.0: Colour Management.
- Blender Foundation, Blender 5.0, What's New.
- Academy Colour Encoding System, What is ACES 2?
- OpenColorIO, project documentation.
More
Other write-ups
Approval Is Not Publication
Thirty seven items in the queue, one approved, nothing published. The last arrow in the diagram is the only one that pays.
Neural Rendering Is Crossing From Reconstruction Into Synthesis
Reconstruction filled in what sparse sampling missed. DLSS 5 generates appearance the renderer never computed.
The Renderer Is Becoming a Training Data Engine
The renderer used to sit at the end of the pipeline. Physical AI gives the same scene a second job: teaching a model.
Local AI Is Becoming a Compute Fabric
Local AI meant one model on one machine. Routing inference across the devices already on a network changes the unit.
Agent Infrastructure Is Becoming a Product Category
Every team used to build the loop, the store, the sandbox. That layer is being sold rather than written.
Choosing a local model with a stopwatch, not a benchmark
Three models, five hard tasks, code actually executed. The official build was 2.4 times faster and more accurate than a community repack of the same model.
We measured real time lighting against baked light, and baked won
A 3D product simulation that had to look like an offline render. The real time version ran at 60 frames per second and looked like clay. Here is the measurement and the architecture that replaced it.
What actually broke in an agency run by agents
Three failures from a delivery stack that runs on AI. None of them were the model's fault, and all three reported success while producing nothing.
A Task Without A Check Command Is Not Automated
If a task has no command that can fail, the pipeline advances on the appearance of work.
A Gate The Model Writes Is A Gate The Model Loosens
Three quality gates returned green while the work behind them was wrong, each for a different reason.
The Scoring Model Was Wrong And It Put The Worst Lead First
A weighted sum let one axis substitute for the other, so a company with money and no problem ranked in the top twenty.
Building Software Got Easy. Getting Value Out Of It Did Not
Aristo took weeks to build. Everything after the build is still in progress, and that gap is the whole story.
Capability Is Becoming an Operational Risk Surface
Safety questions used to be about the text. Once a model can act, the capability itself becomes something to operate.
The Scene Graph Is Becoming an API for AI
A scene graph exists for artists and software. Agents are becoming another consumer, and they need structure rather than pixels.
Animation Is Moving From Clips to Motion Priors
Authored keyframes and blended clips are giving way to asking which constraints define acceptable motion.
Materials Are Becoming Learned Programs
A material is texture maps, parameters and shader code. It is starting to become a small learned program that answers a rendering question.
Procedural Systems Are Expanding Beyond Geometry
Geometry Nodes started with a narrow name. Blender 5.2 puts physics, sound and object data through the same graph.
The Unit of AI Work Is Becoming the Task, Not the Turn
Chat taught us to think one turn at a time. Long-running agents make the task the thing that is scheduled, resumed and reviewed.
Game Engines Are Becoming Operating Systems for Worlds
Engines have been judged on what they render and simulate. The Unreal 6 roadmap points at operating a world rather than drawing one.
The Model Is Becoming a Replaceable Backend
Choosing a provider used to mean choosing an architecture. A stable interface makes replacement possible and evaluation makes it safe.
The Harness Is Part of the Capability
The same model behaves differently depending on context policy, tool design and execution feedback. That surrounding software is not neutral.
Physics Engines Are Becoming Trainable Components
A simulator predicts what happens next. A differentiable one can answer which parameter should change to stop the failure.
The Agent Needs an Environment, Not Just Tools
A search function and a database query were enough for short loops. Longer work needs a place to stand.
Coding Agents Are Becoming General-Purpose Computer Workers
Repositories were a friendly environment: text in, terminal actions, checkable results. That was a starting point, not a boundary.
Open Standards Outlive Model Generations
A year after the MCP bet, the argument can be checked against what happened rather than what was hoped.
The Best Model May Be a Router, Not a Model
GPT-5 moves model selection inside the system. The interesting unit stops being which model and becomes which compute policy.
World Models Are Not Game Engines Yet
Genie 3 generates a navigable 720p world at 24 fps. Production work needs state you can inspect when something goes wrong.
Memory Is Becoming a System Capability
A follow-up to the long-context argument. Storing, selecting and expiring facts is turning into a named part of the product.
Coding Agents Change the Unit of Software Work
AI coding tools have been judged where code appears on screen. The boundary moves when the agent owns a task instead of a snippet.
Agents Need Protocols Between Each Other, Not Just Tools
Tool calling solves the inside of the loop. It says nothing about one agent reaching another built by a different team on another platform.
Agents Need a Runtime, Not a Prompt Loop
An agent is no longer well described as a prompt inside a while loop. The useful abstraction owns execution around the model.
Reasoning Is Not the Only Path to Better Models
Longer thinking improves maths and code. A model that solves a logic puzzle and misreads ordinary intent is not the better production model.
Rendering Is Becoming a Reconstruction Stack
Sparse samples, motion data and lower-resolution frames become a larger final result. Debugging becomes layered when reconstruction sits in the middle.
Agent Reliability Is an Evaluation Problem, Not a Prompting Problem
When an agent misses a step, the usual fix is a stricter prompt. The failure is more often in how completion is detected.
MCP Might Matter More Than Another Model Release
A model can reason well and still be useless inside a company if it cannot reach the files, repositories and tools where work lives.
Computer Use Is the Missing Layer Between Models and Software
Most integrations assume useful software exposes the right API. Much of real software never did.
Inference-Time Compute Is a New Scaling Axis
o1 improves when it is allowed to spend longer on a problem. A benchmark score without a compute budget is an incomplete number.
The Final Pixel Won't Come From the Renderer
Geometry, camera and scene structure stay reliable ground truth. More of final appearance is moving into learned systems.
Open Models Are Becoming Research Infrastructure
Llama 3.1 gets discussed as a benchmark result. The licence terms change which experiments are possible at all.
The Model Is Becoming a Runtime
Function calling, code execution and structured output turn inference into a loop. The model stops being a text generator and starts being a control layer.
Multimodality Changes the Architecture, Not Just the Interface
GPT-4o is easy to read as a faster interface. Training one model end to end across text, vision and audio is an architectural change.
Benchmark Scores Are Not Model Capability
Claude 3 posts 86.8% on MMLU and 50.4% on GPQA Diamond. The chart is useful and it is not the same thing as capability.
Long Context Is Not Memory
Gemini 1.5 makes a million tokens usable. A larger working set is not a system that decides what should survive the session.