When we built the video sketch effect for our online video toolkit, we made a decision that felt almost old-fashioned in 2026: no neural network anywhere in the pipeline. The whole effect is a deterministic chain of classical image operations — Gaussian blur, inversion, color dodge, multiply — running in FFmpeg.

That choice is the entire reason our effect never flickers. Not "we tuned it until the flicker was acceptable." It can't flicker, for reasons that are mathematical rather than empirical. This post is about why — and Part 2 of this series gets into the genuinely painful part: making a browser <canvas> and FFmpeg produce pixel-identical output from the same algorithm.

The recipe: dodge and burn, from the darkroom to OpenCV

The pencil-sketch effect is a classic photo-editing trick, popularized in computer-vision circles by OpenCV's pencilSketch:

1. Convert the frame to grayscale (or keep color, for a colored-pencil look)
2. Invert it
3. Blur the inverted copy with a Gaussian kernel
4. Color-dodge the original against the blurred-inverted copy

Color dodge is division in disguise: dodge(A, B) = A · 255 / (255 − B). Where the blurred-inverted layer is bright (i.e., the original was dark), the denominator is small and the quotient blows up to white — that's the empty paper. Where the original had a sharp luminance transition, the blur lags behind the edge, the quotient lands in the mid-grays, and you get a pencil stroke. Two sliders fall out naturally: the blur radius controls stroke width, and a few cascaded multiply passes control how dark the strokes sit on the paper.

Here's the actual FFmpeg filtergraph we run (slightly reformatted for readability):

[0:v]gblur=sigma=PRE,format=gray,split[a0][b];
[a0]split[a][ams];
[ams]lutyuv=y='if(eq(val,0),0,255)'[am];
[b]negate,gblur=sigma=SIGMA[inv];
[inv][a]blend=all_mode=dodge[d0];
[d0][am]blend=all_mode=multiply[d];
[d]split[p1][p2];[p1][p2]blend=all_mode=multiply:all_opacity=O1[m1];
[m1]split[q1][q2];[q1][q2]blend=all_mode=multiply:all_opacity=O2[m2];
[m2]split[r1][r2];[r1][r2]blend=all_mode=multiply:all_opacity=O3[outv]

(The strange-looking mask in the middle — if(eq(val,0),0,255) — exists solely to align FFmpeg with a browser quirk. That's a Part 2 story, and it's a good one.)

Nothing here is exotic. That's the point.

Why this cannot flicker

AI restyle flickers because every frame is an independent sample from a generative model. Frame 23 and frame 24 go in nearly identical and come out as two different plausible drawings — same content, different micro-texture. String 30 of those per second together and the micro-texture dances. The industry throws optical flow, temporal attention, and consistency losses at this, and it helps, but it's fighting the architecture.

Our chain has the opposite property, and it decomposes into four mechanisms:

1. Every output pixel is a pure function of the current frame.

output_t = f(input_t), with f fixed for the entire video. No state, no random seed, no learned weights. The temporal variation of the output is bounded by the temporal variation of the input: if two adjacent frames are nearly identical, their outputs are nearly identical. Walking people and moving cameras are continuous signals, so the sketch of a walking person is continuous too.

2. There are no hard decisions in the chain.

The classic way per-frame processing flickers is a threshold: a pixel hovering at a decision boundary flips between "edge" and "not edge" on alternating frames, and you get sparkling outlines. Edge-detector-based stylization (Sobel, Canny, edgedetect) suffers from exactly this. Our chain contains only continuous operations — blur is a weighted average; negate, dodge, and multiply are pointwise smooth monotone functions. Move the input a little, the output moves a little. There is nothing to flip.

3. The amplifier sits after the low-pass filter.

Color dodge is a division, and division is a noise amplifier. What saves us is ordering: the signal that gets amplified has already been through two Gaussian blurs (a light pre-blur and the main stroke-width blur). Sensor noise and H.264 compression artifacts — the stuff that genuinely jumps around frame to frame — live in the spatial high frequencies, and a Gaussian kernel is their natural predator. What survives the blur is large-scale structure, which is exactly the part of the signal that's temporally stable. Low-pass first, amplifier second — we treat that ordering as the one non-negotiable rule when we add new styles.

4. Nothing adapts per frame.

A sneakier flicker source is per-frame adaptation: auto-contrast, per-frame histogram equalization, anything that "looks at this frame and tunes itself." Those hunt — this frame a little brighter, next frame a little darker. Every parameter in our chain (blur sigma, the three multiply opacities) is locked for the whole render. The chain has no feedback loop, so it can't hunt.

The rules we now follow

These four mechanisms turned into house rules as we design new styles on the same pipeline (charcoal, ink wash, a cartoon look are on the roadmap):

• No per-frame randomness, ever. Charcoal needs grain — but if you generate fresh random noise each frame, you've re-introduced the dice roll and the picture will "sand-shimmer." Use one fixed grain texture, looped or slowly panned.
• Be suspicious of thresholds. Hard edge detection is the flicker factory. If a style needs outlines, the threshold has to be soft, temporally smoothed, or applied at reduced resolution.
• Blur before you amplify. Any pointwise operation that expands contrast (dodge, burn, gamma < 1) belongs downstream of a low-pass.

Why deterministic, not AI

For this use case, the choice was low-risk across four axes:

• Cost: the chain is a handful of blurs and blends. It runs on commodity CPU, no GPU fleet, no model hosting.
• Speed: faster than realtime on a modern server, fast enough in a browser to power a live preview while the user drags sliders.
• Determinism: the preview the user sees is the export they get. (Getting that literally pixel-identical across two rendering engines was its own war — that's Part 2.)
• Temporal stability: free, as shown above, as a property of the math rather than a tuning target.

AI restyle is the right tool for open-ended restyling — a filter chain will never reach "in the style of Van Gogh." A deterministic chain is the right tool when you want one specific, stable, controllable look. Sketch is that second case, and choosing it removed an entire class of temporal artifacts by construction.

This effect powers the sketch tool at MeiCut, where it runs both server-side and entirely in the browser. Part 2 of this series: making Canvas 2D and FFmpeg render the same sketch, pixel for pixel — including the operand-order bug that silently washed out every frame, and the divide-by-zero where FFmpeg says white and the browser says black.