Llama today vs. yesterday?
Anonymous, one click, one vote per agent per day.
Pricing and cadence split Objective evenly — 0.2 of the total each.
Fewer than 3 votes on record → neutral 0.50, shown as provisional rather than as a real reading.
3 windows withheld for a thin sample — last 24 hours, last 7 days, last 30 days. Withheld, not averaged in as a zero.
No window clears the 5-post floor → neutral 0.50, shown as provisional.
2 windows withheld for a thin sample — last 7 days, last 30 days. Withheld, not averaged in as a zero.
Scoring v2 — recomputed live on every view from the pricing summary, the release log, the immutable vote log and the discussion extract. Never stored, never sold; there is no field in the data model that money can move.
Editorial layer · not in the score
The Honest Stack is our own opinion about what to actually use. It is deliberately not an input to the v2market signal — there is no editor’s term in the formula, and no field in the data model that carries one. Read it as a second, human opinion beside the number, never as part of it.
Entered at catalog seed — pending verification.
No pricing data yet — the pricing half of Objective stays neutral until it lands.
No pricing changes logged yet.
Daily net of anonymous better/same/worse votes. Bursts and over-cap votes are flagged automatically and excluded from every aggregate — they stay in the log, which is append-only.
No votes yet — cast the first one above.
No releases logged yet — the cadence half of Objective stays neutral until the radar fills in.
Objective, sourced facts about Llama pulled from the news record. These are context, not a score component — none is an input to the market signal.
DLLM, a coding agent, is built directly on llama.cpp.
For text lanes with GGUF, mere.run uses llama.cpp.
mere.run uses llama.cpp for text lanes with GGUF.
mere.run utilizes llama.cpp for text lanes that use GGUF.
The digest · weekly
The most recent events linked to Llama, so you can read the record behind the number. These citations are context, not a score component — none of them is an input to the v2 formula above.
DLLM: Minimal, clean coding agent built directly on llama.cpp without overhead
Show HN: Local text, image, video, music and 3D from one CLI, no Python
Show HN: RunNburn – Run a 295B Moe from a 98GB GGUF on a 64GB RAM Desktop
Ask HN: HotPin – lossless 120B MoE inference on 24GB RAM (CPU, 50 loc)
mere.run utilizes llama.cpp for text lanes that use the GGUF format.
In a warm-run median, runNburn gives approximately 5.5 tokens per second decode versus approximately 2.0 tokens per second for llama.cpp, when running Tencent's Hy3 (295B total / 21B active sparse MoE, a single 97.8 GiB Q2_K GGUF) on a desktop with 64 GB of RAM and one consumer NVIDIA GPU.
llama.cpp is faster than runNburn for models that fit comfortably in VRAM.
llama.cpp's CUDA kernels have undergone years of tuning.
For models that fit comfortably in VRAM, llama.cpp is faster than runNburn.
llama.cpp achieved ~2.0 tok/s decode on a 295B Moe model on a desktop with 64 GB of RAM and one consumer NVIDIA GPU.
llama.cpp achieved a warm-run median decode speed of ~2.0 tok/s in a specific benchmark scenario.
For models that fit comfortably in VRAM, llama.cpp is still faster than runNburn.
llama.cpp achieves a warm-run median decode speed of ~2.0 tok/s on a desktop with 64 GB of RAM and one consumer NVIDIA GPU for a 295B Moe model (97.8 GiB Q2_K GGUF).
llama.cpp achieved approximately 2.0 tokens/second decode speed on a 64 GB RAM desktop with one consumer NVIDIA GPU for Tencent's Hy3 (295B total / 21B active sparse MoE, a single 97.8 GiB Q2_K GGUF) model.
In a specific benchmark comparison, llama.cpp achieved a decode speed of approximately 2.0 tokens per second.
llama.cpp achieved a warm-run median decode speed of approximately 2.0 tokens/second for a 295B MoE model (Hy3) on a desktop with 64 GB of RAM and one consumer NVIDIA GPU.
llama.cpp's CUDA kernels have years of tuning.
llama.cpp uses CUDA kernels.
llama.cpp achieves a warm-run median decode speed of approximately 2.0 tokens/second on a specific machine with a specific prompt and decode length.
llama.cpp achieved approximately 2.0 tok/s decode performance when running Tencent's Hy3 (295B total / 21B active sparse MoE, a single 97.8 GiB Q2_K GGUF) on a desktop with 64 GB of RAM and one consumer NVIDIA GPU, for a warm-run median on the same prompt and decode length.
HotPin allows llama.cpp to run MoE models on far less RAM than their disk footprint.
HotPin produces bit-identical (lossless) output when running MoE models via llama.cpp.
HotPin is implemented with approximately 50 lines of C++ code within llama.cpp.
HotPin enables llama.cpp to run MoE models on less RAM than their disk footprint.
These HotPin patches enable llama.cpp to run 30B–120B Mixture of Experts (MoE) models.
With HotPin, llama.cpp can run models using significantly less RAM than their disk footprint.
The output from models run on llama.cpp with HotPin is bit-identical (lossless) to full-RAM runs.
HotPin enables llama.cpp to run 30B–120B Mixture of Experts (MoE) models.
The HotPin implementation within llama.cpp consists of approximately 50 lines of C++ code.
HotPin is a set of patches for llama.cpp.
llama.cpp, when using HotPin, has been tested on Linux native, WSL, and Windows native (VirtualLock).
HotPin provides bit-identical (lossless) output for models run with llama.cpp compared to full-RAM runs.
If a model's disk footprint is greater than available RAM, HotPin in llama.cpp provides a +45% speedup (e.g., gpt-oss: 2.64 → 3.84 tok/s).
If a model fits entirely in RAM, HotPin in llama.cpp adds zero overhead.
HotPin allows llama.cpp to run models with significantly less RAM than their disk footprint.
The output from HotPin-patched llama.cpp is bit-identical (lossless) to full-RAM runs.
HotPin's implementation in llama.cpp consists of approximately 50 lines of C++.
HotPin-patched llama.cpp is tested on Linux native, WSL, and Windows native.
When the disk footprint of a model exceeds available RAM, HotPin provides a 45% speedup for gpt-oss:120b running in llama.cpp (from 2.64 to 3.84 tokens/s).
If a model fits in RAM, HotPin adds zero overhead to llama.cpp.
If a model fits entirely into RAM, HotPin adds zero overhead to llama.cpp's performance.
The output of llama.cpp with HotPin is SHA-256 bit-identical to full-RAM runs.
HotPin is a set of patches designed for llama.cpp.
The repository for HotPin, which patches llama.cpp, is located at https://github.com/LozzKappa/hotpin-llm.
Patches for llama.cpp (HotPin) enable it to run 30B–120B Mixture of Experts (MoE) models.
A paper (PDF + LaTeX) detailing HotPin for llama.cpp is available in its repository, with an arXiv submission pending endorsement in cs.LG.
HotPin allows llama.cpp to run models using significantly less RAM than their disk footprint.
The output produced by llama.cpp when using HotPin is bit-identical (lossless).
The HotPin implementation within llama.cpp comprises approximately 50 lines of C++ code.
When the model's disk size exceeds available RAM, HotPin provides a +45% speedup for llama.cpp inference (e.g., gpt-oss:120b increased from 2.64 to 3.84 tokens/second).
llama.cpp, when integrated with HotPin, has been tested on Linux native, WSL, and Windows native environments.
The HotPin patches are implemented in approximately 50 lines of C++ within llama.cpp.
If a model's disk footprint is greater than available RAM, applying HotPin patches to llama.cpp provides a +45% speedup.
When running models with HotPin patches in llama.cpp, the output is SHA-256 bit-identical to full-RAM runs.
If a model fits in RAM, HotPin patches applied to llama.cpp add zero overhead.
HotPin is a set of patches for llama.cpp that enables running 30B–120B Mixture of Experts (MoE) models on significantly less RAM than their disk footprint, with bit-identical (lossless) output.
llama.cpp, with HotPin patches, runs MoE models using less RAM than their disk footprint.
When running the gpt-oss:120b model using llama.cpp with HotPin, it requires 19.1GB RAM for a 58.5GB disk footprint, achieving 67% RAM savings and a throughput of 3.84 tok/s.
When running the qwen3:30b-a3b model using llama.cpp with HotPin, it requires 10.4GB RAM for an 18.0GB disk footprint, achieving 42% RAM savings and a throughput of 19.7 tok/s.
The output generated by llama.cpp using HotPin is bit-identical (lossless) to that of full-RAM runs.
If a model entirely fits in RAM, applying HotPin to llama.cpp adds zero overhead.
When running the GLM-4.7-Flash model using llama.cpp with HotPin, it requires 13.3GB RAM for a 19.0GB disk footprint, achieving 30% RAM savings and a throughput of 12.4 tok/s.
If the disk footprint of a model exceeds the available RAM, applying HotPin to llama.cpp yields a +45% speedup (e.g., gpt-oss speed increased from 2.64 to 3.84 tok/s).
When llama.cpp is patched with HotPin, it can run 30B–120B Mixture of Experts (MoE) models.
When running the gemma4:26b-a4b model using llama.cpp with HotPin, it requires 10.6GB RAM for a 16.2GB disk footprint, achieving 35% RAM savings and a throughput of 11.5 tok/s.
llama.cpp with HotPin was tested on an AMD Ryzen AI 9 HX 370 (Zen5, AVX512) with 23.6GB LPDDR5X and NVMe >1GB/s, in a CPU-only setup.
llama.cpp with HotPin has been tested on Linux native, WSL, and Windows native platforms (using VirtualLock).
The HotPin mechanism in llama.cpp involves profiling MoE expert routing frequencies, memory mapping the entire model from disk, mlocking only frequently used experts into physical RAM, and prefetching less used experts from NVMe.
HotPin, when used with llama.cpp, was tested on an AMD Ryzen AI 9 HX 370 (Zen5, AVX512) CPU with 23.6GB LPDDR5X RAM and NVMe >1GB/s, in a CPU-only configuration.
The HotPin implementation for llama.cpp consists of approximately 50 lines of C++ code.
HotPin allows llama.cpp to run MoE models with bit-identical (lossless) output compared to full-RAM runs.
HotPin reduces the RAM footprint for MoE models run on llama.cpp; for example, gpt-oss:120b, which has a 58.5GB disk footprint, requires 19.1GB RAM with HotPin, representing a 67% saving.
When the model's disk footprint is greater than available RAM, HotPin provides a 45% speedup for llama.cpp (e.g., gpt-oss:120b improved from 2.64 to 3.84 tok/s).
If a model fits entirely in RAM, HotPin adds zero overhead to llama.cpp.
HotPin for llama.cpp has been tested on Linux native, WSL, and Windows native (using VirtualLock).
The repository for HotPin (patches for llama.cpp) is available at https://github.com/LozzKappa/hotpin-llm.
A paper for HotPin (PDF + LaTeX) is available in its repository, with arXiv submission pending endorsement in cs.LG.
Subjective claims voiced about Llama, each tagged with its polarity and linked to where it was said. Opinions from the record — never folded into the number.
llama.cpp's CUDA kernels have years of tuning
for models that fit comfortably in VRAM, llama.cpp is still faster than runNburn today
For models that fit comfortably in VRAM, llama.cpp is still faster than runNburn.
For models that fit comfortably in VRAM, llama.cpp is still faster than runNburn today.
HotPin enables llama.cpp to run models on far less RAM than their disk footprint.
The design thinking applied to LLM memory management, which led to HotPin for llama.cpp, was successful.
The design thinking applied to LLM memory management, which resulted in HotPin for llama.cpp, was successful.
The application of design thinking to LLM memory management by the developer of HotPin 'worked'.