Stacking star trails: the software workflow

A star trail is just the path a star draws as Earth turns beneath it — the sky rotates at roughly 15 degrees per hour, so over a 30-minute sequence the whole sky turns about 7.5 degrees. How long each star’s own arc looks depends on where that star sits relative to the pole: one near the celestial equator sweeps nearly the full angle, while one close to the pole barely moves, which is why trails curve into circles around it (the find the celestial pole guide covers that). You can record those arcs two ways: hold the shutter open for the whole half hour, or shoot many short frames and let software assemble them afterward. The second method has quietly become the standard, and the reason is a single, almost embarrassingly simple operation.

The one operation that does the work: lighten blend

Stacking star trails rests entirely on the lighten blend — also called a maximum blend. The rule is this: line up all your frames in perfect register (the camera never moved, so they already are), then walk through them pixel position by pixel position. At each position, the software compares the value in every frame and keeps only the brightest one. Everything else is discarded.

Now think about what that means for a moving star. In frame one, the star sits at position A and is far brighter than the dark sky around it. In frame two it has crept to position B; in frame three, position C. When the lighten blend looks at position A, the bright star-pixel from frame one wins — even though every later frame shows only dark sky there. The same happens at B, at C, and at every point along the path. Because the star is always brighter than the sky it passes over, its bright pixel from every single frame survives the blend, and the trail draws itself, point by point, into one continuous arc.

The dark sky between stars stays dark because no frame ever put a bright value there. That is the whole trick. There is no clever motion modelling — just “keep the brightest value, everywhere.”

Why a stack beats one marathon exposure

If a single long exposure records the same arc, why bother with dozens of files? Three concrete reasons.

• You can drop any ruined frame. A plane crosses the sky, a car’s headlights rake the foreground, a cloud drifts through — in a single exposure, that one event is baked into the entire shot and you start the night over. In a stack, you simply delete the offending frame before blending. Its contribution to the arc vanishes, and because the neighbouring frames overlap, the trail closes over the gap almost invisibly.
• Far less noise. A long exposure lets the sensor heat-soak for the full duration, and that heat shows up as noise and amplified hot pixels. A stack of short frames never lets any single exposure sit long enough to cook, so the result is cleaner — especially in the shadows.
• A free timelapse. Because you have the frames as separate files, you can export an animated timelapse of the trail growing arc by arc, from the very same shoot. One capture session, two deliverables.

The trade-off is honest: stacking asks for a tidy folder of files and a few minutes of processing instead of one click. For most photographers that is a bargain.

The end-to-end workflow

The in-field half — composition, intervalometer settings, where to point — is covered in the guide on how to shoot star trails. On the software side the path is short:

1. Shoot a gapless sequence. Commonly around 30 seconds per frame, fired back-to-back with no dead time between them. Gaps between frames become visible dashes in the final arc, so the goal is continuous coverage.
2. Import the frames into your stacking tool of choice.
3. Run the lighten/maximum blend across the whole set. You have two routes here. Dedicated star-trail stacking software (much of it free) does the blend in one pass and usually offers the timelapse export as a bonus. Alternatively, a general image editor can stack the frames as layers and set each layer’s blend mode to lighten — slower with many files, but it keeps everything in one familiar program.
4. Review and cull. Pull any frame spoiled by a plane, satellite flare, or stray light and re-run the blend.

Aspect	Single long exposure	Stacked short frames
Ruined by one mishap?	Yes — whole shot lost	No — drop one frame
Noise	Higher (sensor heat-soaks)	Lower
Timelapse possible?	No	Yes, from the same files
Effort in post	None	A few minutes

Practical tips that lift the result

A clean stack is good; a few extra moves make it noticeably better.

• Shoot a dark frame. With the lens cap on, take one exposure at the same shutter, ISO, and temperature as your sky frames. It captures the sensor’s fixed pattern of hot pixels with no real light, and subtracting it removes those stuck bright dots that would otherwise survive the lighten blend as fake little stars.
• Treat the foreground separately. The land beneath your trails barely changes between frames, so blending it across the whole stack just piles up noise without adding detail. Instead, take the foreground from one clean frame — or from a brighter shot at the start during blue hour — and blend it in so it sits beneath the arcs cleanly rather than buried under stacked noise.
• Point with intent. Where the arcs curve depends on where the pole sits in your frame; aim near it for concentric circles. The guide on how to find the celestial pole shows how to locate it in either hemisphere before you commit a whole night’s frames.

Planning the sequence length, frame count, and timing is exactly what Viewpoint’s star-trail and timelapse tools are built to work out, so you arrive knowing how many frames a target arc needs.

Quick-start checklist

• Shoot a gapless sequence of short frames (~30 s each), camera locked down.
• Capture one dark frame (lens cap on, same settings) for hot-pixel subtraction.
• Import everything and run a lighten / maximum blend across the stack.
• Cull any frame spoiled by a plane, car, or cloud, then re-blend.
• Blend a clean foreground from one frame instead of the whole stack.
• Export an animated timelapse from the same files for a second deliverable.