Skip to main content
Search

# LLM Inference

21 related articles

Subscribe to updates
  1. llama.cpp ships v1.0.0: major version numbers now flag C API and ABI breaks so downstream apps can pin interfaces

    llama.cpp and its underlying tensor library ggml both reach v1.0.0, tying semantic versioning to the public C interface: a major bump marks a breaking change to the public C API under ./include, a minor bump covers backward-compatible features, backend updates, model support or API additions, and a patch covers bug fixes with no API change. After 3.5 years of adoption, interface stability becomes the point of release management, a promise earlier version numbers did not carry.

  2. PyTorch

    PyTorch models now run on the browser GPU without format conversion: one .pte file, 2–10× faster decode than the CPU path

    ExecuTorch adds a WebGPU backend that lets PyTorch models exported once with torch.export to a .pte file run on the GPU directly in WebGPU-enabled browsers, without first converting to another framework's format such as GGUF, ONNX or TFLite. Previously, running a PyTorch model in the browser usually meant doing that conversion first. On Chrome on an Apple M1 Pro, 4-bit quantized Llama 3.2 1B and Qwen3-0.6B ran 4–7× faster on prefill and 2–10× faster on decode than ExecuTorch's own Wasm CPU backend (XNNPACK).

  3. arXiv

    A 30B model won't fit on one consumer GPU: run some layers on the CPU and hide the weight transfers behind that work

    When model weights do not fit in a single consumer GPU, on-demand weight transfer takes about 98% of decode time. A layer-wise schedule runs some layers on the CPU while asynchronously moving the next layer's weights to the GPU, hiding the transfer behind CPU computation; on an RTX 5090 desktop, OPT-30B inference runs 3.5 times faster than HuggingFace Accelerate and 6.3 times faster than DeepSpeed Zero-Inference.

  4. arXiv

    Conditional-memory tables stop spending bits by access frequency: gating each lookup cuts DeepSeek table memory from 23.6 to 3.04 GiB

    Large language models store part of their factual knowledge in hash tables keyed by preceding token sequences, and low-bit quantization erases long-tail facts first, while giving more bits to frequently accessed rows does worse than choosing at random. GateRQ stores each row as a ladder of residual codes, computes each lookup's gate from a 1-bit code, and reads deeper levels only for the lookups the gate ranks highest. On DeepSeek-V4.1-Flash it cuts table memory from 23.6 to 3.04 GiB per GPU and raises vLLM throughput over FP8 tables in GPU memory by about 11% and about 31% on the two workloads, losing about 1 PopQA point at 1.50 bits per lookup.

  5. Fireworks AI

    Fireworks stops shipping generic draft models: adaptive speculative decoding tuned to customer data cuts latency up to 3x

    Fireworks has added adaptive speculative execution to FireOptimizer, training the draft model for speculative decoding on a customer's own inference workload instead of generic conversation data. Speculative decoding lets a smaller draft model predict several tokens in parallel for the main model to verify, so the draft's hit rate sets the payoff; generic drafts hit poorly on specialized workloads. In one specialized case a generic draft hit 29% and raised latency 1.5x, while FireOptimizer reached a 76% hit rate and 2x speedup, up to 3x over a generic draft model.

  6. arXiv

    No GPUs needed to plan LLM serving: BLIS simulates the full pipeline on CPU and holds a 300 ms TTFT SLO on four H100s

    BLIS is a deterministic, CPU-only discrete-event simulator that models the whole LLM inference serving pipeline, including admission, routing, scheduling, prefill/decode execution, KV-cache management, and preemption, reaching 6.7% median end-to-end error across 36 experiments while running about 200 times faster than real execution.

  7. An inference engine splits control from execution: a C++ state machine guards KV cache while Python stays editable

    TokenSpeed released an open-source LLM inference engine for agentic workloads that separates the control plane from the execution plane: the control plane is a C++ finite-state machine that uses the type system to constrain request lifecycles and KV cache state at compile time, while the execution plane stays in Python for fast iteration. Earlier inference engines typically coupled scheduling with execution and checked resource safety at runtime. The engine claims TensorRT-LLM-level performance and vLLM-level usability, and reports 685 tokens/s per user serving Qwen3.8-Flash-Next on NVIDIA GB300.

  8. An inference engine splits control from execution: C++ state machine owns the KV cache, Python stays for researchers

    TokenSpeed is an open-source LLM inference engine for agentic workloads, backed by the non-profit LightSeek Foundation, aiming at TensorRT-LLM-level performance with vLLM-level usability in production agentic serving. It separates the scheduling control plane from the execution plane: the control plane is a C++ finite-state machine that uses the type system to enforce safe reuse of request lifecycles and KV cache state at compile time, while the execution plane stays in Python for fast iteration. Kernels are treated as a modular subsystem decoupled from the core engine through a portable public API, a centralized registry, and a plugin mechanism, and the project states it includes one of the fastest MLA implementations on Blackwell for agentic workloads.

  9. arXiv

    Parallel drafts stop guessing alone: candidate rescoring lifts speculative decoding throughput and still beats the uncorrected drafter at 32 concurrent streams

    A parallel diffusion drafter emits a whole block in one forward pass but each slot never sees which tokens earlier slots actually chose; a lightweight corrector that reads only the drafter's existing hidden states and logits scores adjacent candidates in parallel and re-selects left to right, giving the highest average throughput across four verifier backbones and ten benchmarks and staying ahead of the uncorrected drafter at 32 concurrent streams.

  10. Azure Maia 300 targets useful tokens per watt: 96 accelerators per rack, 36% more system compute

    Microsoft released Azure Maia 300, a third-generation in-house inference accelerator designed as a whole system, with software, silicon, rack, networking and datacenter co-designed so each watt and each dollar yields more useful tokens. Compared with the previous generation, it replaces uniform on-chip memory with a locality-aware non-uniform organization across chiplets, letting software place data near the compute that uses it, and adds narrow-precision formats with hardware data-type conversion to cut bytes moved per token. At system level the rack doubles to 96 accelerators, the scale-up domain grows to a 12,288-accelerator superpod, the multi-chiplet strategy raises system compute FLOPs by 36% and HBM bandwidth increases 2.5 times.