▲ 232 r/Qwen_AI+1 crossposts

Qwen3.8 2.4T open weights made a Call of Duty clone

Qwen released the 2.4T Max weights and I was curious how well it can re-create COD in one prompt

I ran the model on a rented B200 cluster and used roughly 1.1M output tokens over a 5 hour time span

Realistically barely anyone can run this model locally, but the fact that it's open weights unlocks a lot of opportunities for the local AI community even regarding quantization options that might bring us closer to running frontier level intelligence on consumer-ish hardware 

For consumer hardware there is a 27B model from the same release and it's really capable for its size, many people have posted 3D games made with it on X

I'm from the atomic.chat team, so If you wanna try running the new Qwen locally you can do so inside our app (any feedback is appreciated, since we want to make our product as good as possible for you guys) 

We have our own and other community quants of the 27B model available to download directly inside the app

P.S. I am a noob in shooters so pls no hate my low skill gameplay

u/Fun-Meaning-6474 — 1 day ago
▲ 48 r/Appstore+1 crossposts

LFM2.5-VL-3B recognizes Steve from Minecraft running locally on an iPhone 17

Liquid AI put out LFM2.5-VL-3B today, which is a 3.1B vision model that weighs roughly 2GB and fits well on a phone

Benchmarks are benchmarks so I tried something sillier. Took a photo of a little Steve toy I have, gave it to the model and asked it what it was looking at

It ended up thinking for around 2 minutes and 31 seconds on an iPhone 17, which is a bit too lengthy, but it did end up recognizing Steve and gave a detailed description of him

The main diff from the last gen is that it got much better at spotting where things are. ScreenSpot-v2 desktop went from 6 to 78.7. That's why it describes Steve part by part rather than just naming him

LFM2.5-VL-3B HF card: https://huggingface.co/LiquidAI/LFM2.5-VL-3B

The model was run through atomic.chat mobile app (I'm the founder, so any feedback is welcome)

u/Fun-Meaning-6474 — 7 days ago
▲ 63 r/LocalAIStack+3 crossposts

Quantizing Kimi K3 (2.8T A50B) to GGUF ourselves - Q3_K_S works, 1.1 TB on disk

we're experimenting with our own dynamic GGUF quants of kimi k3, made from the original weights with our llama.cpp fork. Q3_K_S is done and works 1114.76 GiB on disk. Q1 and Q2 are in progress, results on those tomorrow

rented box hardware:

- AMD EPYC 9554P, 64 cores
- 1.5 TB of DDR5
- NVMe in raid0 to store the weights (inference runs fully from ram)
- no GPU

the run:

- 110 threads
- pp512: 4.21 t/s

we ran a short test for text coherence and image understanding to make sure the quant isn't lobotomized. loaded the 1969 NYT "men walk on moon" front page and asked the model to describe what's going on. it listed the masthead, the "all the news that's fit to print" slogan, the date, the 10 cent price, the headline, the sub-headline about astronauts collecting rocks and the "voice from moon" column. we haven't noticed any hallucinated text

wdyt about running quants of giant models like this on cpu instead of going with smth smaller but with normal tps and zero extra costs?

disclaimer: we're the team behind atomic chat ( atomic.chat )

u/Fun-Meaning-6474 — 21 days ago

New DSpark outperformed DFlash on Qwen3-8B, up to +18% faster on one RTX 5090 32GB

We benchmarked DeepSeek's new open speculative decoder DSpark locally against their DFlash drafter, both running on the same Qwen3-8B on three everyday tasks: writing code, a math word problem and an open-ended explanation.

Setup:
GPU: 1x RTX 5090 32GB
Target model: Qwen3-8B (bf16)
Block size: 7
Decoding: greedy, temperature 0
Runs: 3 per task, median tokens/sec

Outputs (DFlash → DSpark tok/s, and acceptance length):
Writing code: 225 → 233 tok/s (+4%), acceptance length 5.00 → 5.29
Math problem: 278 → 309 tok/s (+11%), acceptance length 6.18 → 7.01
Open chat: 126 → 149 tok/s (+18%), acceptance length 2.74 → 3.31

The win tracks how predictable the text is. DFlash drafts a whole block of tokens in one pass and it guesses each token without seeing the other tokens it picked. So the words can stop fitting together and the ones that do not fit get rejected. Code and math are structured and easy to predict, so DFlash already gets 5-6 of 7 tokens right on its own. Little for DSpark to add there (+4% and +11%). Open chat has many possible next words, so DFlash clashes the most and accepts only ~2.7. That is where DSpark helps: it adds a small sequential step so each drafted token sees the one before it, the block stays consistent, and more tokens pass (+18%)

DSpark drafter: https://huggingface.co/deepseek-ai/dspark_qwen3_8b_block7
DFlash drafter: https://huggingface.co/deepseek-ai/dflash_qwen3_8b_block7
Target model: https://huggingface.co/Qwen//Qwen3-8B
DSpark paper: https://github.com/deepseek-ai/DeepSpec/blob/main/DSpark_paper.pdf
Code (DeepSpec): https://github.com/deepseek-ai/DeepSpec
Run Local AI Models: atomic.chat
Full prompts in the comments

https://reddit.com/link/1ujzwbm/video/g4784m167hah1/player

reddit.com
u/Fun-Meaning-6474 — 2 months ago

Unlimited-OCR turned a handwritten calculus exam into clean LaTeX!

We gave it a photo of a hand-written exam page. The model read the handwriting and rebuilt every formula into structured digital text.

Ran it ourselves: baidu Unlimited-OCR (3B, open weights) on a single RTX 3090, transformers + bf16, gundam mode, no flash-attn.

Output: Time 55.6s · 836 output tokens · ~15 tok/s · layout-grounded with bbox coords

Formulas came through exactly right - the hard part was nailed. The graph, unfortunately, it didn't redraw. But that's the telling part: most OCR tools just dump the text and quietly drop the figure. Unlimited-OCR caught the plot, boxed it with pixel coords, and pulled it as a crop. It doesn't get redrawn, but it gets read and accounted for.

https://reddit.com/link/1ufbfe2/video/nw3mksd3uf9h1/player

reddit.com
u/Fun-Meaning-6474 — 2 months ago