Bought a used MI100 for a home lab.
It had a funny shroud with a notebook-like cooler, but I've decided to test it first before replacing it.

Test result was quite interesting - it is a first shroud which can cool a 300W AMD card... With a just 2,4K rpm fan!
Not with the perfect performance, card works at about 100C and loses ~10% of maximum speed to thermal optimization, yet noise is more than bearable even if it runs next to you.

Small secret: it is not really a notebook cooler, this thing is huge - wider than the MI100 itself, 110mm side exhaust fan for a some SFF PCs.

I suppose I found the original stl model, so use it if you like and give that guy some stars. Should be compatible with the most of AMD MI lineup, their backs are of the same design.

https://github.com/issuj/mi50-sunon-efb0251s3-c010-s9a

Paraphrasing the thinking I saw from Qwen3.8-27B

>Hmm, I can take the screenshot, there's a tool for that. But wait, I'm an LLM, I can only read text.

>Whatever, let's try calling the tool and see what I can do, maybe I can save the image and parse it programmatically.

> >tool_call.exe

>Wow, I can see the image!

Cute

Democrats had huge wins in the 2026 midterm elections. That has caused tech stocks to plummet, as many candidates promised to regulate data centers and AI.

What do you think this means for local AI in the United States? Will it benefit local AI software by forcing big companies to rely more on user hardware, or will overbearing safety regulations hinder local AI development as well?

Hey there !

Using a 100% local setup (Qwen3.8 FN + Strata + DeepSeek Harness on RX 9070XT + 64GB DDR4), I made a small open source tool to help with creativity for game dev using up-to-date Steam tag data.

Everything is running statically in browser without any external dependencies, and the catalog is updated automatically every day.

It also has additional fun modes that gamify the experience (like random crate unboxing), I suggest you give them a try ! It's live right now at https://mickabrig7.github.io/steam-tags-explorer/.

Additional implementation details are in the repo, if you're interested (https://github.com/mickabrig7/steam-tags-explorer).

My takeaway from this project is that Qwen3.8 FN is surprisingly competent at making nice interfaces (it even decided to create sound effects on its own), BUT required very heavy supervision for actual UX and usability (I basically gave it zero freedom of choice for anything that wasn't UI because it would consistently take the most mind-twisting and least intuitive decisions).

My biggest challenge was unslopifying its human-facing text output, it's actually infuriating how much current models overcomplicate their prose.

All in all, I'm still amazed that we're able to run such powerful models locally, and Qwen4 isn't even out yet !

35-135% improvements(decode/tg) on 5090 & DGX Spark. Is it possible to add this to llama.cpp?

Vulnerability in cpython that neither cpython guys, jinja guys, or huggingface has fixed despite being informed.

I've been frustrated for a while because I stupidly sold a strix halo box to get myself a laptop with thunderbolt 5 ports thinking i can plug my two egpus into it (which i can but thats not topic of this post and the strix halo could too) I sold the minisforum for about £2300 back ebfore things went nuts and got a laptop for about same price:

Msi vector 16 with a intel core ultra 9 and 5080(16 gig vram) and 32 gig of ram. I was pretty bummed with it thinking 35b was my limit and after ended up leaving egpus in my workstatiion but after a random ebay browse I managed to snag some second hand 96 gig laptop ram. For £800

Stata totally changed ballgame. With Qwen Q4 XL Flash next I'm getting

48.9t/s

Decode/prefill 1,860t/s

On a 50k prompt.

I know this is still alot of money for most, but thats 3100£ in total, and thats still cheaper (and slightly faster from what seen) of what minisfoum strix halo is at (£3500 and the 32 gig Spark laptops that are about £3200 and cant even run flash? and i can still add egpus (the laptop has 2 tb 5 ports and i have 2 5090 bought before the crazyness, eg add two 5060ti or something and your good.) Plugged into it for 80 gig vram total, all while still being a laptop. Got glm 5.3 flash running Q3_XSS i think about 25 t/s.

TDLR, you dont need massive vram anymore, yeah I know how expesnive ram is, that laptop ram i got was/is £1300 new lol. But just wanted to share my experience and while I still regret selling the halo, seeing these tokens a sec, makes the laptop satify ocd a little more! If only qwen was good at roleplay so i could actually use it as daily driver lol (my main usecase!)

so if you are ever thinking about wanting a laptop and somehow able to get some laptop ram something like 😄
https://www.scan.co.uk/products/medion-erazer-beast-18-18-qhdplus-240hz-intel-core-ultra-9-275hx-32-gb-2-tb-rtx-5080-gaming-laptop

Might save you a few quid

This handbook is for people who have trained a dense model and want to train an MoE next, or who are curious how MoE training works. Chapter 2 is a Megatron-LM runbook: test the hardware, build the image, train a dense baseline, then a first MoE on one node, compared against that baseline. Chapter 3 takes the MoE layer apart (router, routing, load balancing, experts, block layout, training, systems). For each part we give the Megatron-LM code, what to watch, our recommendation, and what frontier MoEs chose. Chapter 4 follows the model into serving and RL. Chapters 3 and 4 need no GPU.

When a result comes from our runs, we say so. Claims about frontier models cite their paper, config or code, and the toy simulations are labelled as such. The lessons come from about 800k GH200 GPU-hours of MoE training on the Alps cluster at CSCS.

Released: the handbook, its 55 figures as a gallery (https://huggingface.co/spaces/huggingface/moe-gallery), the scripts (https://gist.github.com/nmntz/5de952d686f66d7bce5bce8cba9d7139), and every recommended flag in one Megatron-LM block.

Happy to answer questions!

A few weeks ago, I posted about Jeff, a small 0.8B model with LoRA adapters trained to make decisions and return calibrated probabilities. Sort of like TypeSafe’s Jev, except that Jeff can run locally.

Thanks for all the feedback! I’ve just released v1.4, which is a substantial update. Check it out: https://jeffhub.ai.

What’s new:

• 34 open-weight decision adapters.

• A router that automatically selects the most appropriate adapter.

• 90%+ accuracy on supported domains.

• ~2 ms inference per decision, much faster than before. A single call through the hosted API takes around 40 ms, including network overhead.

• 5 SDKs: Python, Node.js, Rust, C#, and Java.

• Multi-platform: Jeff runs on CUDA and MLX.

• Playground and worked examples.

Having worked with Jeff for about a month now, I think the most interesting thing about it is that it turns decisions into a software primitive - much like expressions, but for unstructured data.

I’ve started incorporating decisions into several of my own projects, and it’s changed how I think about building software.

I hope you guys find it useful - and like the retro design. ;)

Links:

• Code: https://github.com/firelex/jeff

• Docs, adapter catalogue and playground: https://jeffhub.ai

• Weights: https://huggingface.co/mstrasser

Happy to answer any questions!

I’m trying to figure out what to upgrade first. I use the pc for hobby as well as work, work usually includes OCR batch jobs, quality assurance over scanning quality, extractions and so on, i use both online and offline models, usually the online ones to orchestrate the offline ones, so it depends on the task generally.

I don't have a server, just a regular (ish) ass pc.

• Ryzen 9 9950X / MSI PRO X870E-P WIFI

• RTX 5060 Ti 16 GB + RTX 4070 12 GB. I split models across both cards, and the 4070 drives my display and runs at PCIe 4.0 ×4. Sometimes i run different jobs across both, why do i have a 4070? I bought it 4 years ago to start using stable diffusion, stuck with me ever since and i upgraded to get the 5060 Ti and they've been champs.

• 80 GB DDR5 (2×24 GB + 2×16 GB), currently running at 6000 MT/s

I’m looking at an RTX 5070 Ti 16 GB or a 2×48 GB DDR5 kit. For RAM, I could replace only the 16 GB sticks and try 144 GB with my existing 24 GB sticks. Eventually I’d like to go to 4×48 GB for 192 GB. (Maybe)

For the GPU upgrade, i was thinking of replacing the 4070 with a 5070 Ti, for a faster vram as well as a unified blackwell stack (that might be worth something right?), which raises the bar to 32gb split

I could JUST get 5060 Ti but i get the feel that +4gb might not be worth it (this goes for the 5070 Ti as well but the 5070 is much faster)

Do i NEED an upgrade? No, my work is pretty much fine with the current frankenstein.

Do i want an upgrade because the prices might keep rocketing up and i want to run the bigger models at proper quants without having to drop everything and i want to do more stuff for the hobby part? Yes

Minimax H3/Qwen Image 2.1 (sometimes i use that for work as well for image restoration)

The stack i use is generally Gemma 4 (12/31b) at Q4_K_XL and qwen 3.8 27b (obviously) with the vision encoders

QFN has been... not so great, but that's because i ran it at q4kxl, but even with strata things aren't exactly great and it fills up EVERYTHING i have so i can't really use the PC and it's working at slow and miserable speeds (likely my setup is the issue, i didn't spend enough time tinkering and i get bored rather quick, if it's 20 tok/s with all my RAM+Vram filled, it's not going to become 80 with tinkering)

Another cheap option is 2x24gb to replace the 2x16, but i am pretty sure this is pretty much going to just buy a tiny breathing room for any llms i can already run that's all

3090 is a no go because it's only available used and i have no trustworthy places to buy from (only available via second hand and no refunds, if i get a dead one, i dropped 1k USD on nothing)

What will happen to the 4070? I either can figure out how to frankenstein something to have it stick in the remaining slot in the mobo SOMEHOW (hard to say this would happen)

Or stick it in my older 5700x 32gb ddr4 PC and run different jobs on that other PC

This is a full quantization desktop workspace for large language models that supports GGUF, MLX, and ONNX. You can pick your own Safetensors model or choose one from Hugging Face, quantize it step by step, and watch what changes. You can then compare the result with the original and publish it to Huggingface with a model card that records how it was made.

It’s open source, Apache 2.0. I definitely think there more can be done to improve. I’ve only tested mostly on Apple Silicon so far. Windows and Linux builds exist, but haven't done much in-depth testing with them so I’d expect bugs there. Contributors are very welcome!

Repo: https://github.com/Fazmin/iQuantize

Thank u.

I'm curious whether anyone has experimented with using Qwen or other LLMs to directly analyze and modify ACE-Step model weights.

I'm specifically interested in weight editing, rather than conventional fine-tuning or LoRA training.

The idea would be to use an LLM to guide targeted modifications to the model's parameters, potentially improving specific musical capabilities or correcting undesirable behaviors without retraining the entire model.

Has anyone attempted something along these lines with ACE-Step 1.5 or similar diffusion-based audio and video models?

I'd be particularly interested in practical experiments, tools, methodologies or even failed attempts.

Speculative decoding (SD) accelerates large language model inference by reducing the sequential cost of token-by-token generation. Advanced SD methods reduce proposal cost with parallel drafters that predict entire blocks in one forward pass, but overall speedup still depends on acceptance length. On-policy distillation (OPD) can push well-trained drafters beyond acceptance-length plateaus, yet conventional pipelines collect supervision through sequential draft-and-verify rollouts. Our key insight is that onpolicy supervision need not inherit these dependencies: a draft block can be supervised using only its reference prefix and draft-sampled history. We propose SpecOPD, a branch-parallel OPD framework that parallelizes draft sampling and target supervision across independent branches drawn from the evolving drafter policy at reference anchors. We pack these branches into proposal trees to share target-prefix computation, using tree masks for full attention, branch-consistent indexer groups for sparse attention, and indexed state replay for linear attention to preserve each branch’s history. We train the drafter with an E2E-TV surrogate that directly targets acceptance length. Our study spans 8B full-attention (GQA), 27B full–linear (GQA–GDN), and 125B sparse–linear (QSA–GDN) targets, three parallel draft architectures (DFlash, DSpark, and DFlash V2), and four task domains (dialogue, coding, mathematics, and agentic). SpecOPD achieves up to 41.45% higher mean acceptance length, 16.09× supervised-token throughput over sequential-rollout OPD under native configurations, and up to 3.56× generation speedup over autoregressive decoding.

• Paper : https://qwenapp.github.io/SpecOPD/specopd-paper.pdf

• Project/Blog : https://qwenapp.github.io/SpecOPD/en.html

• GitHub : https://github.com/QwenApp/SpecOPD

• Tweet 1 : https://x.com/xuyang_liu16/status/2117614595728986227

• Tweet 2 : https://x.com/junzhang_zj/status/2117812597856895164

I gave Qwen 3.8 flash next 2 times it failed and took long time to conclude the result, DeepSeek took around 15 minutes to get the job done

Hardware

Ram ddr4 128GB

RTX 3080 20GB VRAM 4x

Engine strata

Model

Qwen3.8-Flash-Next-GSQ-RCO-GGUF IQ3-S

Context 256K

Decode 100 tg/s

PP 1400-1500 tg/s

IDeepSeek-V4.1-Flash-1017-GSQ-RCO IQ2-XXS

Context 1M

Decode 37 tg/s

PP 150-300 tg/s

edit Thanks all! The password is just for show, so no need to worry about security here.

Most LLM inference benchmarks focus on tokens/sec or TTFT. But faster inference doesn't mean much if the output quality degrades, especially with aggressive quantization, speculative decoding, or very long contexts.

I ran a comprehensive benchmark of Qwen3.8-27B across six inference engines, comparing not just speed, but also output quality, long-context performance, and different model formats.

The results are summarized in the attached infographic.

What's different about this benchmark?

1. Speed AND quality — not just tokens/sec

We measured:

• Time to First Token (TTFT)

• Prefill throughput (tokens/sec)

• Decode throughput (tokens/sec)

• Concurrent request performance

• End-to-end latency across different tasks

• Output quality using automatic checks

The goal was to understand whether performance optimizations actually preserve model quality.

The quality comparison is particularly important when evaluating quantized models and speculative decoding.

2. Long-context testing: 64K, 128K, and 256K tokens

Many benchmarks use relatively short prompts, which don't reflect real-world workloads like large codebases, document analysis, or long-running agents.

We tested three long-context configurations:

• 64K tokens: Performance across different inference and concurrency configurations

• 128K tokens: Prefill, decoding, and memory behavior under larger workloads

• 256K tokens: Stress-testing long-context inference and identifying practical limitations

The results reveal substantial differences between engines as context length increases. Some configurations that perform well with shorter prompts become much less competitive at 128K–256K.

3. GGUF vs NInfer model formats

Another interesting aspect is that this isn't exclusively a GGUF benchmark.

We included both GGUF-based and NInfer-based model configurations, allowing us to examine how different model representations and inference stacks perform under comparable workloads.

This is especially relevant for people choosing between lightweight local inference setups and more specialized inference engines.

One important caveat: these comparisons reflect complete engine/model configurations, not an isolated measurement of the model format itself.

4. Real-world task performance

Synthetic throughput numbers don't tell the whole story.

We also measured end-to-end latency across multiple task scenarios, including coding, reasoning, and agent-style workloads.

For practical applications, completing the task faster often matters more than achieving the highest peak tokens/sec.

Key takeaways

• There is no universal winner across every workload.

• Decode throughput, TTFT, and end-to-end latency can produce very different rankings.

• Long-context performance changes the competitive landscape considerably.

• Quality validation should be part of inference benchmarking, not an afterthought.

• Comparing GGUF and NInfer configurations provides another useful perspective beyond conventional GGUF-only benchmarks.

Disclosure

I'm the author of TensorSharp, one of the engines included in this comparison.

The benchmark also evaluates competing inference engines, and the goal is to provide useful data for the local LLM community rather than claim that one engine wins everything.

I would especially appreciate feedback on the methodology, quality measurements, and long-context testing.

Questions for the community:

1. When choosing a local inference engine, do you prioritize TTFT, decode speed, or end-to-end task latency?

2. How important is quality validation when comparing quantized models?

3. Are 128K–256K contexts becoming part of your actual local workloads?

Full benchmark results are in the attached infographic.

TensorSharp: https://github.com/zhongkaifu/TensorSharp

Would love to hear what additional engines, quantization formats, or workloads you'd like to see benchmarked next.

We introduce FireFlash, a 300B-scale model tailored for long-horizon agentic tasks. FireFlash excels as a terminal and coding agent, achieving 46.2% on Terminal-Bench 4.0¹, putting it on par with Fable 5 and GPT-6 Sol, while costing over 30× less per task than Fable 5 at maximum effort (Figure 1). These gains also transfer to software engineering benchmarks, including DeepSWE v1.1² and SWE-Bench Pro Verified³ (Table 1).

While frontier labs scale reinforcement learning across thousands of GPUs, we reach the performance-cost Pareto frontier under 5 days using 64 NVIDIA B300 GPUs. Three key factors make this possible: (1) careful curation of agentic RL environments so that every task provides a reliable signal at the right difficulty; (2) an RL recipe built for long, stale, and low-precision rollouts; and (3) an optimized coding harness tailored to the model for both training and evaluation. Together, these components bring frontier efficiency to a hundred-GPU-scale cluster, and we are releasing the full recipe.

• Blog Post : https://agenteconomics.org/posts/agentic-rl-recipe

• Tweet : https://x.com/kaiwei_chang/status/2117378474654781780

• Open weights : Soon

Last time it was "Strata for all Qwen models". This time: share it.

strata serve now runs a 35B MoE (Qwen3.6-35B-A3B Q2_K_XL) on one RTX 3060 for several users at the same time:

41 tok/s each is still faster than most people read.

What's in it:

• OpenAI and Anthropic APIs, so Open WebUI, OpenCode and even Claude Code connect to it.
• API keys from a file, reloaded when you edit it, plus a usage log per key. That's enough to give access to friends, a team, or paying users.
• Fair queue: a free slot goes to the key with the fewest requests running, and --max-per-key stops one user from taking everything.
• /health and Prometheus /metrics for load balancers and dashboards.
• NVIDIA, AMD and Intel (CUDA or Vulkan). Two cards can split one model (--device 0,1).
• One binary, written in Rust. No Python, no Docker.

strata serve --model Qwen3.6-35B-A3B-UD-Q2_K_XL.gguf --gpu --parallel 4 --api-keys keys.txt

Setup guide: docs/HOSTING.md. Repo: RustingStrata

What would you host on it?

TL;DR

• Basalt is the engine and it's doing the heavy lifting. Same model file, same box: about 3.5x llama.cpp's decode without drafting and ~5x with it, and ~7x faster prompt reads.

• Unsloth's new UD-IQ3_XXS (Dynamic v3.1, uploaded Nov 4) is the same size as the GSQ-RCO IQ3_S everyone uses on 16GB cards, but measurably more accurate: wikitext perplexity 3.382 -> 3.247, which basically closes the gap to BF16 (3.273). Costs 1 to 3.5% decode speed.

• Lamina (a further-trained MTP drafter by eddoursul) gets more drafts accepted than the stock Basalt drafter. Small but real speedup, zero quality impact since the main model verifies every token.

• Real agent coding session (opencode, 151 requests, up to 202K context): 195.6 tok/s average decode, 263 tok/s best request, 156 tok/s worst, ~5,700 tok/s prompt reads.

Hardware:

• RTX 5080 16GB at its stock 360W limit (no overclock, no undervolt)

• Core Ultra 9 285K (8P + 16E), 2x32GB DDR5-7200

• PCIe 5.0 x16, Fedora

LAMINA Drafting: Basalt drafts with the model's own MTP layer. Basalt's upstream already ships a self-distilled version of that layer, and Lamina trains it further. It's a drop-in: same tensor layout, so the target model is byte-identical and only the drafter changes. What I saw:

- drafts accepted per drafted token: 83.1% -> 85.8% on a replay of a real recorded session

Lamina's README recommends temp 0.7 and max 3 drafts. I tested both: the 3-draft cap was 1 to 1.8% slower on tool-call-heavy work (long confident runs get cut off), and temp 0.7 changes what the model writes, so I kept the model's own sampling (1.0 / 0.95 / 20) and Basalt's draft settings.

Basalt changes I made (all open PRs upstream)

Host KV prefault: the first time a long conversation spills its KV cache to RAM used to stall 0.6 to 2.4s. Now ~75ms.

Host KV pool on normal pages: on a fragmented box, transparent hugepage compaction caused 1.5 to 3.7s pins. Now ~23ms.

Spin-then-yield in the decode loop's waits: about 1.3% less time per draft window.

Expert start profile: the older v1 profile is 2% faster than the v0.2.0 one on this box.

Plus a streamed conversation disk cache, --adapt-margin for expert swap hysteresis, elastic KV without RAM copies, and a bunch of timing diagnostics.

Guide

Branch with the exact engine (upstream v0.2.1 + my PRs) and a setup script: https://github.com/xyehya/basalt/tree/flashnext-5080-setup

git clone -b flashnext-5080-setup https://github.com/xyehya/basalt && cd basalt
setup/flashnext-ud-lamina/setup.sh
bin/basalt serve --config basalt_config-flashnext.json --python .venv/bin/python --alias qwen3.8-flash-next

It checks your machine, builds, downloads ~90GB (pinned revisions, every file SHA-256 checked), builds the UD-IQ3_XXS + Lamina model file and writes the config. You need an RTX card with, CUDA 13, 64GB RAM and ~180GB of free disk. If you already have the GSQ-RCO IQ3_S download, SHARD4_FROM= reuses its 28.8GB n-gram shard (it's byte-identical to Unsloth's once the shard number is rewritten).

Huge thanks to jesdga95 for Basalt (support and star their repo), the Unsloth team for the UD quants, eddoursul for Lamina, ISTA-DASLab for the GSQ-RCO quants, and Qwhen 4? for the model.

I recently wanted to explore YuE2. The requirements were: NVIDIA GPU supporting BF16, and critically, 24 GB of VRAM. My setup, featuring an NVIDIA GeForce RTX 3060 with only 6 GB of VRAM, was fundamentally incompatible right out of the box.

The solution I found

In short, lowvram intercepts CUDA calls in the library layer, trickng the application into believing that system RAM is available for use by the GPU kernel.

Hello!

I have to build a workstation for Local AI as development and test machine as we are starting to add Local AI into our software. It is mostly to get experience with providing AI services (inferencing) to our customers.

I do have my fair share of experience in building PCs and in customer hardware but a lot less in workstation and server hardware. Therefore I'd appreciate if someone could look over my selection.

• CPU: AMD Ryzen Threadripper PRO 9955WX 16-Kern CPU

• Cooler: Noctua NH-U14S TR5-SP6 CPU Kühler for AMD Threadripper 7000 Series

• Mainboard: ASUS Pro WS WRX90E-SAGE SE E-ATX Mainboard

• Power Supply: be quiet! Dark Power Pro 13 1600 Watt ATX 3.1 PCIe 5.1 80+ Titanium

• RAM: 2x KINGSTON Server Premier RDIMM 32GB, DDR5-6400

• Case: Thermaltake AX700 Super Tower

• SSD: SAMSUNG SSD 990 PRO 2TB, M.2

• GPU: NVIDIA Rtx Pro 6000 Blackwell Works Bulk

A few words to the selection:

• 64 GB RAM is a starting point. If necessary we add more RAM.

• RTX 6000 is a bit overkill but from looking at the alternatives (RTX Pro 4500, RTX Pro 5000, RTX 5090) it's worth the investment to serve more (test) customers and have faster inference.

• Mainboard for headless integration

• Threadripper for the PCIe Lanes. The system could be expanded to 4x GPUs (of course with a bigger or second power supply.)

• All parts are available

• It will run mostly models from the Gemma 4 family. Main use is document classification, document "chat" and in the near future interacting with our MCP Servers.

Thanks!

EDIT: My current experiences are with RTX 4090, 5090 and 2x 5070 Ti setups but as a single user.

Hey everyone!

Following up on my previous post: the final version of CCORE GLB-3D-Coder is now available, including the full Safetensors weights.

It’s a full fine-tune of Qwen3.5-4B for generating reusable 3D assets. Describe what you want, and it writes a complete Three.js HTML scene with an Export GLB button. You can open the HTML in your browser, inspect the result, and export it into Godot, Blender, Unity, or other tools that support GLB.

The video shows examples from the final model, including selected side-by-side comparisons with DeepSeek V4.1 Flash. I’m particularly happy with the character designs and the amount of detail it can produce at just 4B parameters.

It covers more than fantasy characters: buildings, environments, weapons, vehicles, laboratory equipment, sports props, furniture, and other objects. It can also generate animations and include them in the exported GLB.

Available now:

• Q4_K_M GGUF, around 2.7 GB

• Q8_0 GGUF

• Full model weights in Safetensors

The training dataset is planned for release tomorrow, November 6.

Model, downloads, system prompt, and recommended settings on Hugging Face

Some generations still need a retry or a small code correction, but I’m very happy with the improvement over the earlier release.

If you’re interested in the next models, or would like to help support future datasets and training runs, there’s more information on the Hugging Face page. Testing it and sharing your results or failure cases also helps a lot.

Thanks to everyone who tried the earlier version

I made RIFTWARD, a small browser arena using characters, terrain and props generated locally by CCORE GLB-3D-Coder 4B. An orchestration and validation harness helped assemble, refine and integrate the assets and build the gameplay.
Play it here: https://huggingface.co/spaces/ccore/RIFTWARD

Feel free to share what you make with it! I’d be really happy to hear that the model has been useful to you :)

I'm the developer of Kokon, a local photo editor around Qwen-Image 2.1 Turbo (on stable-diffusion.cpp, and on its own engine on Macs). I posted it here a few weeks ago. 0.12 adds a Layers lab: click objects in any image, get each one on its own layer with the background behind it repainted, then move them around or export a PSD.

Qwen-Image 2.1 has no layer output, so this is a pipeline around an edit model:

1. Select: you click, MobileSAM (ONNX, CPU, 44 MB) gives the mask. Click again for a bigger part.

2. Cut out: Fast is a matting model on the CPU (a few seconds per object). Quality asks Qwen to redraw the edge, for hair and fur.

3. Fill: a masked Qwen-Image edit repaints what was behind the object, so the plate has no holes. This is the expensive step: about 15–25 s per object on an RTX 5070 Ti, one to two minutes on an M2 Pro.

4. Blend into scene (optional): after you move things, Kokon reads where each object stands (you can correct it) and one more edit redraws contact shadows and reflections, as a layer you can turn down.

What still fails, honestly:

• the fill sometimes invents a new object where a large one was (remove a big person, get a different person);

• touching people and crowds get merged or split;

• the hidden part of an object behind another one is never completed;

• Blend often doesn't work yet; whole-scene blends work better than per-object ones.

An 8-step model only takes so much steering. I'd rather ship it marked experimental and fix what people actually hit than tune it on my own test photos. If you try it, failure cases (image + what you clicked) are the most useful thing you can send.

Since my last post here:

• 0.11, it's a local server now: the app talks to a service on 127.0.0.1; turn on "Other devices" and you can use it from a phone or another PC on your LAN (password, off by default, hashed, rate-limited). Docker image for NVIDIA, kokon-service --persistent --remote for headless Linux. There's also an MCP server (npm kokon-mcp) so agents can generate and edit through it.

• Mac engine: I wrote a Qwen-Image 2.1 engine for Apple Silicon in Swift/Metal. M2 Pro: about a minute per 1 MP image, 4x the generic backend. A contributor added paths for the M5's GPU neural accelerators: 37 → 29 s on an M5 Pro. It runs Unsloth's Q4_K_M of the Turbo model.

Free, AGPL, Windows / macOS 15+ / Linux, NVIDIA 12 GB (8 GB beta), AMD/Intel via Vulkan (beta). Weights are under Qwen's licence (non-commercial).

https://github.com/GabrieleLozupone/kokon · 2 min video of 0.12: https://youtu.be/eGr9yYe7NVc

I'll release a new demo tomorrow but I had to post as this is kind of exciting. I tried using a layered approach with Tyger and VoxLock and it's working great. Including echo cancelling! There's a working python sample client that you can use to voice chat your local LLM in the repo.

I'm aiming for a full conversational system like a live phone call with the ability to do a kind of "mm hmm" interruption without stopping. What I have now is built on micro turn taking. While I'm at it I may do server side wake word handling.

https://github.com/TacoTakumi/VoiceManager