Papers for

robot navigation teams

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Sense method improves world model planning for navigation and control

The Sense Paradigm for World Models

Abstract: Latent world models predict the future in an embedding space rather than in pixels. An encoder trained only to predict collapses and maps every observation to the same point, so existing models add a mechanism against collapse, such as a target network, a variance penalty or a distribution penalty. These mechanisms keep the embedding from collapsing, but they leave its distances without meaning, and the model cannot tell a reversible transition from an irreversible one. We propose Sense, a single cross-entropy loss over the directed distance $d(x\to y)=\sum_i \mathrm{ReLU}(y_i-x_i)$ that replaces these mechanisms. The loss avoids collapse on its own, and since the encoder no longer needs the predictor, the predictor is fitted afterwards to fixed embeddings by plain regression. On four pixel environments, the return distance learned by Sense detects irreversible transitions with an AUC between 0.95 and 1.00, where LeWorldModel stays between 0.39 and 0.59. On TwoRoom, the navigation benchmark of LeWorldModel, planning with Sense reaches the goal in 100% of episodes against 91% for LeWorldModel. As the goal moves farther away, the planning failure rate of every baseline grows, while that of Sense stays near zero in Cup, Cliff and Sokoban and is the lowest of all methods in Pendulum.

Sun 15 NovMachine Learning
The gist
Predicting future states in complex environments using computer models can be tricky because models can produce meaningless outputs when they simplify too much. The authors introduce Sense, a new way to measure changes between model predictions that prevents this problem without extra tricks. Sense helps models tell when actions can be reversed or not, making planning more reliable. Their tests show this method improves navigation success and detects important transitions better than previous methods.
Open → 2611.19796v1

Planning safely inside learned models with convex optimization

Successive Convexification in Learned World Models for Safe Offline Planning

Abstract: World models learned from offline data allow an agent to plan without further interaction with the environment, but the sampling-based planners used with them handle safety constraints only by scoring or rejecting sampled action sequences. We instead pose safe planning in the latent space of a learned world model as a successive convex program (SCP), in which a learned discrete-time control barrier function is imposed as a constraint at every step of the horizon. SCP requires smooth dynamics, so we build the networks from smoothed MaxMin activations and spectrally normalised layers, and bound the resulting linearisation error in terms of the Lipschitz bound and the smoothing width. As SCP is a local method, we start it from a sampled plan. On two Safety-Gymnasium navigation tasks with offline data, this planner has fewer violations than MPPI and CEM drawing 128 times as many samples at equal wall-clock time in our main comparison, though not significantly, and earns greater return at longer horizons, and is much safer than SCP without a sampled start. SCP converged more often on Lipschitz-bounded models. Unlike sampling, it also reports at each step whether its plan is a feasible, first-order optimal KKT point of the planning problem in the model, or that no feasible plan was found nearby. Our implementation is publicly available at https://github.com/youngers2006/scwm.

Sat 14 NovMachine LearningRobotics
The gist
Planning actions safely using data from past experiences is hard because approaches often guess many possible plans and reject unsafe ones, which can be inefficient. The authors propose a new method that turns this into a step-by-step mathematical problem with safety rules built in. They smooth the model’s behavior to make this step-by-step approach work well and start it from a guess to find safer plans faster. In tests with simulated navigation tasks, their method found safer paths with fewer rule violations and gave a clearer answer if no safe plan was nearby.
Open → 2611.19466v1

Long-range robot navigation improves by combining scene understanding and geometry

MOSU2: Long-range Navigation System with Multi-modal Scene Understanding

Abstract: Robots that travel long distances through public outdoor spaces must do more than avoid obstacles: they must remain on terrain suited to their mobility and decide when to proceed, yield, or detour around pedestrians, cyclists, vehicles, traffic signals, and temporary restrictions. These decisions are difficult because their correctness often depends on how a scene evolves, such as whether an approaching car is slowing or a cyclist will cross the robot's path. Vision-language models (VLMs) can interpret such cues, but they reason over images that lack metric geometry and motion. Supplying this evidence at every step is too slow for real-time navigation, and hand-crafted triggers cannot anticipate the open-ended variety of outdoor situations. We present MOSU2, a long-range navigation system with two-stage trajectory selection, in which first-stage contextual reasoning determines when additional evidence is needed and what to retrieve. Only when an interaction remains unresolved does the first stage trigger the second stage to retrieve geometric and dynamic information and align it with scene context to make navigation decisions. Building on MOSU, MOSU2 follows routes from GPS-based route planning and filters candidate trajectories through multi-modal traversability analysis before selecting a trajectory to move the robot. In real-world experiments spanning stop gestures, construction sites, crosswalks, and roads shared with vehicles, cyclists, and pedestrians, MOSU2 raises mean navigation success from 61.8% to 94.2% and condition-detection accuracy from 72.2% to 91.4% over its single-image predecessor, at about 2.2 times its mean decision latency. Project website: https://jinggm.github.io/mosu2/

Sun 8 NovRobotics
The gist
Robots moving through public outdoor spaces need to safely navigate around people, vehicles, and various obstacles while staying on suitable paths. The authors show that using a two-step system helps robots decide when to get more detailed information about their environment, combining visual cues with measurements of distance and motion. This helps the robot better understand how scenes change over time, like whether a car is slowing down or a cyclist is about to cross. Their system, MOSU2, improves navigation success and accuracy compared to prior approaches relying on single images.
Open → 2611.11148v1

Improved 3D scene reconstruction using Gaussian spacing normalization

SplatAnything: Gaussian Spacing Normalization for Feed-forward 3DGS across Arbitrary Scenes

Abstract: We identify a key limitation of existing feed-forward 3DGS methods: Gaussian attributes are typically predicted in a radial-distance-normalized space that canonicalizes a global radial statistic of the reconstructed geometry, while the spacing between neighboring Gaussian centers can still vary substantially across scene scales and camera configurations. This mismatch induces systematic shifts in Gaussian-scale targets, leading to ambiguous supervision. To address this, we propose SplatAnything with Gaussian Spacing Normalization (GSNorm), which canonicalizes a robust scene-level statistic of Gaussian spacing to provide a more consistent spatial reference for Gaussian prediction. To rigorously assess our method, we further establish a systematic benchmark spanning diverse datasets, input sparsity levels, and challenging extrapolated viewpoints. Extensive experiments demonstrate that SplatAnything achieves state-of-the-art performance, with particularly strong gains under substantial variations in scene scale and viewpoint.

Thu 5 NovComputer Vision and Pattern Recognition
The gist
Reconstructing 3D scenes using existing methods can be tricky because the distances between key points called Gaussians change a lot depending on the scene size and viewpoint. This makes it hard for the system to learn the right shapes consistently. The authors found a way to adjust these key points by normalizing how spaced out they are across the whole scene, making the system's predictions more stable. They tested their method on many different scenes and camera views and showed it works better than previous approaches, especially when the scene size or viewpoint changes a lot.
Open → 2611.08264v1

Fast nearest neighbor searches and shortest paths inside polygons

Implicit Additively Weighted Geodesic Voronoi Diagrams and Applications

Abstract: Let $P$ be a simple polygon with $m$ vertices. After $O(m)$-time preprocessing of $P$, for any set $S$ of $n$ additively weighted point sites, we compute an implicit additively weighted geodesic Voronoi diagram in $O(n\log n+n\log^2 m)$ time, supporting nearest-neighbor queries in $O(\log(n+m))$ time. In contrast, explicitly constructing the diagram requires $Ω(m)$ time. Our algorithm introduces a new sweep-line paradigm that avoids explicitly constructing the diagram, together with a novel technique for point location in implicit subdivisions. As applications, we obtain new dynamic data structures for additively weighted geodesic nearest-neighbor searching and the first efficient algorithms for shortest paths in geodesic disk graphs. After the same $O(m)$-time preprocessing, single-source shortest paths in a geodesic disk graph of $n$ sites can be computed in $O(n\log n+n\log^2 m)$ time in the unweighted case and $O(n^{3/2}(\log n+\log^2 m))$ time in the weighted case. We also extend our techniques to implicit farthest geodesic Voronoi diagrams for unweighted sites, obtaining analogous bounds and dynamic farthest-neighbor data structures.

Fri 30 OctComputational GeometryData Structures and Algorithms
The gist
Finding the closest site inside a polygon can be very slow when there are many points and vertices. The authors describe a way to quickly find nearest neighbors and shortest paths without building large complex maps explicitly. Their new method uses a clever sweeping process and stores information implicitly to answer queries much faster. This makes it possible to efficiently update and search in complicated polygonal environments.
Open → 2610.42075v1

Panographicgs improves 3d scene maps and segmentation across views

PanoGraphGS: Unifying Panoptic Segmentation and Hierarchical 3D Scene Graphs with Gaussian Splatting

Abstract: 3D scene graphs support language-guided navigation by organizing physical entities and their containment and spatial relations into hierarchical maps. Building such structured maps requires a scene representation that consistently distinguishes semantic regions and object instances across viewpoints. To this end, we present PanoGraphGS, a unified framework that integrates panoptic 3D Gaussian representation learning with hierarchical 3D scene graph construction. The framework learns semantic and instance features on shared Gaussian geometry. Prototype-based semantic learning and association-based instance learning produce consistent panoptic predictions across viewpoints. The learned representation supports novel-view panoptic segmentation and direct Gaussian-level panoptic decoding. A semantic-aware scene graph module further recovers a floor-room-stuff-object hierarchy with containment and spatial relations. We further release NaviGS, a real-world dataset for panoramic scene understanding. The dataset provides 3DGS, mesh, RGB, semantic, and depth data. For 3D scene graph identification, PanoGraphGS outperforms the strongest evaluated baseline in object-node accuracy by more than 50\% points on average across Replica and NaviGS. PanoGraphGS also achieves state-of-the-art performance among the evaluated methods in 2D panoptic segmentation. These results demonstrate the effectiveness of PanoGraphGS in both hierarchical 3D scene understanding and 2D panoptic segmentation. The project website is available at: https://github.com/gaojh0333/PanoGraphGS.

Tue 20 OctComputer Vision and Pattern RecognitionRobotics
The gist
Understanding complex 3D scenes involves recognizing objects and how they fit together in a space, like rooms in a building. The authors developed PanoGraphGS, a system that uses a special 3D representation called Gaussian splatting to consistently identify objects and their relationships from different viewpoints. This helps create detailed scene maps that include both object types and their hierarchy, such as which room an object belongs to. Their system performs better than previous methods on real-world datasets and also improves 2D image segmentation.
Open → 2610.27696v1

Curved sight lines improve visibility in art gallery polygons

Arithmetic Visibility in Polygons: Curved Sight in the Art Gallery

Abstract: In the classical art gallery problem, a guard sees a target when the segment joining them lies entirely within the polygon. We explore what changes when sight may bend along regular arcs on absolutely irreducible curves, but only those defined by primitive integer polynomials of total degree at most \(d\) and coefficient height at most \(H\). We call such curves admissible sight carriers. Arcs can dramatically improve sight. In a one-sided comb, no straight-line guard sees selected targets in two different teeth, yet a single central guard sees a chosen target in every tooth along parabolic carriers. Sight can also fail in two different ways. Geometrically, the polygon may block every sight arc of the allowed degree between two points. For instance, in an alternating comb, the number of guards needed for a row of targets spanning the comb grows linearly with the number of sides at each fixed degree, even for carriers with arbitrary real coefficients. Arithmetically, no admissible carrier may pass through the points at all. Even in the unit square, at fixed \(d\) and \(H\), the proportion of rational targets that must guard themselves tends to one as the height bound grows. An algebraic target may lie on no rational curve of degree at most \(d\), however large \(H\) is. Both failures can be overcome for finite target sets by allowing the degree and coefficient height to grow. We show that every finite set of algebraic targets in a rational polygon becomes visible from any rational interior guard, with explicit bounds. We also construct, for every \(d\), arbitrarily large Galois orbits in the unit square, all of projective height \(4^{d+1}\), whose points must each guard themselves at degree \(d\) for every \(H\). Yet at degree \(d+1\) and coefficient height one, a single guard sees the whole orbit along \(Z(Y-X^{d+1})\).

Wed 14 OctComputational Geometry
The gist
The classical art gallery problem asks how to place guards so they can see every point inside a polygon using straight lines. This paper studies what happens if guards can see along certain carefully defined curved paths instead. The authors find that curved sight can let a single guard see places that straight sight cannot, but there are geometric and arithmetic limits on when this works. They prove that by allowing more complex curves, any finite set of targets inside a polygon can be seen from any guard position. They also identify special sets of points that need very specific curve shapes to be seen.
Open → 2610.19506v1

Looped reasoning methods solve problems faster with stable cycles

Looped Reasoning Finishes Earlier Than You Think

Abstract: Looped reasoning with dynamic depth can be viewed as relaxation toward solution attractors in a learned dynamical landscape. In practice, however, latent trajectories often oscillate, cycle, or drift rather than cleanly converge to stable fixed points. How these non-stationary dynamics contribute to reasoning and constrain convergence remains unclear. We show that slowly decaying oscillatory modes can impose their convergence rate on coupled latent dynamics, creating a bottleneck. Yet damping these modes indiscriminately can disrupt the reasoning computation they support. This tension motivates an architectural approach: introducing rotational degrees of freedom along which symmetry-generated rotational motion leaves the reasoning-relevant quotient dynamics unchanged by construction. We propose QRR (Quotient Recurrent Reasoner), a gauge-equivariant recurrent architecture with an exact per-token phase-rotation symmetry. Motion along these symmetry directions leaves the quotient representation unchanged and is dynamically decoupled from reasoning-relevant dynamics. Empirically, QRR achieves stable and faster convergence to solution roots in quotient space, without forming a dominant slow oscillatory bottleneck, while matching or surpassing recent recurrent reasoning models on Sudoku, Maze, and Mini-ARC.

Tue 13 OctMachine LearningArtificial Intelligence
The gist
Some computer reasoning methods take longer because their internal steps cycle or oscillate without settling down quickly. The authors show that these slow cycles can cause delays but can’t be removed entirely without hurting the reasoning process. They design a new method called QRR that separates the harmless oscillations from the reasoning steps, allowing the system to finish reasoning faster and more reliably. They tested this on puzzles like Sudoku and mazes, where QRR performed as well as or better than other recent systems.
Open → 2610.18174v1

Bayesian updates improve 3D reconstruction from long video streams

BAT3R: Robust Online 3D Reconstruction with Bayesian Adaptive State Updates

Abstract: Feed-forward transformer models have driven remarkable progress in 3D vision,yet their quadratic complexity renders them impractical for long video sequences. Streaming 3D reconstruction addresses this bottleneck by processing frames sequen?tially with constant memory. However, existing recurrent architectures inevitably suffer from progressive degradation over long sequences, as they fail to account for the intrinsic reliability of observations and the accumulated confidence of the historical state, leading to severe error accumulation. To address these issues, we introduce BAT3R, a training-free Bayesian adaptation framework comprising two synergistic modules: State Innovation Gating (SIG) and Bayesian-guided Adaptive State Updating (BASU). SIG acts as a distributional regularizer that anchors state evolution to its geometric initialization, effectively arresting representational drift during long-term inference. Building on this, BASU reformulates state update as a recursive Bayesian inference process within a Kalman filtering framework. By jointly modeling the temporal reliability of observations via information-theoretic gain and spatial relevance via cross-attention maps, BASU achieves an asymmetric spatio-temporal state fusion: well-consolidated historical regions are protected from redundant updates, while genuinely novel scene content is aggressively incor?porated. Extensive experiments on standard benchmarks (7-Scenes, TUM, ScanNet, KITTI, etc.) demonstrate that BAT3R consistently outperforms state-of-the-art online 3D reconstruction methods, with the most significant gains observed on long sequences and complex scenes.

Mon 12 OctComputer Vision and Pattern RecognitionArtificial Intelligence
The gist
Building 3D images from videos can be tricky because errors add up over time, making the model worse. The authors introduce a method called BAT3R that uses smart checking and updating techniques based on probability math to keep the 3D model accurate as new video frames come in. Their approach protects well-learned parts of the scene while updating only what is new or uncertain. Tests on many standard datasets show BAT3R works better than existing tools, especially for long or complex video sequences.
Open → 2610.16330v1

Proof confirms cyclic search method is best for multipath search

On the Cyclic Assumption of the Cow-Path Search Algorithm

Abstract: In the cow-path problem, a cow must find a goal lying at an unknown distance on one of $w$ paths connected only at the origin, and performance is measured by competitive ratio. Kao, Reif and Tate designed an efficient randomized algorithm in which the cow visits the paths in a fixed cyclic order. They proved the algorithm is optimal for $w=2$, and subsequently Kao, Ma, Sipser and Yin proved its optimality for all $w$, with a claim that no algorithm does better than the best cyclic one. This note provides a detailed proof of that claim.

Wed 7 OctData Structures and AlgorithmsMachine Learning
The gist
The paper studies a problem where a searcher must find a target hidden on one of several paths starting from the same point, without knowing the target’s distance. Earlier work designed a randomized search method that checks the paths in a fixed order cyclically and showed it’s optimal when there are two paths. The authors clarify and prove that this cyclic approach is actually the best possible for any number of paths, meaning no other algorithm can outperform it. This settles a previous claim about the optimality of the cyclic search pattern.
Open → 2610.10253v1

Lightweight instance method improves 4D occupancy forecasting accuracy

LighTROcc: Lightweight 4D Occupancy Forecasting via Instance-Centric 3D Gaussians

Abstract: Forecasting future 3D occupancy from surround-view cameras is essential for autonomous driving, yet existing approaches rely on dense voxel or bird's-eye-view representations whose cost grows rapidly with spatial resolution and prediction horizon. Because these representations do not explicitly maintain object identities, they also struggle to preserve instance consistency over time. We present LighTROcc, a lightweight instance-centric framework that represents movable objects with a compact set of learned queries and predicts present and future occupancy in a single forward pass. LighTROcc localizes each query through attention-guided forward lifting, combining image-space cross-attention, query-specific depth, and camera geometry to estimate its 3D center. Each instance is modeled as a mixture of anisotropic 3D Gaussians and propagated across future steps using predicted displacements, producing continuous, temporally consistent occupancy forecasts. Experiments on nuScenes and supplemented nuScenes-Occupancy show that LighTROcc outperforms the evaluated dense and instance-wise baselines in instance-level forecasting accuracy while maintaining strong voxel-level occupancy quality. Across different model configurations, LighTROcc achieves a favorable balance between forecasting accuracy and computational efficiency, demonstrating the potential of compact instance-centric modeling for camera-based 4D occupancy forecasting.

Wed 7 OctComputer Vision and Pattern Recognition
The gist
Forecasting where objects will be in 3D over time is important for self-driving cars to understand their surroundings. Existing methods use dense 3D grids that get very expensive as they try to be more detailed and predict further into the future. The authors introduce LighTROcc, a lighter approach that tracks individual movable objects using a few learned points and models their shape as 3D Gaussian blobs. This method predicts current and future object locations efficiently and keeps the identity of each object over time. Tests show it is more accurate at forecasting object-level positions while still providing good overall 3D occupancy quality.
Open → 2610.09444v1

Controllable crowd simulation adapts to new user objectives

Controllable Crowd Generation through World-Model Planning

Abstract: Crowd simulation plays a central role in robot navigation, autonomous driving, and urban planning. For these applications, realistic simulation requires crowds to adapt their behavior to environmental changes and user objectives. However, existing methods that rely on predefined control settings have limited flexibility in accommodating new user-specified objectives. To address this limitation, we propose Ctrl-CWM, a multi-agent Controllable Crowd World Model that integrates crowd generation and run-time control. Our key idea is to adapt the world-model principle of planning using imagined futures to crowd simulation. To this end, Ctrl-CWM consists of an encoder that learns a representation of human motion dynamics, an actor that proposes pedestrian displacements, a critic that evaluates imagined crowd trajectories, and a planner that selects actions. We first learn human motion dynamics through trajectory prediction on real-world pedestrian videos and then freeze the encoder to preserve them. Using this representation, the actor generates imagined crowd trajectories through repeated state updates, and the planner combines the critic's scores with user costs to select actions. Repeated planning advances the simulated crowd, while additional user costs introduce new control objectives without retraining. We extensively evaluate crowd generation under varied agent arrival conditions and run-time control across avoidance and attraction scenarios. Ctrl-CWM outperforms the state-of-the-art method on most crowd realism and collision metrics, and adapts crowd behaviors to user-specified objectives introduced during simulation. The project page is available at https://jungyu0413.github.io/Ctrl-CWM

Wed 7 OctComputer Vision and Pattern Recognition
The gist
Simulating crowds realistically is important for things like robot navigation and city planning. However, existing methods struggle to easily adjust crowd behavior when users want new goals during the simulation. The authors propose Ctrl-CWM, which uses a special planning model that imagines multiple future crowd movements and chooses actions aligning with new user goals without retraining. This approach produces more realistic crowds that can adapt their movements to avoid or be attracted to certain areas as specified by the user.
Open → 2610.09438v1

Temporal graph exploration time grows with degree and size logarithm

Hiding a Vertex from the Temporal Explorer: A Lower Bound for Degree-Bounded Temporal Graphs

Abstract: A temporal graph is a sequence of graphs on a common set of $n$ vertices, its snapshots, one for each time step. An agent, knowing the entire sequence in advance, may at each time step wait or move along an edge of the current snapshot, and the temporal graph is explored once the agent has visited every vertex. We consider always-connected temporal graphs, in which every snapshot is connected, and ask how long exploration can be forced to take when the underlying graph, the union of all snapshots, has maximum degree at most~$Δ$. Two lower bounds were known in this setting, $Ω(Δn)$ and $Ω(n\log n)$, realised by different constructions. We establish a stronger lower bound, answering a question of Bastide, Groenland, Michel and Rambaud. Specifically, for every $n$ and $Δ$ with $Δ_0\leΔ\le n-1$ we construct an always-connected temporal graph on $n$ vertices with underlying maximum degree at most~$Δ$ that cannot be explored in fewer than $γ\,Δn\,(1+\log(n/Δ))$ time steps from any start vertex, where $γ>0$ and $Δ_0$ are absolute constants. The construction is deterministic, and every snapshot is a spanning tree with exactly one vertex of degree greater than three. Time is divided into phases. In each phase, a rotating-cycle gadget prevents the agent from reaching more than half of the trees attached to it. Between phases, we reassign target vertices among these trees using walks on a constant-degree expander, and a Gray code order of the targets keeps the underlying degree bounded. The reassignment guarantees that, for any walk of the agent, some target remains unvisited throughout all phases.

Mon 5 OctData Structures and AlgorithmsDiscrete Mathematics
The gist
Exploring a network that changes over time can take a long time, even when each snapshot is connected and the network isn’t too complicated. The authors show that for networks where no point connects to too many others, there’s a fundamental lower limit on the time needed to visit all points. They build special examples where an agent, even with full knowledge of the network’s changes, must spend a long time to visit every location. This finding improves previous known limits and answers a key open question in the field.
Open → 2610.06228v1

Motion code method improves continuous trajectory forecasting accuracy

MoCAR: Motion-code Coordinate-aware AutoRegression for Continuous Trajectory Forecasting

Abstract: Autoregressive generation is natural for language, where predicted tokens can be directly reused as the next prediction state, but trajectory forecasting lacks such a clean token: motion is continuous, multimodal, and expressed in local coordinate frames that evolve with the predicted trajectory. We present MoCAR (Motion-code Coordinate-aware AutoRegression), a decoder-only framework that casts trajectory forecasting as next-code prediction in a coordinate-aware continuous latent space. MoCAR learns a continuous motion-code space from endpoint-normalized trajectory segments, where each code jointly captures local trajectory geometry and the reference-frame transition induced by that segment. Historical motion codes are used as a teacher-forced prefix, future codes are generated autoregressively under temporal, map, agent, and mode interactions, and predicted codes persist in latent memory while decoded endpoints update the local scene context. This enables rollout without trajectory-space re-tokenization, trajectory queries, goal candidates, or proposal-and-refinement pipelines. On Argoverse (AV) benchmarks, MoCAR achieves top-tier performance with a simple single-stage architecture, transfers strongly from AV2 to AV1 in zero-shot evaluation, and improves on turn-heavy scenarios. Ablations confirm that the learned continuous motion-code space, latent alignment, weak KL regularization, and joint tokenizer-predictor optimization are essential for stable latent autoregression.

Mon 5 OctComputer Vision and Pattern Recognition
The gist
Predicting where things will move in a continuous space is hard because movement is smooth and depends on changing viewpoints. The authors created MoCAR, a way to translate movement into a continuous code that considers both the path shape and changing coordinate frames. This code lets a system predict future movement step-by-step without converting back and forth between formats or needing extra tricks like guessing goals first. Tests showed MoCAR performs very well on vehicle trajectory prediction tasks, especially when turns are involved, and works well with data from different sources.
Open → 2610.06210v1

Gpu-accelerated collision-aware planning improves 3d gaussian splatting scenes

CollisionSplatting: Collision-Aware Motion Planning in 3DGS Scenes with Image-Conditioned Objectives and Adjustable Conservatism

Abstract: Incorporating dense visual information into motion planning remains challenging, as geometric planners rely on abstracted scene representations that discard visual richness, while learned visual models often lack geometric interpretability and computational efficiency. This paper introduces CollisionSplatting, a simple, modular, GPU-accelerated, probability-inspired distance metric with tunable conservatism that operates directly on standard 3D Gaussian Splatting (3DGS) scenes. When combined with learned image-conditioned reward functions, this metric enables joint geometric and visual planning by unifying collision-aware costs with image-space objectives. We integrate the metric into GPU-accelerated Model Predictive Path Integral (MPPI) and Rapidly-Exploring Random Tree (RRT) planners, and show on-par or better collision-classification performance compared to representative baselines while achieving substantially higher collision-checking throughput and significantly lower VRAM usage. Finally, we demonstrate the effectiveness of our metric in real-world vision-guided navigation and manipulation tasks, highlighting 3DGS as a practical bridge between rich perception and real-time motion planning.

Mon 28 SeptRobotics
The gist
Planning safe movement for robots using detailed 3D scenes is hard because traditional methods simplify visuals or are slow and hard to interpret. The authors propose a new technique called CollisionSplatting that uses a fast, adjustable way to measure distances directly on detailed 3D visual data. This method works well with AI tools that use images to guide decisions and fits nicely into popular robot path planning methods. Their approach runs fast, uses less memory, and makes smart, safe navigation possible in real-world tasks.
Open → 2609.35619v1

3D point tracking improves metric accuracy using state space models

3D Point Tracking with State Space Models

Abstract: Tracking any point of a dynamic scene in metric 3D - in absolute meters, not up to an unknown scale - underpins 3D and 4D reconstruction, robot navigation, and autonomous driving, where decisions are made in meters, not pixels. Our objective is a 3D point tracker accurate in those absolute terms and operating within a single commodity GPU, pose-free, monocular budget. Our method rests on one observation: once a point's 2D image trajectory is fixed, the quantity that governs its metric accuracy is the depth along its pixel ray. Rather than learning tracking end-to-end, we therefore compose two frozen front-ends - dense optical flow for 2D correspondence and a monocular metric-depth network for the third dimension - and learn only the residual they cannot supply: that depth, refined by a compact state space model (Mamba-3) conditioned on appearance features (DINOv3). A state space model rather than the transformers the strongest 3D trackers adopt is what makes a single-GPU budget attainable: it summarises a track in a fixed-size recurrent state whose memory cost is constant in the number of frames, whereas attention requires a key-value cache that grows linearly with them. On the TAPVid-3D minival benchmark our best configuration attains the highest absolute metric accuracy among methods evaluated under identical conditions (mean metric Average Jaccard, 0.256), exceeding strong feed-forward trackers, while a companion analysis, reproduced with each competitor's own evaluator, explains why several published trackers lose most of their accuracy under this budget.

Sun 27 SeptComputer Vision and Pattern RecognitionMachine LearningRobotics
The gist
Tracking points in 3D space accurately is important for robots and self-driving cars, which need real-world distances rather than just pixels. The authors combine two existing tools for 2D tracking and depth estimation and add a small model to improve depth accuracy over time. This approach runs on a single common GPU and performs better than other methods using similar resources. Their method helps track points precisely in meters rather than arbitrary scales.
Open → 2609.34035v1

Fast method predicts how far uncertain vehicles may move toward robots

Fast Direction-Conditioned Reachability for Motion Prediction Under Model Uncertainty

Abstract: To avoid collisions, a robot must repeatedly predict where nearby agents may move, usually with an imperfect model of their dynamics. Reachable sets provide such predictions, but computing them when the system matrices themselves are uncertain can become computationally expensive and conservative for frequent replanning. Moreover, a planner often needs to know only how far an agent can move in one particular direction, for example toward the robot, rather than the complete reachable set. We propose a direction-conditioned reachability method for linear systems with uncertain state and input matrices. Given a query direction $d$, the method selects one admissible model $(A^\star,B^\star)$ whose reachable set extends nearly as far along $d$ as the reachable set of the entire uncertain model family, and then computes the reachable set of only this model with a standard reachability solver. On an uncertain linearized bicycle model, the complete selection-and-computation pipeline is about three times faster than computing the reachable set of the full uncertain family in the CORA toolbox, while its extent along $d$ is within $5\%$ of the full family's in the reported directions. We also use the method in a closed-loop multi-vehicle simulation in which the robot queries, at each replanning step, how far each nearby vehicle can move toward it, and replans to avoid the resulting sets.

Tue 22 SeptRobotics
The gist
Robots need to guess where nearby moving things like cars will go to avoid crashing. This is hard because the robot's model of how things move isn't perfect and can be slow to calculate. The authors created a faster way to figure out how far an agent might move in just one direction, such as toward the robot, by focusing on one likely motion model instead of all possibilities. Their method is about three times faster and almost as accurate, helping robots plan safer paths around uncertain moving vehicles.
Open → 2609.27077v1

Cube-splat improves 360 degree slam tracking and mapping accuracy

Cube-Splat: High-Fidelity 360° Gaussian Splatting SLAM via Cubemap Factorization and Adjoint-Consistent Optimization

Abstract: Recent progress in 3D Gaussian Splatting (3DGS) has enabled dense visual SLAM with pinhole cameras, yet most pipelines are not designed for panoramic imagery. We present Cube-Splat, the first panoramic GS-SLAM framework that factorizes each 360° frame into a cubemap of four fixed-orientation virtual pinhole views sharing a single optical center. By designating the front face as the primary pose state, we accumulate gradients from all faces via an adjoint mapping, thereby enabling multi-face observations to coherently update a single state while strictly preserving cross-view geometric consistency. Concurrently, our mapping module densifies and optimizes anisotropic Gaussians using aggregated cubemap rays for high-fidelity, dense reconstruction. Furthermore, to rigorously evaluate panoramic SLAM under diverse and challenging conditions, we introduce SynPano, a highly scalable, photorealistic synthetic dataset featuring parameterized complex trajectories and multi-modal ground truth. Extensive evaluations on two public benchmarks (PALVIO and OmniBlender) and our SynPano dataset, collectively encompassing both indoor and outdoor scenes, demonstrate that Cube-Splat achieves state-of-the-art (SOTA) performance in tracking accuracy and reconstruction fidelity. Both the source code and the SynPano dataset are available at https://github.com/guoxf304/CubeSplat.

Fri 18 SeptComputer Vision and Pattern Recognition
The gist
360-degree cameras see everything around you, but it’s hard for computers to use these images to understand their location and surroundings accurately. The authors created Cube-Splat, a method that breaks down 360-degree images into smaller square views to better track movement and build detailed 3D maps. They also made a new dataset called SynPano that helps test these methods in different environments. Their approach works better than others on public benchmarks for both how well it tracks movement and how closely it reconstructs scenes.
Open → 2609.21347v1