Hugging Face

The Hugging Face community: trending models and datasets, leaderboard shifts, the open-source barometer.

179 picksRelated topicsOpen source Model releases Data & training

Latest picks

141–160 of 179

May 15Friday

AI HOT (Curated Pool)May 15, 02:55

Granite Embedding Multilingual R2: Open Multilingual Embedding Model with 32K Context

IBM Granite released Granite Embedding Multilingual R2 on Hugging Face under Apache 2.0, with fewer than 100 million parameters, a 32K-token context length, and top same-scale retrieval performance on MTEB according to the post.

Why it matters: HKR-H/K/R pass: the 32K-context, sub-100M multilingual embedding model gives RAG builders a concrete open-source option. Impact is narrower than a frontier-model release, so it sits at the featured threshold.

r/LocalLLaMAMay 15, 01:33

MOOSE-Star (ICML 2026): 7B Model and 108K-Paper Dataset for Scientific Hypothesis Discovery

MiroMind researchers released the MOOSE-Star collection with three 7B models and TOMATO-Star, a dataset of 108,717 NCBI papers. MS-IR-7B reaches 54.37% inspiration-retrieval accuracy, uses DeepSeek-R1-Distill-Qwen-7B as its base, runs at about 14GB fp16, and supports llama.cpp, vLLM, and SGLang.

Why it matters: HKR-H/K/R all pass via the local 7B research-agent hook and concrete dataset metrics. Single Reddit source and limited lab gravity keep it below the must-write band.

Take

MOOSE-Star’s useful claim is not “AI discovers science.” It puts a small, runnable baseline under a noisy category. The concrete hooks are good: three 7B models, TOMATO-Star with 108,717 NCBI papers, MS-IR-7B based on DeepSeek-R1-Distill-Qwen-7B, 54.37% inspiration-retrieval accuracy, about 14GB fp16, with llama.cpp, vLLM, and SGLang support.

I like the 7B choice. Scientific hypothesis agents get muddy fast when the demo rides a closed frontier model; nobody can separate retrieval, reasoning, memorization, and prompt craft. A 14GB fp16 model lets labs run ablations instead of applauding a slide. The Reddit body is blocked by 403, so training details and benchmark construction are not visible here. I would be careful with the 54.37% number until we see negatives, time splits, and leakage controls.

r/LocalLLaMAMay 15, 00:30

inclusionAI/Ring-2.6-1T on Hugging Face

inclusionAI released Ring-2.6-1T, a 1T-parameter reasoning model on Hugging Face; it supports high and xhigh reasoning effort levels, targets agent workflows and long-horizon tasks, and uses Async RL with the IcePop algorithm for reinforcement-learning training stability.

Why it matters: HKR-H/K/R pass: a 1T HF model with two reasoning modes and named training methods is real signal. Benchmarks, license, and inference cost are not disclosed, so this stays at the lower edge of featured.

May 14Thursday

r/LocalLLaMAMay 14, 18:32

Automated AI researcher running locally with llama.cpp

Hugging Face’s ml-intern added local-model support through llama.cpp and ollama; the post says Qwen3.6-35B-A3B can orchestrate CPU/GPU sandboxes and Hub jobs to run an end-to-end SFT workflow.

Why it matters: HKR-H/K/R all pass, but this is a Reddit-sourced open-source tool update, not a major model release. Local sandbox and Hub-job orchestration for SFT put it just above the featured threshold.

Take

This reads like a local agent plumbing milestone, not proof that “AI researcher” is solved. The concrete hook is ml-intern adding llama.cpp and ollama support, with Qwen3.6-35B-A3B orchestrating CPU/GPU sandboxes plus Hugging Face Hub jobs to finish an end-to-end SFT run. Reddit’s body is blocked by 403, so run time, failure rate, human intervention points, and VRAM setup are missing. I’d treat this as a reproducible toolchain claim, not a capability claim. Claude Code and OpenAI’s Codex-style agents already made tool use feel normal in cloud setups; the local angle buys privacy, cost control, and sandbox ownership. The weak spot is still long-horizon brittleness: one bad dependency, dataset format issue, or Hub auth error can turn a 35B-A3B “researcher” back into a script runner.

r/LocalLLaMAMay 14, 17:16

Open-source one-prompt-to-cinematic-reel pipeline on one GPU with FLUX.2 and Wan2.2-I2V

The developer open-sourced StudioMI300, an 8-stage sequential pipeline that turns one English sentence into a 720p MP4 on a single AMD Instinct MI300X, cutting end-to-end time from 25.9 minutes to 10.4 minutes per clip.

Why it matters: HKR-H/K/R all pass: the post has a concrete one-GPU video pipeline, runtime numbers, and a local-build cost/control hook. Reddit single-source status and no third-party replication keep it below the 78+ band.

AI HOT (Curated Pool)May 14, 08:00

Unlocking Asynchrony in Continuous Batching

Hugging Face says an 8B model generating 8K tokens leaves the GPU idle for 24% of the time, and asynchronous batching uses CUDA streams to overlap CPU preparation for batch N+1 with GPU computation for batch N.

Why it matters: HKR-H/K/R all pass, but this is inference-systems engineering rather than a major model release. The Hugging Face post provides a concrete 24% idle-rate number and CUDA-stream overlap mechanism, placing it in low featured.

r/LocalLLaMAMay 14, 00:08

sensenova/SenseNova-U1-A3B-MoT · Hugging Face

SenseNova published SenseNova-U1-A3B-MoT on Hugging Face; the post lists A3B MoT, 8B MoT, and 0.4B LoRA weight links, and says the NEO-unify architecture unifies multimodal understanding, reasoning, and generation in one model family.

Why it matters: HKR-H/K/R all pass: an open multimodal model release with multiple weight sizes and a named NEO-unify mechanism. Source authority and missing benchmarks/license details keep it in the lower featured band.

May 13Wednesday

r/LocalLLaMAMay 13, 20:29

AIDC-AI/Ovis2.6-80B-A3B on Hugging Face

AIDC-AI released Ovis2.6-80B-A3B, a multimodal MoE model with 80B total parameters and about 3B active parameters at inference, supporting a 64K-token context window and images up to 2880×2880 resolution.

Why it matters: HKR-H/K/R pass: the open multimodal MoE has concrete specs and a real efficiency hook. Score stays near the featured floor because the post gives no benchmarks, license details, or hands-on results.

QbitAI · WeChatMay 13, 18:06

ByteDance Proposes Generative Refinement Networks as a Third Route for Visual Generation

ByteDance’s commercial technology team proposed GRN, a visual generation architecture using HBQ, global refinement, and complexity-aware sampling to address quantization loss, error accumulation, and fixed-step inference; on a 130M model, adaptive sampling reduced inference from 50 steps to an average of 24, while gFID changed from 3.56 to 3.79.

Why it matters: HKR-H/K/R all pass: ByteDance’s GRN has a concrete hook plus 130M, 24-step inference and gFID 3.79. It is a strong research release, not a flagship model launch, so it stays in the 78–84 band.

May 11Monday

r/LocalLLaMAMay 11, 03:25

MTP benchmark results: task type determines speculative inference speedups or slowdowns

A Reddit LocalLLaMA user ran 300+ tests on Qwen 3.6 27B MTP quants, finding coding draft acceptance at 79-89% and F16 coding speed up 171%, while Q4_K_M creative writing slowed down 9%.

Why it matters: HKR-H/K/R all pass: this is a single Reddit experiment, not a market event, but 300+ Qwen 3.6 27B MTP quantization tests give practical numbers for local inference tuning.

May 10Sunday

r/LocalLLaMAMay 10, 08:48

NVIDIA AI Releases Star Elastic: One Checkpoint Contains 30B, 23B, and 12B Reasoning Models

NVIDIA AI released Star Elastic, a single checkpoint that can zero-shot slice 30B, 23B, and 12B reasoning models in BF16, FP8, and NVFP4; when the 23B submodel handles thinking and the 30B model handles final answers, reported accuracy rises 16% and latency drops 1.9× on AIME-2025, GPQA, LiveCodeBench v5, and MMLU-Pro.

Why it matters: HKR-H/K/R all pass: Star Elastic has a concrete mechanism and testable numbers for inference deployment. Its reach is still narrower than a frontier-model release, so it sits in the high-quality featured band.

May 9Saturday

AI HOT (Curated Pool)May 9, 00:03

EMO: Expert Mixture Models for Emergent Modular Pretraining

AllenAI introduced EMO, a mixture-of-experts model with 14B total parameters and 1B active parameters, trained on 1 trillion tokens and able to use only 12.5% of its experts for specific tasks while retaining near-full-model performance.

Why it matters: HKR-H/K/R all pass, but this is an AllenAI/Hugging Face research release rather than a frontier model launch. The 14B/1B and 12.5% expert-activation claims justify the low featured band.

May 8Friday

r/LocalLLaMAMay 8, 00:20

WARNING: Open-OSS/privacy-filter Malware

A Reddit user says Hugging Face repo Open-OSS/privacy-filter is an infostealer. It mimics OpenAI's privacy filter, uses loader.py to fetch PowerShell, then downloads an EXE and runs it via Task Scheduler. The author says they reported it to Microsoft and Hugging Face; the post says Linux is unaffected.

Why it matters: HKR-H/K/R all pass: malware disguised as an OpenAI privacy filter has a concrete Windows execution chain. Single Reddit sourcing keeps it at the 72-77 featured threshold.

Take

A Reddit user accused Open-OSS/privacy-filter on Hugging Face of delivering a Windows infostealer through loader.py, PowerShell, an EXE, and Task Scheduler.

I'll be blunt: this is not a weird Hugging Face corner case. This is the normal software-supply-chain problem entering the AI model distribution layer. Model repos now bundle weights, Python helpers, demo apps, Gradio code, evaluation scripts, config files, and install instructions. Plenty of users clone a repo and run `pip install -r requirements.txt` or `python app.py` without reading the code. npm and PyPI have been punished by that behavior for years. Hugging Face inherits the same attack surface, with a user base that is often less security-trained than package maintainers.

The source here is thin. The body is only a Reddit 403 page. The original post, screenshots, code snippets, repo commits, hashes, IOC list, Microsoft response, and Hugging Face response are not visible. The title names Open-OSS/privacy-filter. The summary says it mimics OpenAI’s privacy filter, uses loader.py to fetch PowerShell, downloads an EXE, and runs it through Windows Task Scheduler. The summary also says Linux is unaffected. I have not verified the repo, the binary signature, the C2 endpoint, the scheduled task name, or the current takedown state.

Still, the described chain is plausible. Task Scheduler is a standard Windows persistence mechanism. PowerShell as a remote payload launcher is old tradecraft. The AI-specific trick is the label: “privacy filter.” That name borrows trust from OpenAI, privacy anxiety, safety tooling, and open-source culture at once. Local-model users worry about sending data to hosted APIs. That makes them especially receptive to a tool claiming to protect privacy locally. The bait is well chosen.

There is prior context here. Hugging Face has warned for years about pickle and `torch.load` risks, and safetensors exists largely to avoid arbitrary code execution through model loading. The community has also seen malicious model repos, malicious Spaces, and poisoned dependencies. On PyPI, typosquatting and post-install credential stealers are already boringly common. Hugging Face has an extra problem: it is not used only by package-aware developers. Researchers, notebook users, product teams, and automation scripts all click “Use this model.” The UI lowers friction, and attackers love lowered friction.

I do have doubts about the claim as presented. A malware allegation without a VirusTotal link, SHA256, repo snapshot, or platform confirmation is not enough for a final forensic call. Security threads with all-caps “WARNING MALWARE” sometimes spread faster than the evidence. Some Windows helper scripts also look ugly to static scanners. But loader.py fetching PowerShell, dropping an EXE, and registering a scheduled task is far beyond what a normal ML privacy-filter demo should need. Unless the maintainer gives a precise installer rationale, I would treat the repo as hostile.

For practitioners, the operational lesson is concrete. Do not run Hugging Face repo code directly on a primary Windows machine. Inspect loader.py, setup.py, postinstall hooks, PowerShell, batch files, EXEs, DLLs, and any dynamic download path. Prefer safetensors for weights. Run demos in containers or disposable VMs. Restrict outbound network access during first execution. If you touched this repo on Windows, inspect Task Scheduler and startup locations. In a company environment, Hugging Face downloads need software supply-chain scanning. Treating the platform as a “model website” is too naive now.

The uncomfortable part is that open-source AI culture trains people to run first and audit later. Rankings, README snippets, one-click demos, and notebook cells all reward speed. Attackers are simply adapting. Hugging Face can add malware scanning, repo warnings, pickle warnings, and takedown workflows, but arbitrary Python inside model repos means the platform cannot absorb all user risk. A model repo is not automatically trustworthy because the weights are open. Weights are one asset class; executable code is another. Once a repo asks you to run scripts, you are in supply-chain territory, not model-download territory.

May 7Thursday

r/LocalLLaMAMay 7, 03:54

Exaggerated PCI-E Bandwidth Concerns?

Reddit user ziphnor tested 2x RTX 5060 Ti 16GB with vLLM TP=2 and 32k-context prefill. PCIe peaked at 3–4 GB/s, about 40–50% of a PCIe 4.0 x4 link. Prefill reached ~840–850, 1500, and 1600–1700 t/s; the post does not disclose decode bandwidth.

Why it matters: HKR-H/K/R all pass: a myth-busting PCIe bandwidth test with concrete vLLM conditions and numbers. Single Reddit source limits authority, but the named first-person experiment lifts it to the featured threshold.

May 6Wednesday

r/LocalLLaMAMay 6, 17:35

2.5x Faster Inference with Qwen 3.6 27B Using MTP on 48GB

A llama.cpp PR adds MTP support for Qwen 3.6 27B, with a reported 2.5x inference speedup. The author measured 28 tok/s on a Mac M2 Max 96GB and shared GGUF builds, compile steps, and a 262144-context server command. The key detail is turbo4 4.25-bit KV cache: a 48GB Mac runs Q5_K_M at 262K context.

Why it matters: HKR-H/K/R all pass: the hook is concrete, the post names mechanisms and numbers, and local coding-agent cost resonates. Single Reddit source and setup complexity keep it in the low featured band.

r/LocalLLaMAMay 6, 00:01

Gemma 4 MTP Released

Google released Gemma 4 MTP drafters with 4 Hugging Face checkpoints listed. MTP uses a smaller draft model to predict multiple tokens, then the target model verifies them in parallel, giving up to 2x decoding speedups with identical output quality.

Why it matters: HKR-H/K/R all pass: the practical hook is 2x lower-latency decoding, with 4 checkpoints and a clear speculative-decoding mechanism. It is a useful Gemma update, not a flagship model release, so 75 fits the featured lower band.

Take

Google released 4 Gemma 4 MTP draft checkpoints, with the summary claiming up to 2x decoding speedups. The article body is only a Reddit 403 page. It does not disclose checkpoint names, target Gemma 4 sizes, context length, acceptance rates, batch settings, hardware, or integration status for vLLM, SGLang, or llama.cpp. So I would not read this as “Gemma 4 is now 2x faster.” I would read it as Google making the speculative-decoding support pieces public.

My read on this category is blunt: draft models are easy to announce, and hard to make consistently useful. MTP has a clean mechanism. A smaller draft model predicts several tokens, and the target model verifies them in parallel. Output quality can stay identical because the target model still decides the accepted tokens. Latency gains are not automatic. If the draft model is too weak, it misses often and burns verification cycles. If it is too large, it eats memory and scheduling budget. The summary says “up to 2x,” but the body gives no test condition. We do not know whether that number came from single-batch decoding, low-temperature sampling, short completions, or a mixed production workload.

The broader context matters here. Open inference has moved beyond leaderboard scores. Serving cost now decides whether a model gets used. vLLM speculative decoding, Medusa, EAGLE, and Lookahead-style decoding all chase the same bottleneck: interactive workloads spend painful time in token-by-token decode. Prefill can be amortized or optimized with attention kernels, but decode latency is still where chat, coding assistants, and local agents feel slow. For Gemma, MTP support is more useful than another small benchmark bump if it works under normal traffic.

I have a real concern with the “identical quality” framing. It is true at the token-distribution level if verification is implemented correctly. System quality is broader. Tail latency, VRAM pressure, batching behavior, tokenizer compatibility, and failure modes all matter. A second draft checkpoint means another model loaded, another config path, and another scheduler decision. Local users on 24GB or 48GB GPUs may lose KV-cache room to the draft model. Cloud deployments face a different version of the same issue: once batch size rises, speculative decoding gains can shrink because scheduling becomes messier.

There is also a practical adoption question. If Google only posts Hugging Face weights, the release helps researchers first. If the checkpoints land cleanly in vLLM, SGLang, llama.cpp, and MLX, then it becomes useful for daily inference. The article does not confirm that. I would want three numbers before changing a serving stack: the target-model pairing for each of the 4 checkpoints, tokens/sec plus p95 latency on H100/A100/RTX 4090/Mac-class hardware, and acceptance rate across chat, code, high-temperature sampling, and long-context continuations.

So yes, this is a good release signal. Google is treating Gemma as a deployable model family, not only a benchmark artifact. But the production value lives in acceptance-rate curves, not the headline 2x.

May 5Tuesday

r/LocalLLaMAMay 5, 23:02

SenseNova-U1-8B-MoT open-source multimodal architecture draws LocalLLaMA discussion

SenseNova open-sourced SenseNova-U1-8B-MoT, an 8B native multimodal understanding and image-generation model. Its Hugging Face text says NEO-Unify removes VE and VAE, supports interleaved image-text generation, and high-density rendering; the post does not disclose test scores. The key question is whether the monolithic design yields reproducible gains.

Why it matters: HKR-H/K/R all pass: the open 8B unified multimodal model has a concrete architecture hook. No benchmark scores, license detail, or deployment cost are disclosed, so it stays in the 72–77 band.

Take

SenseNova-U1-8B-MoT has the right bait: 8B parameters, open source, native multimodal understanding, image generation, and a NEO-Unify pitch that removes VE and VAE. That directly pokes at the messy stack around Qwen-VL, InternVL, LLaVA-style adapters, and separate diffusion/VAE plumbing. If one compact model handles interleaved text-image generation and dense information rendering reliably, the architecture deserves attention.

The evidence is thin. The Reddit body is blocked by 403, and the summary gives no benchmark, license, VRAM profile, sampling setup, or failure cases. “High-density rendering” is exactly where demos lie: OCR, tables, UI screenshots, and Chinese long images break polished claims fast. I’d file this as architecturally interesting, not yet performance-relevant.

r/LocalLLaMAMay 5, 22:45

Interactive Guide from Hugging Face Comparing RL Environments Across Frameworks

Hugging Face’s post-training team published an interactive guide comparing RL environment frameworks. The team spent one month building environments in verifiers, OpenEnv, Nemo-Gym, OpenRewards, and others, then trained models to study scaling. The post does not disclose benchmark scores, model sizes, or training costs.

Why it matters: HKR-H/K/R pass through the HF comparison hook, one-month hands-on setup, and post-training cost nerve. Missing benchmark scores, model sizes, and training costs keep it at the low featured band.

Apr 30Thursday

r/LocalLLaMAApr 30, 17:40

Qwen-Scope: Official Sparse Autoencoders (SAEs) for Qwen 3.5 models

Qwen Team released Qwen-Scope, SAEs for Qwen 3.5 models from 2B to 35B MoE. It maps residual-stream features across all layers, including Feature #6159 for Chinese activation. The key point is feature-level debugging and steering; the license discourages removing safety filters.

Why it matters: HKR-H/K/R all pass: official Qwen SAEs are novel, concrete, and useful for interpretability work. This is not a new model release, so it stays in the 78–84 recommendation band.

Take

Qwen-Scope matters because Qwen is turning interpretability into official model infrastructure, not leaving it as a side project. The concrete hook is strong: SAEs cover Qwen 3.5 from 2B to 35B MoE and map residual-stream features across all layers; the cited Feature #6159 fires on Chinese-mixing behavior. That is a better release than another eval table, because it gives practitioners a handle for debugging and steering.

I’m cautious because the Reddit body is blocked by 403, so the license text, SAE training setup, sparsity, and reconstruction error are not visible here. Anthropic has used interpretability as a safety asset for a year; Qwen shipping tooling to the local-model crowd pushes the same game into open weights. The test is whether these features survive real steering runs, not whether the screenshots look clean.

r/LocalLLaMAApr 30, 01:19

inclusionAI/Ling-2.6-1T · Hugging Face

inclusionAI open-sourced Ling-2.6-1T on Hugging Face, with 1 trillion parameters. It uses MLA plus Linear Attention and Contextual Process Redundancy Suppression to reduce CoT overhead. The post cites AIME26 and SWE-bench Verified but does not disclose scores.

Why it matters: HKR-H/K/R all pass, but benchmark scores for AIME26 and SWE-bench Verified are not disclosed. A 1T open model with a named architecture mechanism fits featured, not P1.