Forem: Takumi Chiba

How to build a film look in a renderer without just adding grain

Takumi Chiba — Wed, 20 May 2026 11:33:50 +0000

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 Size now 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.

Try Filmtone in your browser

Download Filmtone Desktop for Mac

Making creative LUTs safer for Rec.709 video

Takumi Chiba — Sun, 17 May 2026 12:08:39 +0000

A strong creative LUT can look great on the footage it was designed around.
That does not mean it should hit every source the same way.

This was the problem behind the latest Filmtone Desktop release.

Filmtone has built-in creative Looks named Stone, Urban, and Noir. They are
designed to do more than a tiny color nudge: they can move contrast, hue,
saturation, glow, softness, and the optical finish of the image.

That is useful when the source is ready for a creative transform.

It is less useful when the source has already been rendered for display.

The source is part of the color decision

Rec.709 footage is often already opinionated.

It may already have:

display contrast baked in;
saturation pushed into a consumer-friendly range;
highlights compressed into a smaller space;
skin and sky colors that are usable, but not very flexible.

If a full creative LUT is applied directly on top of that, the failure mode is
easy to recognize:

highlight color breaks;
skin shifts too far;
saturation feels harsh;
dark color separation collapses;
lowering the whole LUT intensity makes the result safer, but also makes the Look less useful.

The tempting fix is simple:

If the source is Rec.709, reduce LUT intensity.

That helped, but it was not enough.

It made the transform less aggressive, but it did not change the shape of the
transform. The same hue and saturation moves were still there, just blended
back toward the source.

What changed in Filmtone Desktop 1.12

Filmtone Desktop 1.12 adds dedicated Rec.709-safe variants for the built-in
Stone, Urban, and Noir Looks.

On Rec.709, SDR BT.709, Display P3 SDR, or unknown display-referred sources,
the Desktop renderer now chooses a safer Look variant instead of only lowering
the full Look intensity.

The intent is not to make the result flat.

The intent is to keep the useful parts:

glow;
softness;
grain and finish controls;
before/after comparison;
playback review before export.

And pull back the parts that break fastest on already-rendered footage:

strong hue travel;
saturation spikes;
aggressive highlight color shifts;
compression moves that were tuned for a different source state.

Full Looks still matter

This does not mean every source should be treated like Rec.709.

If the footage is normalized through an explicit Log or camera profile path,
Filmtone keeps the full Creative Pack 01 Look behavior.

That distinction matters.

The product should not flatten all sources into one generic safe path. A Log
clip waiting for normalization is not the same starting point as an iPhone or
camera file that has already been rendered for display.

Filmtone now keeps those paths separate:

source profile / source state -> base grade -> optical finish -> creative Look decision -> export

Preview and export must agree

The other important part is less visible, but more important for trust.

Preview, still export, video export, and video composition rendering all resolve
the same source-aware built-in Look variant.

That means if a Rec.709-safe preview is shown, the export path uses the same
decision.

For a finishing tool, that matters more than having a long feature list. The
basic promise is:

What you judge in playback should be the thing you export.

Where this fits

Filmtone is not a full editing suite replacement.

It is a smaller tool for a smaller moment:

Open a clip.
Choose a Preset or Look.
Compare while the footage moves.
Adjust only what the footage asks for.
Export on Mac when the result is ready.

The Rec.709-safe variants make that path more reliable for the kind of footage
people already have: phone clips, camera files, SDR exports, and footage that
is technically usable but not yet finished.

If you work with video and LUTs, I would like feedback on whether this split
matches how you think about source material.

Try Filmtone:

Product Hunt launch will follow after this article has collected some early
feedback.