Error Diffusion Dithering

What error diffusion actually does

Quantise a pixel to the nearest value you’re allowed. Measure the error you just made by doing that. Then push that error forward onto pixels you haven’t processed yet, split between them by a fixed set of weights — the kernel. Work through the image in scan order and the error never disappears; it migrates. A region that keeps getting rounded down accumulates a debt until it forces a pixel the other way, and that is where the dot goes.

The result has no grid in it. Dots land where the picture needs them rather than where a matrix happens to be, which is why error diffusion holds detail that ordered dithering flattens.

It also costs more, structurally. Each pixel’s input depends on the pixels before it, so the work cannot simply be spread across the frame the way ordered dithering can. V3KTR runs the real sequential propagation in compute rather than approximating it with a precomputed mask — which is the difference between looking a bit like Floyd–Steinberg and being it.

The seven classic kernels, and what each one is for

Floyd–Steinberg (1976) distributes to four neighbours with weights of 7, 3, 5 and 1 sixteenths. It is the default almost everywhere for a good reason: tight, detailed, minimal smearing, and cheap.

Atkinson — Bill Atkinson’s, written for the original Macintosh — is the odd one out. It passes only three quarters of the error on and discards the rest. Deliberately losing error means deep shadows go fully black and bright areas go fully white instead of holding texture, so you trade detail at both ends for contrast and open white space. It is the crisp 1-bit Mac look, and it is the one to pick when a Floyd–Steinberg result feels muddy.

Jarvis–Judice–Ninke spreads across twelve neighbours over three rows. Much wider distribution: smoother gradients, softer edges, more work per pixel. Stucki uses the same twelve-neighbour footprint with different weights, tuned to be quicker and to hold a harder edge. Burkes is Stucki with the third row removed — most of the smoothness for a good deal less spread.

Sierra sits between those and Floyd–Steinberg: ten neighbours over three rows. Sierra Lite cuts it back to three neighbours over two rows with weights of 2, 1 and 1 quarters — the cheapest member of the family, and visibly the grainiest. When you want the algorithm to be part of the texture rather than invisible, Sierra Lite and Atkinson are the two that show.

Two that aren’t kernels at all

Ostromoukhov’s is a variable-coefficient kernel, which is a different idea from the seven above. All of those use one fixed set of weights for every pixel in the picture. Ostromoukhov’s varies its coefficients with the input tone, using a table tuned specifically to break up the artefacts that fixed kernels produce in the places they are worst — the near-black and near-white ends, where Floyd–Steinberg leaves the “worms” you can see crawling through a smooth gradient. It costs a lookup per pixel and buys clean extremes.

Riemersma is not a scan at all. Instead of running along rows, it walks the image on a Hilbert curve — a space-filling path that stays local, so consecutive steps are always neighbours in two dimensions rather than only in one. There is no kernel; the last sixteen quantisation errors ride along the curve behind the walker, weighted from full strength for the newest down to a sixteenth for the oldest. Because the path has no preferred direction, the output has no directional structure either: no worms, no rows, no diagonal grain. It is the one to pick when any hint of scan direction is spoiling the picture.

Two consequences worth knowing. Riemersma ignores serpentine, because there is no scan to alternate. And it cannot be used with Depth Planes — the planes work by switching the kernel per depth band, and Riemersma has no kernel to switch. Choose it and those controls go away.

Three that are ours: Drip, Comb and Bend

The nine above are inherited — published algorithms, implemented faithfully. These three exist because once you are running the real sequential propagation rather than faking it with a mask, the kernel stops being a thing you pick and becomes a thing you can play. Each of them takes an artefact the classical work spent forty years designing out, and makes it the point.

Drip is directional diffusion. Every kernel above spreads the error over at least two rows and to both sides, and that is precisely how Floyd–Steinberg avoids what the literature calls worms — long correlated runs where the error walks along instead of dispersing. Send all of it one way and worms are the entire result: each line becomes its own independent one-dimensional chain, and the error walks until it flips a level and paints a streak on the way. LEAN sets the angle — zero is vertical, and one pixel of sideways drift per row is exactly 45°, so the control walks the streaks between vertical runs and diagonal staircases. STEER makes that angle follow the picture's own brightness, so the drift changes direction as the image does.

Comb is the same idea turned ninety degrees: mostly along the scan, with an eighth of the error leaking downward. That leak is not decoration. A purely horizontal chain throws away its accumulated error at the end of every row, and the mean tone drifts as a result; the small downward tap is what conserves it. Drip needs no equivalent because a vertical chain only spills once, at the bottom edge. Serpentine alternates the smear direction row by row, which changes Comb's character more than it changes any classical kernel's.

BLEED decides how much of each pixel's error travels at all. Below one, the quantiser stays on the source value far longer, so runs stretch and the picture posterises toward the tones it started from. It is deliberately available only on Drip and Bend, and pinned to one everywhere else — on a classical kernel, discarding error is not a control, it is a bug.

Bend hands you Floyd–Steinberg's four neighbours as SIGNED weights — Right, Down, Down Right and Down Left, under a SPREAD heading — normalised by their own sum. The normalisation is what makes it playable: it holds the overall gain at one, so a wildly asymmetric setting stays tonally correct, and it means only the RATIOS between the four matter. Doubling all four is the same kernel, which is why the controls can stay narrow instead of running to the large numbers the idea started with.

What survives that normalisation is everything worth having. The asymmetry decides which way the error walks — heavily Right gives long horizontal lines, heavily Down gives vertical ones, loading either diagonal gives 45° planes. The negative weights are the real instrument: a negative weight pushes a neighbour AWAY from the tone the pixel just missed, so the error alternates sign as it spreads and the quantiser rings. That ringing is circuit-bent modulation and CRT scanline banding, and it comes out of the algorithm rather than being pasted over it.

One thing to know, because you will find it: push the four weights until they very nearly cancel each other out and the picture gives way. With the sum close to zero there is no scaling that conserves tone, and the result stops being a dither and becomes a flat field. That boundary is real and it is reached from a fair part of the control's range — treat the interesting territory as the settings where the four weights still clearly add up to something, and the edge as somewhere you visit deliberately rather than land on by accident.

A different kernel per depth plane

Error Dither carries the app’s DEPTH PLANES control, and it is the more interesting of the two dither effects to use it on. With planes on, the MID PLANE and FAR PLANE sections each pick their own Algorithm.

Atkinson in front and Jarvis–Judice–Ninke behind gives you a hard, high-contrast subject against a background that diffuses smoothly away — an effect that would otherwise need two layers, two masks and a compositing decision, from one layer and one control.

The per-plane Algorithm lists are shorter than the main one. They offer the seven classic kernels plus Ostromoukhov — the ones that are a fixed table of weights the planes can simply swap between. Riemersma is absent because it has no kernel to swap, and Drip, Comb and Bend are absent because each builds its kernel per run from its own controls, which the planes have no way to vary independently. Choose any of those four as the main Algorithm and the per-plane pickers still work; they just draw from the eight.

When you’d reach for it over ordered dithering

When you want the reduction to serve the photograph rather than announce itself. Error diffusion keeps faces readable, keeps fine detail, and keeps gradients from banding, all of which ordered dithering will sacrifice for pattern.

Reach for the ordered one instead when the pattern IS the aesthetic — console screenshots, print-zine flatness, anything where a visible weave is the point.

Every option, from the app

Generated from the registry the app publishes, so this list is whatever the current build actually ships — not a copy of it.

Algorithm

Floyd-SteinbergAtkinsonSierraSierra LiteStuckiJarvis-Judice-NinkeBurkesOstromoukhovRiemersmaDripCombBend

Planes

OffNear + FarNear · Mid · Far

Algorithm · Mid Plane

Floyd-SteinbergAtkinsonSierraSierra LiteStuckiJarvis-Judice-NinkeBurkesOstromoukhov

Algorithm · Far Plane

Floyd-SteinbergAtkinsonSierraSierra LiteStuckiJarvis-Judice-NinkeBurkesOstromoukhov

Related effects

• DitherOrdered dithering: Bayer and blue-noise threshold masks quantised to real machine palettes — Game Boy, PICO-8, CGA, EGA, NES, C64, ZX Spectrum and more.
• HalftoneA real halftone screen — an angled grid of cells whose ink coverage tracks tone, in dot, line, cross or square, with a separate four-colour process screen for CMYK.
• RisographSpot-ink riso printing: luminance separated into two or three inks, each screened at its own angle with mottled grain and multiplied over tinted paper — mis-registration and all.

Open the app to try it; the free effects work with no signup. Open V3KTR · all the FX · how it works