Toward the world's best free video noise reducer

Abstract

We asked one question — how does a free plugin become the most effective video noise reducer on the planet? — and answered it twice: by measuring the current denoiser on real 4K night footage, and by convening nine independent domain experts who read the actual source, generated 68 ideas, then adversarially stress-tested every one.

The central finding is a strategic inversion. Hush's noise removal is already excellent — good enough that nearly every idea whose only job was to remove more noise was killed or demoted for "merely lowering a number." The frontier is texture reconstruction: after the noise is gone, put back what real optics and real film would have left — optical edge acutance (sharpness that reads like a lens, not a sharpen filter) and emulsion-grade grain (matched to the noise that was removed, not a white-noise dither). Nine lenses converged on this independently. That convergence, not any single idea, is the result.

01What the panel did

The empirical baseline measured, not assumed

Before ideating, the exact CPU reference pipeline was run on real footage — a 4K DCI ProRes night portrait, with handheld drift and a focus pull. Native-resolution crops with shadows lifted 4× (to expose what a colorist sees after grading) gave a clear verdict.

Those two weaknesses and the brief's north star — remove noise while preserving or enhancing sharpness, with film-like grain, not video crunch — became the fixed target for every agent.

The panel

Nine lenses ran in parallel — transform-domain, motion, deconvolution, perceptual/grain, grading-integration, signal-model, tiny-ML, systems, and a cross-domain wildcard. Each read the source, grounded ideas in real functions, avoided shipped features and a "graveyard" of measured-dead ideas, and attached a control arm to every idea: the cheap baseline it must beat, and by how much, on a prototype before any code. A plain post-blur once beat a ground-truth-offset super-resolution accumulator by 1.9 dB — so a win against a strawman is worthless. Every idea then faced an independent adversary judging thesis-fit, novelty, four-backend feasibility, real-time cost, and whether the control arm was real. Verdict: 22 keep, 33 maybe, 13 kill.

02The finding: texture reconstruction

The lenses weren't told to agree, yet they converged hard. Read across all nine, the same three-part architecture appears again and again, each expert arriving from a different direction:

1 · Optical acutance on the cleaned signal. Sharpen after denoising, gated by the plugin's own noise field so it can never amplify noise, and overshoot-bounded so edges gain slope without the bright halo that reads "video."

2 · Detail transfer, not blur inversion. Put back the high-frequency structure the denoiser removed by coring the denoise delta — amplify what survives a noise-scale threshold, discard the rest. Halo-free by construction.

3 · Reconstructed film grain. Replace the spectrally-white, mid-gray-peaked value-noise with grain whose amplitude follows the measured shadow-loud noise curve, whose spectrum is shaped near the eye's contrast-sensitivity peak, and which is placed where the denoiser waxed the image — refilling exactly what was removed.

Why this is the answer and not "denoise harder": the kills prove it. Almost every killed or demoted idea did so for the same reason — it only lowered a noise number, which the north star explicitly rules out. Hush stops competing on "cleanest" (a race against paid tools with far larger teams) and wins on "most filmic" — a race almost nobody is running, and one a small, transparent, free plugin can lead.

03The 22 survivors, as one architecture

The keepers aren't a list; they're four subsystems plus a substrate. Chips show the adversary's confidence.

04What was killed — the sharpest lessons

The kills encode discipline. The through-line: an idea that only makes the image cleaner is, at this point, not good enough.

05A build sequence, with honest gates

Each item is prototyped on the real clip, gated against its stated control arm, then ported to four kernels only if it passes. Grain and acutance add high-frequency energy on purpose — they're gated on acutance / overshoot / matched-RMS / blind preference, never on PSNR.

Code-level corrections the panel surfaced (all since fixed in v3.6): the grain response peaked mid-gray (backwards); the luma-texture re-add was uncored (re-noising the shadow it was meant to fix); Detail Rescue was preserve-only (gain ≤ 1 — no sharpening existed). And effN plus the residual field were computed but under-consumed — they now ride the acutance gating and the confidence matte, exactly as predicted.

06Splitting NR across Color-page nodes

Yes — and how you split it is itself a quality lever. Six situations, in rough order of everyday impact:

• Isolation for caching (the biggest win). Put NR on its own node, early, and let Resolve cache it — grade in real time without re-running the most expensive op on every tweak.
• Before the grade amplifies the noise. Lift/gamma/gain and saturation magnify grain — denoise upstream of the creative grade. Hush fetches ±3 neighbor frames, so the node before it is what it denoises; put it first so Render Boost's history stays coherent.
• Region-split via qualifiers / Power Windows. Shadows want heavy NR, skin wants gentle (keep pore texture), sky wants aggressive chroma, highlights almost none — exactly what the qualifier-matte-input keeper folds into one node.
• Denoise early, sharpen late. Cleanup is scene-referred; acutance and grain are display-referred finishing. Run NR on an early cached node and the texture mode on a final node, on graded contrast. Clean early, reconstruct late.
• Temporal early, spatial late. Temporal NR needs coherent frame-to-frame motion — run it before anything disturbs it; spatial NR after the balance.
• Parallel blend & confidence downstream. Mix NR back at reduced opacity for a gentler result; hand the clean-confidence matte forward so a later node keys shadow-lift and grain off where the denoiser actually succeeded.

The design implication: Hush should be built to live in a node graph — cacheable, matte-in for region control, confidence-out for the grade, and mode-selectable so the same plugin is both the early clean-up node and the final texture-reconstruction node.

07Postscript: from study to shipped

Added 2026-07-16 · after v3.6 built Phase 0 and the first Phase-1 fix

The study was a design panel. The next day a second Claude instance built its Phase 0 and the start of Phase 1 — across the CPU reference and all three GPU kernels at parity, gated on the same night clip. Building it did what a panel cannot: it shipped the thesis, and it corrected the paper in three places. That correction is the entire point of the X3 "prototype before code" law — here is what it caught.

Shipped in v3.6. The full Phase-0 quartet — shadow-loud, contrast-masked, blue-noise grain; overshoot-bounded optical acutance; detail-transfer coring; and the clean-confidence matte — plus the Phase-1 shadow chroma-speckle fix. Everything is off by default, so existing projects render bit-for-bit identical until you reach for it.

1 · The blue-noise grain formula was backwards for this codebase. The study proposed gn − gHi·valueNoise(2·size). But here valueNoise at a coarser scale is an independent field — subtracting it adds low-frequency energy, the opposite of blue. On the real clip the high-frequency fraction moved the wrong way (0.41 → 0.29). The true high-pass subtracts a low-pass of the same grain field (its four-neighbour mean, a grain-cell away), which put the spectrum where it belongs: 0.41 → 0.69. A one-line error no panel could have caught without measuring.

2 · Auto-tuning correlated chroma noise needs generalized SURE — the build's most transferable result. The self-tuner's chroma pass read the real shadow speckle backwards and de-tuned a good profile by ~0.9 dB. The cause is textbook but easy to miss: Monte-Carlo SURE is an unbiased error estimate only for white noise, and the speckle is spatially correlated. Match the probe's own correlation to the measured noise — a block-constant Rademacher field at the estimated correlation length — and the estimator becomes generalized SURE (it measures tr(AΣ), not σ²·tr(A)); its argmin tracks true error again. The 0.9 dB loss became a 3.0 dB gain. The lesson outlives this plugin: if you tune against SURE, the probe must carry the noise's covariance, or it will confidently tune the wrong way on anything but white noise.

3 · The chroma-speckle "safety" is just the window size. The panel asked for a block-mean-subtracted chroma pass so real low-frequency color scores zero. In practice no subtraction is needed: a luma-guided wide chroma mean at moderate reach averages the ~30 px speckle while the frame-scale lighting gradient — warm streetlight against cool ambient over dark fabric — is locally flat across the window and passes straight through. The protection falls out of the geometry: −70% shadow speckle, the real color untouched.

And two the build sharpened. Acutance's halo bound must reference the pre-spatial (post-temporal) 3×3 min/max, not the over-smoothed spatial output — exceeding the smoothed range is precisely how it restores the slope the smoother removed, while staying halo-free against the true signal. And coring belongs at the input-noise scale (s.sy·gainY), not the residual: the removed delta carries a single frame's full noise, so thresholding at the residual under-cores and re-noises the shadow — the correct scale cut shadow re-noising from 4.7× to 1.2×.

One honest limitation — for the graveyard. Scoring the whole temporal-plus-spatial pipeline against the input sigma over-credits the spatial stage once the temporal average has already crushed the residual, so on a near-lossless static shot the tuner can nudge toward over-smoothing (a 46 dB stack drifting to 45 dB — imperceptible, but the wrong direction). Hold-out cross-validation against an independent probe catches the variance form of this; the systematic bias wants scoring against the post-temporal residual, and is logged for a later pass. The panel's discipline was to publish its graveyard — this belongs in it.

The thesis grew a second tool

Section 06's conclusion — clean early, reconstruct late, on a final node — was a prediction about the shape of the node graph. Building it produced both halves. Hush denoises early and now exports the clean-confidence matte; the reconstruction half became Speak, a standalone film-emulation effect for the end of the tree — film-stock density, subtractive color, halation, bloom, grain — that reads Hush's confidence matte downstream to lay grain exactly where the image was cleaned most. Node one measures and cleans; the last node reconstructs the optical image; a matte crosses the graph between them. The study didn't just steer a denoiser — it specified an interface, and a second product grew into it.

Ultimate finding

The world's best free video noise reducer won't win by removing the most noise — that race is against paid tools with large teams, and Hush is already close. It wins by being the only free tool that treats denoising as step one of texture management: strip the noise, then reconstruct the optical image — lens-like acutance without a digital halo, emulsion-grade grain matched to exactly what was removed — and couple that reconstruction to the grade through confidence mattes, qualifier inputs, and film-optic finishing.

Do all of it transparently, portably across four backends, in real time — and give it away.