# Band Desk

> Banding is a distance, not a shade count. A step is visible because of how many PIXELS wide
> it is, and that is the extent divided by the code values the gradient occupies - so a sky
> over 1920 px occupying 20 code values steps every 96 pixels.

https://band-desk.skillsafe.ai/

## What it is

Five lanes over one gradient - how much contrast it has, how far it spreads, and the chain of
stages it passes through - plus a **free browser-side engine** that computes the step width
and height. The engine costs nothing and needs no account. Writing the report costs credits.

## The arithmetic

    step width          extent / code values the gradient occupies
    code values         ramp x 2^(bits - 8)          ramp measured at 8-bit full range
    step height         slope / (2^bits - 1)
    legal range         (235 - 16 + 1) x 2^(bits - 8) values, about 86% of the full set

## Figures that are exact, and surprising

- A sky spanning 20 code values across 1920 px steps **every 96 pixels**, at 8 bit. That is
  a band you can point at, and it is there the moment the file is made.
- **Ungraded, nobody can see it.** Each step is 0.392% of full scale - just under the 0.4%
  threshold at which two flat areas separate. This is why the raw clips look clean.
- **A grade x3 takes it to 1.176% and the width does not move.** Still 96 pixels, still 20
  distinct values. The grade does not create the bands; it raises the ones already there.
- **Promoting 8-bit into a 16-bit container changes nothing.** The same 20 distinct values,
  now spaced 256 apart. Depth only helps at the moment of quantisation.
- **Capturing at 10 bit gives the same scene 80 code values** - a step every 24 px at 0.293%,
  under both thresholds on the identical grade. At 12 bit, 320 values and 6 px.
- **A wider frame is worse, not better.** The step width scales directly with the extent: the
  same gradient across 3840 px steps every 192 pixels.
- **The width almost never rescues anything.** It takes only 2 px, which at 20 code values
  means a gradient narrower than 40 px. The width says how coarse; the height says whether.
- **Legal range costs about a sixth of the code values** - 220 of 256 at 8 bit - so every
  step is about 1.16 times wider than a full-range figure says.
- **Dither adds no levels at all.** About one code value of noise before the quantisation, so
  the step lands somewhere different on each pixel. That is the whole transaction.

## The sheet

    GRADIENT
    name   | the generated sky
    ramp   | 20              code values it occupies AT 8-BIT FULL RANGE - required
    width  | 1920            pixels it spans - required
    range  | full            full or legal; defaults to full, the optimistic reading
    dither | no              defaults to no

    STAGES
    s1 | capture | 8  | as delivered
    s2 | promote | 16 | conformed into the timeline
    s3 | grade   | 3  | the look
    s4 | dither  |    | before the delivery encode

A stage row is `id | stage | value | description`. The stage is one of `capture`, `promote`,
`grade` or `dither`, and **only `capture` decides how many distinct values there are** - that
is the whole reason the four are separated. `capture` and `promote` take a bit depth, `grade`
takes a slope, `dither` takes nothing.

A stage without the number it needs is **refused rather than guessed**, because the number it
needs is the one that decides the answer.

## Lanes

- `plan` - decide what the gradient has to survive, before anything is shot
- `check` - how wide the steps actually are (primary)
- `grade` - what the curve did and did not do
- `depth` - what another two bits would buy
- `deliver` - as it is, fix in the grade, or needs a deeper capture

## What it cannot do

It is arithmetic on a stated ramp and it **has not seen the picture**. Both of its inputs -
how many code values the gradient occupies and how far it spreads - are usually eyeballed
rather than measured, and the step width is one divided by the other, so a ramp guessed at
half its real contrast doubles every figure. The thresholds for what is visible are
conventions written down so they can be argued with, not laws of perception: whether a
96-pixel step at 1.2% is visible depends on the display, the viewing distance and what is
beside it. A real gradient is not linear and a real grade is not a single slope - the slope
here is the local one where the banding is. And noise already in the picture dithers it for
free, which nothing here models.

## Links

- App: https://band-desk.skillsafe.ai/
- API: https://band-desk.skillsafe.ai/api.html
- Source skill: https://github.com/affaan-m/everything-claude-code (not affiliated or endorsed)