Google Timeline Visualizer Camera Movement Presets Explained

The Google Timeline Visualizer ships with three built-in camera movement presets—fixed zoom, steady following, and dynamic following—that control how the map view tracks your journey during playback.

The camera movement presets in the mahlernim/google-timeline-visualizer repository determine the cinematic behavior of the map visualization, allowing you to choose between static framing, smooth tracking, or adaptive zooming based on travel speed. These presets are exposed through both the command-line interface and the web-based UI, making them accessible regardless of how you run the visualizer.

Available Camera Movement Presets

The visualizer defines three distinct camera movement presets in the source code, each designed for different viewing experiences.

Fixed Zoom

The fixed zoom preset maintains a constant zoom level throughout the entire journey. The camera stays anchored to the center of the map without panning, meaning the map tiles and overlays move beneath a static viewport while the journey plays.

This preset is defined in web/index.html (lines 124-126) and mapped in visualizer.py (line 65) under the CLI option value "fixed".

Steady Following

Steady following is the default camera movement preset that provides a smooth tracking experience. The camera continuously centers on the current position along the path while maintaining a consistent zoom level, creating a stable "follow-the-traveler" effect without abrupt movements.

According to the source code in visualizer.py, this preset corresponds to the "steady" option value and serves as the fallback when no specific movement mode is specified. The HTML interface in web/index.html (lines 124-127) marks this as the selected default in the dropdown menu.

Dynamic Following

The dynamic following preset offers a cinematic experience by adjusting the zoom level dynamically based on travel speed and direction changes. This mode implements zoom hysteresis in web/src/camera.ts (lines 381-384), causing the camera to zoom in and out gradually rather than instantaneously.

When travel speed increases, the camera pulls back to show more context; when slowing down, it zooms in for detail. This behavior is controlled by the MOVEMENT_PROFILES implementation in the TypeScript camera controller.

How to Configure Camera Movement Presets

You can select camera movement presets through either the command-line interface or the web UI.

Command-Line Configuration

In visualizer.py, the application parses the --camera-movement argument to set the active preset. The CAMERA_MOVEMENTS mapping accepts three string values:

# Use fixed zoom

python visualizer.py --camera-movement fixed ...

# Use steady following (default)

python visualizer.py --camera-movement steady ...

# Use dynamic following

python visualizer.py --camera-movement dynamic ...

The CLI handler at line 65 of visualizer.py validates these inputs against the available camera movement presets before initializing the visualization pipeline.

Web Interface Selection

The web interface exposes these options through a dropdown selector defined in web/index.html (lines 124-127):

<select id="camera-movement">
  <option value="fixed">Fixed zoom</option>
  <option value="steady" selected>Steady following</option>
  <option value="dynamic">Dynamic following</option>
</select>

When users change this selection, the JavaScript event listener triggers updateSelection(), which propagates the chosen camera movement preset to the rendering engine. The runtime logic in web/src/camera.ts then applies the corresponding MOVEMENT_PROFILES configuration to control viewport calculations.

Summary

• The fixed zoom preset keeps the camera static at a constant zoom level while the map moves beneath it.
• Steady following provides the default smooth tracking behavior that centers the path while maintaining consistent zoom.
• Dynamic following adjusts zoom based on travel speed using hysteresis algorithms in camera.ts for cinematic effect.
• All presets are accessible via the --camera-movement CLI flag in visualizer.py or through the HTML dropdown in web/index.html.
• The implementation uses CAMERA_MOVEMENTS for CLI mapping and MOVEMENT_PROFILES for runtime camera control.

Frequently Asked Questions

What is the default camera movement preset in Google Timeline Visualizer?

Steady following is the default camera movement preset. When you run visualizer.py without specifying the --camera-movement flag, or load the web interface for the first time, the system automatically selects the steady following mode to provide balanced tracking behavior.

How does dynamic following differ from steady following?

While steady following maintains a consistent zoom level throughout the journey, dynamic following actively adjusts the zoom based on your travel speed and direction changes. The dynamic mode implements zoom hysteresis in web/src/camera.ts to prevent jarring transitions, smoothly zooming out during high-speed travel and in during slower segments.

Can I change camera movement presets during playback?

The source code structure in web/index.html includes an event listener on the camera movement dropdown that calls updateSelection() when changed. This suggests the web interface supports switching presets during visualization, though the exact runtime behavior depends on how the MOVEMENT_PROFILES state management is implemented in web/src/camera.ts.

Where are the camera movement presets defined in the codebase?

The preset definitions are split across three key files: visualizer.py (line 65) contains the CAMERA_MOVEMENTS mapping for CLI options, web/index.html (lines 124-127) defines the UI dropdown options, and web/src/camera.ts (lines 381-384) implements the runtime logic through MOVEMENT_PROFILES that actually controls the camera viewport calculations.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}