FlashBEV: Fast and Memory-Efficient Exact BEV Transformation with IO-Awareness

MegaSlide-DiT: Memory-Centric Adaptation and Deformable Local Attention for Efficient Video Diffusion

High-resolution video diffusion models built on Diffusion Transformers (DiTs) deliver strong fidelity but quickly exhaust the memory budget of a single workstation. A 100 billion-plus parameter DiT easily requires over a terabyte of persistent state, while naive spatiotemporal self-attention grows quadratically in sequence length. These two walls -- parameter memory and activation memory -- prevent researchers from adapting massive generative models without large GPU clusters. We revisit this problem from a systems perspective and introduce MegaSlide-DiT, a prototype that demonstrates how a pre-trained 105B DiT can be adapted on a single H200 GPU with 1.5 TB of host RAM. Our key insight is that the GPU need not own the model state: all persistent weights, master weights and optimizer moments remain in host memory, while only transient shards are streamed to the GPU on demand. Simultaneously, we replace quadratic global attention with 3D Deformable Slide Attention (3D-DSA), a motion-adaptive local attention operator that reduces both memory and computational complexity to linear in the sequence length. We report detailed memory accounting, execution traces and evaluation results to substantiate our design. MegaSlide-DiT does not claim to train a 105B model from scratch on a single GPU, nor does it magically solve bandwidth limits; rather, it offers a pragmatic path for full-parameter adaptation of massive video diffusion models on high-end workstations.

HiResNets: Native Full-HD Video Recognition with Foveal Residual Streams

Much of the recent progress in image and video recognition has come at the cost of memory: larger models, increased resolution, and longer temporal contexts. An inevitable component is the quadratic (or larger) growth of memory and compute based on image resolution, which is a property of the grid sampling used in convolutional networks and vision transformers. In this work we study residual networks whose convolutional blocks have logarithmic-square growth instead, enabling them to process very high-resolution video quickly. The key insight is to use a residual architecture's residual stream as a high-resolution buffer, to which convolutional blocks only read and write via log-polar image warp operations. Layers adaptively focus on different parts of each frame, with very high resolution only near the focus point. A complete high-resolution representation is built up in the residual stream, analogous to eye saccades creating a complete picture in biological vision, and a theoretical construction is presented that eliminates the quadratic dependency of the residual stream resolution. Experiments demonstrate that our proposed HiResNets learn to foveate around scenes similarly to human vision, and have superior performance in difficult egocentric video recognition tasks, especially egocentric video with small objects and fine-grained recognition.

SeGO: Sensitivity-Aware Golden Optimization for Large-Scale VLM Quantization

YOLOv8n-FEL: A Lightweight Visual Detector with a Progressive Compress-Then-Enhance Architecture for Autonomous Driving

Real-time visual object detection on resource-constrained in-vehicle platforms requires a practical balance among detection accuracy, model size, computational complexity, and inference speed. Existing lightweight detectors may sacrifice accuracy, particularly for small and occluded objects, when model scale is compressed aggressively. To address this trade-off, this study investigates YOLOv8n-FEL, a lightweight visual detector built on YOLOv8n with a progressive “compress-then-enhance” architecture. The design contains three architecture-level modifications. First, the standard Bottleneck blocks in the C2f module are replaced with FasterBlock from FasterNet, forming the C2F-Faster module to reduce parameter count and computational cost. Second, Efficient Multi-Scale Attention (EMA) is integrated through the C2F-Faster-EMA configuration to refine features for small and occluded objects. Third, Large Separable Kernel Attention (LSKA) is introduced at the SPPF stage to refine multi-scale pooled features without quadratic complexity growth. Experiments on KITTI show that YOLOv8n-FEL reduces the parameter count from 3.006 M to 2.582 M and GFLOPs from 8.1 to 6.7, corresponding to reductions of approximately 14.1% and 17.3%, respectively. Under this lightweight setting, precision increases from 88.8% to 90.6% and mAP@0.5 increases from 89.1% to 89.5%; however, recall, mAP@0.5:0.95, and measured inference latency do not surpass the YOLOv8n baseline. At the class level, the main gain is observed for Cyclist detection, with AP@0.5 increasing from 89.9% to 92.6%, whereas Pedestrian detection and high-IoU localization remain challenging. Direct evaluation on DAIR-V2X and Carla simulation is used as supporting evidence under domain shift and controlled scenario variations rather than as deployment-level robustness validation. Overall, YOLOv8n-FEL is best understood as a lightweight accuracy–complexity trade-off model.

FlashBoot: Sub-Second Weight Loading for Large Models at Rack Scale

Flagship Mixture-of-Experts (MoE) models are growing fast along two axes at once: total parameter count and the number of experts. In elastic deployment scenarios, many GPUs across many nodes must become serving-ready quickly, and this growth makes weight loading a noticeable part of the latency budget. Even on NVIDIA's GB300 NVL72, today's state-of-the-art loaders leave most of that bandwidth unused. The losses are structural: (C1) weight memory is fragmented into tens of thousands of per-tensor objects, so transfers run far below link bandwidth; (C2) cross-node replication is gated by NCCL communicator setup, which costs 10-110 s before a single weight byte moves; and (C3) the existing cross-node GPU->GPU clone path is serial and scales poorly to concurrent multi-node bring-up. We present FlashBoot, a hardware-friendly, framework-workflow co-designed weight-loading subsystem built on SGLang. At its core is FabricArena, a contiguous, exportable and inter-node addressable tensor memory layout. On top of it, FlashLoad loads from CPU as a single bulk, zero-copy transfer, and FlashClone replicates a resident model from a remote GPU via a remote-mapping mechanism that removes NCCL setup. In experiments on NVL72 with DeepSeek-V4-Pro and DeepSeek-V4-Flash, FlashClone maps remote weight memory in ~10 ms (versus 10-110 s for NCCL) and sustains>=700 GB/s per clone. Against the state of the art, FlashBoot accelerates single-node weight loading by up to 50x (from 20.1 s to 0.4 s) and concurrent rack-level weight loading by>270x (from 87 s to 0.32 s). Our code will be made publicly available.

Wan-Streamer v0.2: Higher Resolution, Same Latency

We present Wan-Streamer v0.2, a latency-preserving upgrade of the native-streaming, end-to-end audio-visual interaction model. v0.2 keeps the v0.1 modeling formulation, but raises the interactive output stream from 192x336 to 640x368 while preserving approximately 200 ms model-side signal-to-signal latency at 25 FPS. The higher-resolution stream supports scene-grounded mid-shot agents whose posture, gaze, hands, nearby objects, and local scene layout remain legible during real-time conversation. To support the larger visual stream without adding user-visible delay, v0.2 keeps the thinker as a single-GPU low-latency path for streaming perception, the short language/state Transformer pass that builds the generation cache, and final decoding. The performer becomes a multi-GPU Ulysses-style context-parallel group for the expensive next-unit latent generation. Each performer rank writes incoming K/V into a pre-sharded local cache. The long high-resolution latent video sequence is split across ranks for denoising and gathered through Ulysses communication, while the much shorter audio latent sequence is generated without sequence sharding. In this split, the thinker's language/state computation reaches the performer only as K/V conditioning, so no separate language sequence has to be communicated inside the performer group. This concentrates additional hardware on visual generation while preserving the compact thinker-performer boundary, keeping total remote interaction latency at approximately 550 ms when a 350 ms bidirectional network budget is included.