LongStream: Streaming Visual Geometry & Data Systems

• LongStream is a multifaceted concept spanning long-sequence streaming visual geometry, temporal network analysis, and durable SQL stream processing.
• In visual geometry, it employs gauge decoupling and cache-consistent training to achieve stable, metric-scale scene reconstruction over thousands of frames.
• As a systems paradigm, LongStream ensures semantic correctness and resource stability in indefinite streams and modular temporal network analysis.

Searching arXiv for the cited LongStream-related papers and adjacent work. arxiv_search(query="LongStream Long-Sequence Streaming Autoregressive Visual Geometry", max_results=5, sort_by="relevance") արxiv_search{"query":"LongStream Long-Sequence Streaming Autoregressive Visual Geometry","max_results":5,"sort_by":"relevance"} Searching arXiv for "LongStream Long-Sequence Streaming Autoregressive Visual Geometry". LongStream is used in several technically distinct research contexts. The most prominent usage in the supplied literature denotes a long-sequence streaming autoregressive visual geometry model for metric-scale scene reconstruction over thousands of frames, designed around gauge decoupling, keyframe-relative pose prediction, orthogonal scale learning, and cache-consistent Transformer inference (Cheng et al., 13 Feb 2026). The same label also appears in temporal network analysis as a shorthand for longitudinal modularity on link streams, and more loosely in streaming SQL and long-state stream processing as a descriptor for systems that must preserve correctness and stability over indefinite horizons (Brabant et al., 2024, Begoli et al., 2019, Hu et al., 2024).

1. LongStream in long-sequence streaming visual geometry

In the visual-geometry literature, LongStream addresses long-sequence streaming autoregressive reconstruction: estimating camera motion and 3D scene structure in metric units, online, over very long RGB videos, using an autoregressive Transformer with KV caching (Cheng et al., 13 Feb 2026). The stated objective is stable, metric-scale scene reconstruction in real time over kilometer-scale trajectories, without reprocessing the full history.

The problem formulation is motivated by several failure modes of earlier streaming Transformers. The paper identifies attention decay and attention-sink reliance, in which causal attention develops a strong fixation on the first frame; scale drift induced by coupled learning of geometry and metric scale; long-range extrapolation errors caused by training on short windows and testing on long sequences; and first-frame anchoring, which ties predictions to a fixed gauge and amplifies error accumulation (Cheng et al., 13 Feb 2026). In this formulation, long-horizon instability is not treated as a generic capacity issue alone, but as a compound effect of pose parameterization, scale coupling, and cache dynamics.

LongStream’s central design claim is gauge decoupling. It removes dependence on a fixed first-frame anchor by predicting poses relative to a moving keyframe, and it separates metric scale estimation from geometry learning. A plausible implication is that the model reframes long-horizon inference as repeated local estimation rather than extrapolation over an expanding absolute coordinate frame.

2. Gauge-decoupled formulation and state evolution

The model represents camera pose as

$$T = \begin{bmatrix} R & t \ 0 & 1 \end{bmatrix},$$

with $R \in SO(3)$ and $t \in \mathbb{R}^3$, and predicts for frame $i$ relative to current keyframe $k$

$T_{i \leftarrow k} = T_i T_k^{-1}.$

In parameter form, the relative prediction is

$$p_{i \leftarrow k} = [t_{i \leftarrow k}, q_{i \leftarrow k}, f_{i \leftarrow k}],$$

where $q$ is a unit quaternion and $f$ is a focal-length offset (Cheng et al., 13 Feb 2026).

This reformulation localizes the prediction difficulty. Instead of extrapolating absolute pose to large frame indices, the model predicts $\Delta T$ within a bounded keyframe interval. For non-keyframes, global pose is recovered by composition,

$R \in SO(3)$0

and when frame $R \in SO(3)$1 becomes a new keyframe, the system sets $R \in SO(3)$2 and begins predicting subsequent frames relative to that new anchor (Cheng et al., 13 Feb 2026). If a global trajectory spanning multiple keyframes is needed, the trajectory is composed along the chain of local transforms rather than expressed against a single initial frame.

LongStream also introduces orthogonal scale learning. The paper defines a scalar metric scale $R \in SO(3)$3 and separates geometry parameters from scale-sensitive quantities. Geometry is optimized in a normalized space:

$R \in SO(3)$4

with

$R \in SO(3)$5

so that $R \in SO(3)$6 (Cheng et al., 13 Feb 2026). Scale is predicted by a dedicated head,

$R \in SO(3)$7

and supervised with

$R \in SO(3)$8

The intended effect is to prevent scale errors from leaking into geometry gradients.

3. Architecture, cache mechanics, and training regimen

LongStream uses a DINOv2-based tokenizer to produce patch tokens, augments them with Camera, Keyframe, and Register tokens plus a shared ScaleToken, and processes them with a 24-layer Transformer with alternating global and frame-level attention, approximately 1.3B parameters, initialized from VGGT (Cheng et al., 13 Feb 2026). The outputs per frame are a frame representation $R \in SO(3)$9, a relative pose prediction $t \in \mathbb{R}^3$0, depth $t \in \mathbb{R}^3$1, pointmap $t \in \mathbb{R}^3$2, and a global scale estimate $t \in \mathbb{R}^3$3.

The cache mechanism is central to the system. Standard attention is written as

$t \in \mathbb{R}^3$4

and streaming inference concatenates cached keys and values with current-frame keys and values. The paper argues that naive causal training encourages a persistent attention sink and long-term KV-cache contamination, in which stale features remain in memory and degrade geometry as sequence length grows (Cheng et al., 13 Feb 2026).

To address this, LongStream introduces cache-consistent training (CCT), explicitly training with the same sliding-window KV passing used at inference. The training pseudocode is summarized as $T_{i \leftarrow k} = T_i T_k^{-1}.$0 with inference maintaining a sliding window of size $t \in \mathbb{R}^3$5 and promoting a new keyframe every $t \in \mathbb{R}^3$6 frames (Cheng et al., 13 Feb 2026). Periodic cache refresh resets the KV cache every $t \in \mathbb{R}^3$7 keyframes to marginalize stale context while preserving consistency because prediction remains keyframe-relative.

The training procedure has two stages. Stage 1 is batch-independent pretraining with batch size 22 for 50k iterations, using cosine learning rate with peak $t \in \mathbb{R}^3$8 and 1k warmup, reported as approximately 3 days on 32 A100 GPUs. Stage 2 is KV-consistent training on sampled sequence lengths 10–80 with explicit cache passing and trimming. Metric-scale supervision is applied only on datasets with metric ground truth (Cheng et al., 13 Feb 2026).

4. Empirical performance and relation to constant-memory recurrent systems

The visual-geometry LongStream paper reports real-time streaming at 18 FPS on a single GPU, with memory and latency remaining stable with sequence length, while offline baselines grow memory and hit out-of-memory on long sequences (Cheng et al., 13 Feb 2026). On KITTI, the reported average ATE is 51.90, compared with 226.15 for StreamVGGT, 227.77 for STream3R, 209.78 for CUT3R, 177.73 for TTT3R, and 263.37 for VGGT-SLAM. On vKITTI, the average ATE is 1.610, and on Waymo it is 0.737. On TUM-RGBD, the reported ATE is 0.076, and on Oxford Spires it is 19.815. For 3D reconstruction, the paper reports on 7Scenes a Chamfer Distance of 2.260 and $t \in \mathbb{R}^3$9 of 0.641, and on TUM a Chamfer Distance of 0.225 and $i$0 of 0.673; for scale estimation, the reported full-sequence scale ratio on vKITTI is 0.9905 (Cheng et al., 13 Feb 2026).

A separate analysis positions LongStream within a broader taxonomy of streaming 3D reconstruction methods. In that taxonomy, constant-memory recurrent backbones compress the full history into a fixed-size state $i$1, whereas KV-cache–based Transformers in the VGGT family grow memory with sequence length; LongStream is identified as representative of the latter (Ren et al., 16 May 2026). That paper states that LongStream retrains a VGGT-based architecture for long sequences by redesigning camera pose parameterization and the training of a growing KV cache to mitigate first-frame anchor bias and cache saturation. The stated trade-offs are that it forfeits strictly constant memory and requires training from scratch.

The same study contrasts LongStream with adaptive frame gating on CUT3R-like recurrent backbones. It reports that TTT3R-style per-token gates are structurally bounded in magnitude, with median $i$2, 99% of values below $i$3, maximum $i$4, and no gate exceeding $i$5, yielding an effective memory horizon of approximately three frames per state token (Ren et al., 16 May 2026). The proposed scalar frame-level gate $i$6 is presented as a continuous relaxation of SLAM keyframe selection and as a content-aware modifier of recurrent updates. On KITTI long-sequence pose estimation, the reported average ATEs are 43.96 for AFG-Pose, 51.90 for LongStream, 56.60 for AFG-Img, 68.54 for TTT3R, and 87.00 for Keyframe-VO (Ren et al., 16 May 2026). The paper explicitly notes, however, that applying such a gate to a cache-based LongStream-like pipeline does not change its asymptotic memory growth.

5. LongStream as longitudinal modularity for link streams

In temporal network analysis, “LongStream” is used as a label for longitudinal modularity, a modularity function defined directly on link streams rather than on aggregated snapshots (Brabant et al., 2024). A link stream is defined as

$i$7

where $i$8 is a time interval, $i$9 is a finite set of nodes, and $k$0 is a finite set of interactions. The formulation in the paper focuses on instantaneous, undirected, unweighted interactions, with discrete time for convenience.

The modularity construction compares observed internal interactions to longitudinal expectations under a configuration-style null model, while adding a smoothness penalty based on the Community Switch Count. For a dynamic community structure $k$1, the longitudinal modularity is

$k$2

where $k$3 selects one of three longitudinal expectations, and

$k$4

penalizes temporal discontinuity through node-level community switches (Brabant et al., 2024).

Three expectation variants are defined: co-membership expectation, joint membership expectation, and mean membership expectation. The paper states that if there is only one time step, these expectations reduce to the static configuration model term $k$5, and the smoothness term becomes zero, so the formulation recovers static Newman modularity (Brabant et al., 2024). It also argues that the score is independent of time aggregation under lossless aggregation into weighted multigraph snapshots, because internal interaction counts, temporal presence ratios, global degrees, and the CSC penalty remain invariant.

Experimentally, the paper evaluates the measure on the Sociopatterns high school dataset and reports that partitions obtained from MS-modularity generally score higher under L-Modularity than partitions from a no-smoothing baseline; it also notes that ground-truth classes yield relatively high, but not maximal, longitudinal modularity (Brabant et al., 2024). The paper does not provide an optimization algorithm and explicitly calls for a Louvain-like heuristic for direct maximization.

6. LongStream-style stream processing in SQL and long-state joins

In the supplied systems literature, “LongStream-style” refers to long-running stream-processing settings that require durable semantics over out-of-order, high-volume streams. One line of work proposes a minimal extension of SQL based on time-varying relations (TVRs), explicit event time, watermarks, and optional materialization controls such as EMIT STREAM and EMIT AFTER WATERMARK (Begoli et al., 2019). A TVR is defined as

$k$6

with snapshot operator $k$7 and relational operators lifted pointwise over time:

$k$8

This makes streams and tables two materializations of the same semantic object rather than separate semantic domains.

The same proposal makes event time first-class through explicit timestamp columns and watermarks

$k$9

interpreted so that once the watermark passes an event-time boundary, groups keyed by earlier event-time values are complete (Begoli et al., 2019). Tumble and Hop are introduced as event-time table-valued functions, and the paper argues that full SQL semantics remain available under this TVR-centric formulation.

A second systems paper addresses the complementary problem of multi-way joins over long state streams under limited memory. It introduces UMJoin, a single-node multi-way stream join operator with an LSM-Tree state backend, and TSC, a Tree to Single-node Conversion that rewrites binary join trees into UMJoin nodes (Hu et al., 2024). UMJoin maintains per-stream key-to-list state in active and immutable memtables backed by SST files, Bloom filters, and an LRU block cache; on each arriving tuple, it inserts the tuple into the corresponding LSM state and probes the other streams’ states, aborting early if any lookup misses.

The paper’s experimental setup uses Flink Standalone on a single server with 8 TaskManagers, 4 slots each, parallelism 32, and TPC-DS v2.13.0 scale factor 10. Under memory caps of 2 GB, 3 GB, and 4 GB, the in-memory MultiStream baseline fails to complete at 2 GB and 3 GB, whereas UMJoin completes at all three limits (Hu et al., 2024). Against a best binary join tree using the same LSM backend, UMJoin is reported as consistently faster from 1–10 GB of backend memory, with the binary plan requiring an additional 5.03 GB of intermediate result data; at 11–12 GB, the binary tree becomes faster, which the paper attributes to UMJoin’s lack of intermediate-result caching and increased disk I/O under abundant memory (Hu et al., 2024).

Taken together, these systems papers use “LongStream” not as a single named algorithm, but as a problem regime: indefinite stream processing with strict demands on semantic predictability, state retention, and resource stability. In that sense, the label spans SQL semantics, storage backends, and optimizer transformations rather than a single model family.