How Stacking Actually Works (And Why More Frames Isn't Always Better)

Ask why we stack astrophotographs and you will usually be told “to reduce noise.” That is true and almost useless, because it does not tell you how many frames you need, why your stack of 200 looks worse than someone else’s stack of 60, or why adding another hour sometimes changes nothing at all.

The actual argument is short, and once you have it, most stacking decisions answer themselves.

Signal adds. Noise does not.

Point your telescope at a nebula and take an exposure. Each pixel receives some number of photons from the sky. That number is not fixed — photon arrival is random, and the count varies from exposure to exposure by roughly the square root of itself. Collect 100 photons and the frame-to-frame variation is about 10. Collect 10,000 and it is about 100.

Now stack N frames. The signal — the real photon count from the object — adds linearly: N times as much. The noise is random and partly cancels, growing only as the square root of N.

So the ratio of signal to noise improves by √N.

That single relationship explains most of what you observe:

• 4 frames is twice as good as 1.
• 16 frames is twice as good as 4.
• 64 frames is twice as good as 16.

Each doubling of quality costs four times as many frames. This is why the difference between 10 and 40 frames is dramatic and the difference between 200 and 260 is invisible. You are not doing anything wrong when the second one disappoints you — you added 30% more frames for a 14% improvement, and 14% is below what the eye reliably notices.

If you want a visible step up from a 200-frame stack, you need around 800.

Which is why read noise decides your sub length

There is a second noise source that does not behave like this. Every time the sensor is read out, the electronics add a fixed penalty. It does not depend on exposure length — a 5-second frame and a 500-second frame each pay it exactly once.

So a given total integration time carries read noise in proportion to how many frames you split it into. Ninety minutes as 540 ten-second subs pays the penalty 540 times. The same ninety minutes as 18 five-minute subs pays it 18 times.

This is the whole argument for longer sub-exposures, and it is why a guided setup pulls away from a smart telescope on faint targets even at identical total time. It is not that the guided rig collects more light. It reads the sensor thirty times less often.

The counter-pressure is that long subs need good tracking, and a trailed 300-second frame is worth nothing. The right sub length is the longest one your mount reliably delivers — which is a mechanical question, not a processing one.

Alignment is where stacks are actually lost

The √N argument assumes every frame contributes the same signal to the same pixel. That requires the frames to be in register, and this is where most disappointing stacks actually fail.

Frames move between exposures. Mount drift, refraction near the horizon, flexure, and — on any alt-azimuth mount, which includes every smart telescope — field rotation. Over an hour, frames taken at the start and end can be rotated by tens of degrees relative to each other.

Alignment that handles only translation will not cope. What is worse is how it fails: not with an error message, but with a stack where everything is slightly smeared. It looks like poor focus or bad seeing, and people spend a season chasing the wrong problem.

Proper registration works from the stars themselves. Build triangles from the brightest stars in each frame and describe them by side ratios — quantities that survive translation, rotation and scale. Matching triangles vote for which star corresponds to which, a robust fit throws out votes that disagree, and a refinement pass pulls the result to sub-pixel accuracy.

That last part matters. Sub-pixel accuracy is not a nicety; a consistent half-pixel error across your stack costs you the same detail that would have been lost to slightly worse seeing.

Rejection: the part that removes what averaging cannot

Averaging handles random noise. It does not handle things that are not random: satellites, aircraft, cosmic rays, a car’s headlights sweeping the field.

Average 100 frames where one has a satellite trail and the trail is still there at 1% strength — faint, but visible against a dark sky, and it survives stretching.

Rejection removes it by looking across the stack at each pixel and discarding values that do not belong. The methods differ in what “do not belong” means, and choosing between them is not arbitrary:

Sigma clipping takes the mean and standard deviation at each pixel and drops values beyond a threshold. It works well and it is the default for good reason — but it assumes every frame samples the same distribution.

Winsorized sigma clipping pulls outliers in towards the bulk rather than removing them. Safer on shallow stacks, where estimating a standard deviation from eight samples and then throwing values away tends to discard real signal.

Linear-fit clipping answers a different question. It sorts each pixel’s values across the stack and fits a line through them. A smooth spread — the kind produced by transparency changing through the night — is expected by that model and costs nothing, while a satellite trail is still one value far off the line.

That distinction matters more than it sounds. When high cloud rolls in, or your target sinks toward the light dome, the frames genuinely differ. The spread is real data, not noise. Sigma clipping sees frames at the ends of the range as outliers and starts discarding them — and the ones at the dark end are usually the clearest frames in the session. You lose your best data to a method that assumed it was wrong.

The signal to watch is how much your per-frame sky level drifts. If it is stable, sigma clipping is right. If it moves by more than a few percent, a linear fit will serve you better. Akastroid measures this and switches automatically above about 8% drift, which is a decision that requires no astronomy knowledge to get right and a fair bit to get right by hand.

Shallow stacks need different treatment

With eight frames you cannot estimate a distribution. Any rejection method is working from too few samples, and aggressive clipping will remove real signal while claiming to remove outliers.

Below about eight frames, plain averaging or a median is usually the honest choice. Between eight and fifteen, Winsorizing. Above that, real clipping becomes safe.

The failure mode here is subtle: aggressive rejection on a shallow stack produces an image that looks clean and is quietly missing faint detail. It does not look broken. It looks slightly empty, and there is nothing on screen to tell you why.

When more frames genuinely stops helping

Three cases where the next hour buys you nothing:

You are read-noise limited. With very short subs, the noise floor is set by readout, not by sky photons. Stacking still helps, but you are fighting a fixed cost that more frames do not remove. Longer subs would.

You are sky-limited on a faint target. Under bright skies the background dominates, and the faint outer regions of your target may simply never rise above it. Signal-to-noise still improves as √N — but √N of “barely detectable” is still barely detectable. Darker skies or narrowband filters change this; more time does not.

Your alignment is the limit. If registration is leaving half-pixel errors, adding frames adds more slightly-misregistered data. The stack gets smoother and no sharper. This is worth checking before blaming the sky.

A working answer

• Sub length: the longest your mount reliably tracks. This dominates read noise, and read noise dominates faint targets.
• Frame count: think in factors of four. If you want a visible improvement, plan to quadruple, not to add a bit.
• Registration: must handle rotation. Non-negotiable on any alt-az mount.
• Rejection: match it to the depth of your stack and the steadiness of your night.
• Know your limit: read noise, sky brightness, or alignment. Adding frames only helps the first two, and only slowly.

None of this requires understanding the mathematics beyond √N. But it does explain why the stack you are unhappy with is unhappy — and that is usually a more useful thing to know than another slider.