Skip to main content
Search

# SGLang

13 related articles

Subscribe to updates
  1. LMSYS Org

    Muse Spark Open decoding passes 1,000 tokens per second: one resident kernel per layer lifts throughput from 517 to 1,109 tok/s

    Muse Spark Open decoding rises from a 517 tok/s baseline to 1,109 tok/s by fusing each layer's attention and MoE into a single kernel that stays resident on the GPU, overlapping weight loads, tensor-core work and cross-GPU communication. Previously SGLang launched about 1,450 kernels per decoding step, and the GPU drained and refilled between them, leaving some SMs and threads idle. The figure was measured on Blackwell GPUs at batch size one with DFlash V2 speculative decoding and has not yet been extended to larger batches.

  2. LMSYS Org

    Decision models skip the explanation: SGLang's Score API reuses a shared query across candidates, so latency barely grows with option count

    For decision tasks such as checking an order's status, an application often needs a category or a score rather than prose. SGLang's Score API lets callers declare label tokens explicitly and read their scores directly, while multi-item scoring (MIS) reuses the repeated query computation inside one request and keeps candidates isolated. On Open-Jev choice tasks, MIS latency stays nearly flat as options grow from 2 to 16: 18.7 ms on Qwen3-0.6B versus 39.6 ms for Generate and 24.3 ms for SIS; the advantage is largest as load rises and is not consistently faster at low load.

  3. arXiv

    Mirage puts a gate on KV-cache timing leaks: probing a sensitive prefix only delays the gateway stream while the GPU keeps reusing cache

    Shared prefix caching makes a cache-hit request reach its first token much faster than a miss, and an attacker can exploit that gap to guess another tenant's prompt token by token. Mirage stops isolating caches by content and instead counts new candidate branches under the same sensitive prefix at the gateway; once the budget is spent, it shifts the whole output stream so a hit looks like a natural miss. On SGLang across Qwen, Llama and DeepSeek models and three timing attacks, attack success falls near the random-guessing floor while median first-token latency on public prefixes stays essentially unchanged.

  4. LMSYS Org

    SGLang stores KV cache in 4 bits: long-context decode throughput rises 26–30%, and FP8 stalls first under agent concurrency

    SGLang adds NVFP4 storage to its paged KV cache, cutting per-token key-value bytes to about 56% of FP8. On Qwen3.8-27B at 32K, 160K and 1M input lengths with matched decode concurrency, peak-batch decode throughput rises about 26–30%; on agentic load beyond concurrency 12, FP8 throughput collapses while NVFP4 keeps climbing. Accuracy gaps vary by task, reaching 1.60 points on SWE-bench Verified.

  5. LMSYS Org

    XM-Sparse moves sparse-attention KV cache off HBM: 49.25% lower time per token at 16K context and matched batch

    Netpreme attaches its X-Mem™ memory tier to SGLang HiSparse so decode GPUs fetch missed KV entries from high-bandwidth external memory instead of host DRAM over PCIe. At 16K context, batch 192 per GPU and a 20% top-k miss rate, average time per output token falls from 167.48 ms to 84.99 ms, a 49.25% reduction; at a 40% miss rate the reduction is 63.58%. At 20% misses, peak decode throughput is 2.09–3.04× that of host DRAM across 16K to 1M contexts.

  6. LMSYS Org

    After DeepSeek open-sourced DeepInfer, SGLang matches or beats it on its own benchmarks, up to 1.04x prefill throughput

    DeepSeek open-sourced DeepInfer, the inference engine behind its own service, along with its kernels; SGLang then brought the Mega kernel series, DSpark speculative decoding, SWA bounded replay and both Engram placements into its mainline and compared against DeepInfer on the same hardware using DeepInfer's own benchmarks. On 4x GB300 and 4x B300, SGLang reaches up to 1.04x DeepInfer's prefill throughput, within 1% at the remaining points; on 64x GB300 its decode step is 1.1% to 7.4% shorter from 16 to 256 requests per GPU and on par at 8. SGLang also ships the KV cache system, prefill/decode disaggregation and cross-replica load balancing that DeepInfer's release notes list as not included.

  7. LMSYS Org

    When a long-context request dies mid-transfer, its KV cache can land in someone else's output: SGLang now holds slots until writes drain

    SGLang closed a cross-request KV cache exposure in disaggregated prefill/decode serving: after a request aborts mid-transfer, RDMA writes it already launched can still land and overwrite another request's cache. Decode now keeps the aborted request's slots until every notified prefill rank acknowledges a drain or a bounded timeout fires, default-on for Mooncake and NIXL from v0.5.21, with throughput deltas within ±2% on 2×H100.

  8. LMSYS Org

    SGLang grows a live MoE deployment instead of restarting it, reaching the first request 5.3× to 8.2× faster

    Large mixture-of-experts (MoE) inference deployments previously had two scaling options: add a full model replica, or restart into a wider expert-parallel topology. SGLang's elastic expert-parallel scale-up adds GPU ranks to a running deployment, reserving metadata and communication buffers for max_ep_size at launch, admitting joiners through Mooncake PG, and carrying expert traffic over NIXL before committing the new topology. On 8×H100 with DeepSeek-V3-Lite FP8, scale-up reached the first completed request 5.3× to 8.2× faster than restart.

  9. LMSYS Org

    SGLang moves its serving stack onto TPU: one engine for GPU and TPU, already in production at Meta

    The SGLang team, with Google and Meta, released SGLang-TorchTPU, an open-source backend that runs the same SGLang serving engine on both GPUs and TPUs. TPU had not been a native PyTorch device, so a PyTorch-centric serving stack could not be reused directly; the new backend keeps the scheduler, RadixAttention and API server unchanged and places TPU work underneath. It is already running in production at Meta and serves as the rollout engine for reinforcement learning with TorchTitan through Miles.

  10. LMSYS Org

    An 816B open-weight multimodal model runs on day one: SGLang and Miles wire up inference and RL backends together

    Meta released Muse Spark Open, an open-weight multimodal mixture-of-experts model, and SGLang and Miles added inference and reinforcement-learning training backends on launch day. Its text backbone has 816B parameters with about 42B active per token, accepting text, image, video and audio with a 1M-token context. On eight B300 GPUs with NVFP4 weights, an OpenHands multi-turn agentic coding replay reaches 80.3K total tokens/s per GPU at 61 tokens/s per user at concurrency 128.