Low film frame rate

Visible effect

Sparse captured poses replace continuous motion

A low capture rate records fewer positions along a moving subject’s path. When those frames are shown on a faster display, each recorded image is held across several display refreshes and motion advances in larger steps. The result is staccato or strobed motion, not a spatial filter applied independently to every pixel.

The held frame also owns a held point in time. Grain, chemical spots, and other time-driven processing later in the pipeline must receive that captured time; otherwise the subject freezes while the surface texture continues to animate, revealing a stack of unrelated effects rather than one film frame.

Physics

The shutter and pulldown divide time into exposures

A film camera cannot expose while its pulldown is moving the film. The shutter closes, the mechanism advances a fresh frame into the gate, the frame is registered and held, and the shutter opens for the next exposure. Drive speed sets how often that cycle repeats.

Fewer cycles per second sample a moving subject at fewer positions. Standard historical rates include 24 fps for sound film, 18 fps for some amateur formats, and roughly 16 fps for much silent-era capture. Exposure blur can soften the transition between sampled positions, but this isolated playground caches and holds one complete frame.

Mathematics

A delta-time-aware sample-and-hold gate

Capture rate f_c defines frame period Δ. The update predicate u becomes true on the first frame or when source time t is at least one interval beyond held time t_h. Only then are held image I_hand its timestamp replaced.

Returning t_h' is as important as returningI_h'. Every downstream time-dependent operation must use the captured timestamp so one repeated image remains one repeated film frame.

Code

A CPU-side frame gate, not a shader

No per-pixel transformation defines this effect. The exact TypeScript unit below decides when to copy a new frame and returns the timestamp that must travel with it. The playground imports and executes this same module.

export interface FrameGateState {
  capturedAt: number | null;
  phaseAt?: number;
}

export interface FrameGateResult {
  capturedAt: number;
  shouldCapture: boolean;
  state: FrameGateState;
}

export const frameInterval = (framesPerSecond: number): number =>
  1 / Math.min(120, Math.max(1, framesPerSecond));

export const updateFrameGate = (
  sourceTime: number,
  framesPerSecond: number,
  previous: FrameGateState
): FrameGateResult => {
  const safeTime = Math.max(0, sourceTime);
  const timelineRestarted =
    previous.capturedAt !== null && safeTime < previous.capturedAt;
  const previousPhase = previous.phaseAt ?? previous.capturedAt;
  const interval = frameInterval(framesPerSecond);
  const shouldCapture =
    previous.capturedAt === null ||
    timelineRestarted ||
    (previousPhase !== null && safeTime - previousPhase >= interval);
  const capturedAt = shouldCapture
    ? safeTime
    : previous.capturedAt ?? safeTime;
  const elapsedIntervals = previousPhase === null
    ? 0
    : Math.max(1, Math.floor((safeTime - previousPhase) / interval));
  const phaseAt = previous.capturedAt === null || timelineRestarted
    ? safeTime
    : shouldCapture && previousPhase !== null
      ? previousPhase + elapsedIntervals * interval
      : previousPhase ?? safeTime;

  return {
    capturedAt,
    shouldCapture,
    state: { capturedAt, phaseAt }
  };
};

Why these steps are here

1. Measure elapsed source time. The gate remains correct when display refresh intervals vary.
2. Copy only at the threshold. All intermediate display refreshes reuse the cached image.
3. Return captured time. Grain, spots, and later temporal effects stay fixed to the repeated frame.
4. Reset on a timeline restart. Seeking backwards captures immediately instead of holding a frame from the old time.

Notes

• Low frame rate creates temporal stepping. Frame jitter or weave moves the image relative to the frame boundary and belongs to registration, not cadence.
• The playground copies a frame only after one frame interval. It does not accumulate intermediate frames into motion blur.
• The cached timestamp propagates with the cached image so downstream time-dependent effects remain synchronized.
• Changing playback rate can create undercranked or overcranked speed changes. This playground preserves duration and isolates the cached-frame cadence.

References