Slitscan

Stacks N time-shifted copies of the upstream along an axis — every row (or column) is a different moment in time. Produces the "waterfall of pixels" look popularised by François Vogel.

Category: Time Menu path: Time > Slitscan

Ports

Port	Type	Direction	Description
in	imageRgba16f	input	Upstream animated content (typically a video chain).
out	imageRgba16f	output	Slitscan composite — each output pixel reads from a different time slice.

Parameters

Param	Type	Default	Description
mode	enum	FrozenLine	FrozenLine = Vogel-style. The current frame shows untouched up to the sample line; past the line, every row pulls the sample-line pixels at a progressively older moment. Smear = the whole image is time-warped row-by-row, no static portion.
sampleLine	scalar	0.5	Position of the sample line along axis, normalized 0–1. FrozenLine only — ignored in Smear mode.
samples	scalar	24	Number of time slices, K. Each slice is a full upstream re-evaluation. Clamped 2–32.
frameSpan	scalar	60	Total frames covered across the time axis. Slice 0 = current frame, slice K-1 = comp_frame - frameSpan.
axis	enum	Y	Axis along which time runs. Y = vertical waterfall. X = horizontal smear.
direction	enum	Forward	Forward = newest at the start of the axis (top for Y, left for X). Reverse flips it.
smooth	boolean	true	Bilinear-blend between adjacent slices for smooth transitions. Off = banded, hard transitions.
gamma	scalar	1	Distribution shaping. 1 = linear time-per-pixel. >1 = more axis-pixels spent on the older half (long tail of past). <1 = more spent near now (frozen near current frame, fast smear into the past).

Expose Channels

When enabled (E button on node header), adds input ports that override params via edge connections:

Port	Type	Overrides
samples_in	scalar	samples
frameSpan_in	scalar	frameSpan
sampleLine_in	scalar	sampleLine
gamma_in	scalar	gamma

How It Works

For each of the K slices, the engine re-evaluates the upstream subgraph at comp_frame - i * (frameSpan / (K-1)), exactly the way Echo does. The K resulting frames are stacked into a 2D texture array on the GPU. The final fragment shader's behavior depends on mode:

• FrozenLine (default, the Vogel look): for output pixels whose axis coordinate is on the "newest" side of sampleLine, sample slice 0 (the current frame) at the pixel's actual UV — pass-through. For pixels past the sample line, sample the K array based on the pixel's distance from the line, but read the source at (uv.x, sampleLine) instead of the pixel's own UV — every row in the drip region shows the sample-line pixels at a progressively older moment.
• Smear: every output pixel reads from the array layer corresponding to its position along the axis, at its own UV. The whole image varies in time.

Both modes do bilinear blending between adjacent layers when smooth = true. The cost scales linearly with samples. On video chains this is unusable without a FileCache between the source and Slitscan — random-frame access on a video decoder is orders of magnitude slower than reading cached frames from disk.

Usage Examples

Vogel-style frozen waterfall (default look)

VideoSource → FileCache → Slitscan → Output. Default params: FrozenLine, sampleLine=0.5, axis Y, forward. The top half of the frame plays normally; below the midline, the pixels at the midline drip downward through time. New content "falls" out of the sample line as time advances. Move the camera or have something cross the sample line to see the most dramatic drips.

Vogel near the bottom edge

Same chain with sampleLine = 0.85. Most of the image plays normally; only the bottom 15% of the frame becomes the time-drip region — a much more subtle effect that reads as "the floor is frozen in time."

Smear mode (no static portion)

Set mode = Smear. Whole image is time-warped — every row is a different historical frame, no pass-through region. Useful for abstract / liquid looks rather than figurative time-photography.

Frozen-with-tail

gamma = 2.0 in either mode. Most of the time-axis is spent on the recent past, with a long compressed tail of older content at the far edge.

Horizontal time-drip

axis = X, direction = Forward, sampleLine = 0.5. Left half of the frame plays normally; right half drips horizontally — pixels at the midline column smear rightward through time.

Animated sample line

Drive sampleLine_in from a Time-driven Math node. Watch the boundary between live and frozen content sweep across the frame.

Tips

• Always pair with FileCache. Without one, every frame re-decodes the video K times. With a FileCache between VideoSource and Slitscan, the K slices read straight from disk.
• Memory budget. Slitscan allocates a texture array of size width × height × K at Rgba16Float = 8 bytes/pixel. At 1080p × 32 ≈ 130 MB. Drop samples for tighter machines.
• Sub-frame distribution. frameSpan / (samples - 1) is the time step between adjacent slices. To get one slice per source frame, set frameSpan = samples - 1.
• High samples + low frameSpan = ultra-smooth, short-history smear (great for liquid motion). Low samples + high frameSpan = punchy, banded chronophotography look — turn smooth off to lean into it.
• For a stop-motion strobe within the smear, sandwich with PosterizeTime upstream of Slitscan.

Related Nodes

• Echo — same multi-time eval primitive, but blends the K frames temporally instead of stacking them spatially.
• Time Shift — single-offset re-eval. Slitscan is N TimeShifts demuxed along an axis.
• FileCache — the indispensable performance pivot for any time-warp on video.
• Posterize Time — discrete-step playback. Stop-motion + Slitscan = strobed waterfall.