Video yükleniyor...

Video Yüklenemedi

Ana Sayfaya Dön

🚨 2.8 trillion parameters. Under 4GB VRAM. No quantization. An open source tool called AirLLM has changed how large language models run on consumer hardware. Instead of loading the entire model at once, it processes one layer at a time. This means your VRAM needs depend only on the...

40,529 görüntüleme • 13 gün önce •via X (Twitter)

17 Yorum

Brooks Whale X 🐋 profil fotoğrafı
Brooks Whale X 🐋13 gün önce

Repo:

Md Santo profil fotoğrafı
Md Santo12 gün önce

great share

verdoyant profil fotoğrafı
verdoyant12 gün önce

@HealthRanger

Holland Tech Marco profil fotoğrafı
Holland Tech Marco12 gün önce

This is a very interesting development in the AI space.

Tanvir profil fotoğrafı
Tanvir12 gün önce

Fantastic share

Safwan profil fotoğrafı
Safwan12 gün önce

That's great

Luqman Ali profil fotoğrafı
Luqman Ali13 gün önce

That's Excellent

Yasir Ai profil fotoğrafı
Yasir Ai13 gün önce

Been looking for something that lets me run bigger models on my 16GB card without heavy quantization. Might test this.

Zayden Tech profil fotoğrafı
Zayden Tech12 gün önce

Awesome share

Paul Sims profil fotoğrafı
Paul Sims12 gün önce

Amazing Share

Arsène Lupin profil fotoğrafı
Arsène Lupin12 gün önce

That's an excellent share.

Onil Coder profil fotoğrafı
Onil Coder12 gün önce

I hadn’t thought about it this way before.

Aiden Tech profil fotoğrafı
Aiden Tech13 gün önce

This is amazing share

Oliver Kane profil fotoğrafı
Oliver Kane13 gün önce

The MoE part is the interesting bit. Most of the model never even touches VRAM. Still skeptical until I see real token speeds though.

Brooks Whale X 🐋 profil fotoğrafı
Brooks Whale X 🐋13 gün önce

MoE is the VRAM cheat code. Speed is the reality check: measured ~292 seconds per token on Kimi K3. Disk bandwidth is the new bottleneck.

Winston B. profil fotoğrafı
Winston B.12 gün önce

The tradeoff it skips is speed, since every token streams the weights off disk while the GPU mostly waits. One AirLLM test on a 70B model clocked 292 s/token, which turns a 100-token answer into an 8-hour wait.

Brooks Whale X 🐋 profil fotoğrafı
Brooks Whale X 🐋12 gün önce

Thanks for noting the speed tradeoff. Sequential disk streaming keeps VRAM low but creates high latency, as seen in the 292 s/token result, making AirLLM suitable mainly for batch rather than interactive workloads.

Benzer Videolar

Alibaba just released a coding model that hits 82 percent on SWE-Bench Verified. That is the highest score ever published for an open-source model. The weights are free. The license is Apache 2.0. You can run it today. The model is Qwen 4 Coder 32B. Here is what 82 percent on SWE-Bench Verified actually means. SWE-Bench Verified tests whether an AI can autonomously resolve real bugs pulled from real production GitHub repositories. Not synthetic exercises. Real open-source projects that real teams depend on. A model gets a bug report, reads the code, writes a fix, and either passes the test suite or it does not. At 82 percent, Qwen 4 Coder 32B resolves 82 out of every 100 real production bugs it is given. Without a human guiding it. On code it has never seen before. For comparison: Qwen 4 Coder 32B: 82 percent SWE-Bench Verified. Open source. Apache 2.0. Claude Fable 5: 80.3 percent SWE-Bench Pro. $10 input / $50 output per million tokens. Currently suspended. GPT-5.6 Sol: Competitive on Terminal-Bench. $5 input / $30 output per million tokens. An open-weight model that you can download and run for free just beat both of them on the benchmark designed to measure real software engineering capability. Here is the architecture. Qwen 4 Coder 32B is a 32 billion parameter dense model. Not a Mixture-of-Experts. Every parameter is active on every request. This matters for inference: a dense 32B model runs on 22 gigabytes of VRAM, which fits on a single high-end consumer GPU or a MacBook Pro with 64GB of unified memory. The smaller variant, Qwen 4 Coder 4B, runs at approximately 135 tokens per second on an M5 Max and fits inside 8 gigabytes of RAM. For a model with usable coding capability, that is a new bar for what fits in a single laptop. The training methodology continued Alibaba's approach of reinforcement learning on verifiable coding tasks. The model gets rewarded when its code passes tests. It gets penalized when it fails. Over millions of training steps, the model learns to write code that actually runs rather than code that looks plausible. License: Apache 2.0. Full commercial use. No attribution requirement. No revenue threshold. No monthly active user ceiling. Weights: Hugging Face, available today. Runs on: vLLM, Ollama, SGLang, and any standard GGUF-compatible inference engine. Qwen 4 32B also runs at approximately 135 tokens per second on an M5 Max chip, setting a new bar for what a sub-8GB model can do on Apple Silicon. The open-source coding model just beat the best closed-source model in the world on the benchmark designed to test whether AI can actually do software engineering. The weights are free. The subscription is optional. Source: Autom8Labs AI Insight July 2026, State of Open Source LLMs June 2026, Kunal Ganglani blog June 2026.

Harman

41,278 görüntüleme • 3 ay önce

six months ago this wasn't happening on 8gb vram. running unsloth's Q4_K_XL quant of gemma 4 26b-a4b-it-qat, a sparse MoE model with only 4b active params on a single rtx 4060 laptop gpu, 8gb vram, 20+ tok/s decode. no cloud, no api, no offload hacks. just a gaming laptop on battery. what makes it fit: google's QAT (quantization aware training), plus MTP (multi token prediction) support in the latest llama.cpp builds. that combo is the single biggest unlock for local inference on low vram. rtx 3060, rtx 3070, gtx 1070, gtx 1080, rtx 4050, rtx 4060, rtx 5050, rtx 5060 — any 6-8gb consumer gpu, old or new — this model runs on it. world cup season, so i told it to build a soccer themed flappy bird clone. one shot, zero iteration, fully playable. six months ago an 8gb model could barely clone vanilla flappy bird. now it's shipping a themed game from a sparse MoE model running locally on a laptop battery. inference benchmarks: - decode throughput: 30 tok/s - context: 64k. this is the real unlock. 64k ctx is what makes a hermes agent loop viable locally on this model, not just single-turn chat. llama.cpp flags: -m gemma-4-26B-A4B-it-qat-UD-Q4_K_XL.gguf -c 64000 -cmoe --port 8080 game's deployed on my own site, built and shipped end to end with open source llm, zero closed source api dependency in the pipeline. link in the description. gguf weights on huggingface, link in the comments. pull it down, run it on whatever 8gb card is sitting in your rig. try the game and tell me your score and what you want in v2. local llms on consumer gpus stopped being a meme.

Alok

62,381 görüntüleme • 4 ay önce