A film look does not come from adding grain at the end of a pipeline.
Grain matters, but it only works when it belongs to the rendered image. If the color response is brittle, the grain ignores image density, or particle size only makes noise louder, the result does not become more film-like. It just becomes noisier.
The better question is:
How should color response, image density, and grain particles work together?
That is the renderer boundary I changed in Filmtone Desktop v1.13.
The short version
For this release, I treated film look as a relationship between four parts:
color response
+ image-density response
+ particle scale
+ particle density
= texture that belongs to the image
Filmtone Desktop v1.13 changes the native renderer in three places:
- built-in Stone, Urban, and Noir now carry an internal Exposure / Density Color Response stage;
- grain moved away from direct RGB noise toward a density-domain particle model;
-
Grain Sizenow feeds an internal Texture Engine:
Texture = ScalingField(image) * ParticleField(seed, params)
No new grain panel. No sidecar schema change. No export workflow change.
The point was to improve the model before adding more controls.
Why "add noise" breaks down
The simplest grain implementation looks like this:
output.rgb = graded.rgb + noise.rgb * amount
That can be useful as a debug view, but it has a predictable visual failure: the noise does not know anything about the image it is being applied to.
On smooth bright surfaces, it can read as a layer of speckle. On skin or saturated colors, independent RGB movement can become colored dirt. In dense shadows, grain can turn into muddiness instead of texture.
The failure is not just amplitude. Turning the slider down hides the problem, but it also removes the texture.
The model needs better boundaries.
1. Color response before grain
If a strong grade already separates color too harshly, grain will amplify the breakpoints.
In Filmtone Desktop v1.13, the built-in Stone, Urban, and Noir paths now include an internal Exposure / Density Color Response stage. This is not a new user-facing control. It is a renderer-stage change inside the built-in preset path.
Imported LUTs and custom grade paths stay neutral unless they explicitly opt into this response in a future release.
The goal is simple: make the color response hold together before particles are added.
2. Grain as a density-domain particle model
The next change was to stop treating grain as unrelated RGB pixels sprinkled over the frame.
The release moves the built-in grain path toward:
mostly luma/density residual
weak correlated dye variation
no independent RGB color dirt
procedural particle structure
This is not a full film-emulsion simulation. Filmtone Desktop v1.13 does not ship scanned grain plate libraries, measured stock profiles, or a claim of physical film accuracy.
The narrower goal is more useful for this release: make procedural grain behave more like image texture and less like an overlay.
3. Splitting where texture appears from what particles are
The larger internal change is the Texture Engine shape:
Texture = ScalingField(image) * ParticleField(seed, params)
ScalingField answers where the texture should be visible. For grain, it is image-dependent: highlights, mid tones, and shadows should not all carry particles the same way.
ParticleField answers what the texture looks like. It owns particle size, density, variation, and stochastic structure.
That split matters because grain size is not the same thing as grain amount.
If increasing Grain Size only makes the noise coarser or louder, bright smooth areas quickly become uniform digital spray. The renderer needs a morphology axis: as particles get larger, particle density should be able to change too.
In v1.13, Grain Size feeds this Texture Engine so the renderer can trade particle density for particle scale. Bright areas can hold fewer, larger particles instead of only gaining more speckle.
The core path looks like this:
graded image
|
v
internal color / density response
|
v
ScalingField(image) ParticleField(seed, params)
| |
+------ texture = scaling * particles
|
v
density-domain grain response
|
v
output image
Why this stayed internal
I did not add more controls for this release because the public UI was not the problem.
The old model could fail even with reasonable control values. Adding more sliders would have asked the user to compensate for renderer behavior that should be handled inside the image pipeline.
So the public surface stayed stable:
- existing controls;
- existing saved settings;
- existing sidecars;
- existing export workflow.
The renderer changed underneath the built-in Stone, Urban, and Noir paths.
Boundaries
A few boundaries are important.
Filmtone Desktop v1.13 is a public Desktop release, not an iOS release announcement. Filmtone's iOS public App Store version is a separate release axis.
This release also does not claim parity with named film-emulation tools. It uses familiar ideas from grain synthesis and procedural particle models, but the shipped behavior is Filmtone's own native renderer path.
Print Material speck and Backlight Veil mottle are not public texture surfaces in this release. The Texture Engine foundation is used for grain first.
Takeaway
If I had to reduce the implementation lesson to one line:
A film look needs grain to be part of image formation, not a noise layer after it.
For Filmtone Desktop v1.13, that meant color response first, density-domain grain second, and a Texture Engine that separates where texture appears from what the particles are.
Small UI release. Meaningful renderer change.