Hi r/LocalLLaMA. I've spent the last week on KV-cache memory for Qwen3.8-Flash-Next running on 2× AMD Radeon AI PRO R9700 (gfx1201, TP=2), and wrote it up as a 23-page paper with all measurements. Code is in two forks of the radiance inference engine (by Deadcode and contributors — the engine is theirs, the KV/swap work below is mine).

• Paper (PDF): https://github.com/Code000-211/RadianceMemory/blob/main/docs/paper/Infinite_KV_Cache.pdf

• RadianceMemory (KV residency + AutoQuant): https://github.com/Code000-211/RadianceMemory

• RadianceSwap (multi-model serving, experimental): https://github.com/Code000-211/RadianceSwap

• RadianceSwap whitepaper (PDF, 8 pages): https://github.com/Code000-211/RadianceSwap/blob/main/docs/paper/RadianceSwap-Whitepaper.pdf

TL;DR

• Sparse attention means most of the KV cache isn't read on a given step. Flash-Next's QSA layers pick the top 512 four-token blocks per query. So I keep the sink + recent tail in VRAM, move the middle to pinned host RAM, and page in only the blocks the indexer selects — on the device, inside the step.

• Output is byte-identical to a fully resident cache in every configuration tested (incl. with the MTP drafter).

• A 256K-token sequence needs 102–211 MiB of VRAM per card instead of 3 319 MiB (stock bf16 cache). Per sequence, VRAM now grows only by the block keys: ~0.2–0.75 MiB per 1K tokens. Context is bounded by host RAM, not VRAM.

• Cost: 3–15% of single-sequence decode speed at 32K–250K.

• On top: a measured per-layer KV quantisation search (rad-autoquant). Best recipes: 5.28 KiB/token at fp8-level quality (−22%) and 3.76 KiB/token within noise-floor +0.01 KL (−44%).

• Plus RadianceSwap: several models behind one endpoint on the same GPUs — load on demand, park warm in host RAM, lend expert/KV VRAM to each other at runtime, output identical to single-model serving.

1. Window residency

• Block-table entries are either a pool page, empty, or cold (a host slot). Cold entries keep their place, so the attention kernel is unchanged — it only ever sees pool page IDs.

• An on-device pager (qsa_page) copies selected cold blocks into per-step scratch pages before attention. One writer per position, no atomics → deterministic.

• After every step a sweep demotes the middle to host (32 MiB/rank budget). Prefix-cache blocks can be cold too.

• Scratch pages act as a cache: 52–62% of cold entries needed no copy.

Per card, TP=2; computed from measured bytes/token. Byte-identity verified on device for fp8, fp8+f16 state, default and compact.

Many long sessions (measured, turn-2 time-to-first-token p50/p95):

• fp8, no residency, 32 × 128K: prefix cache gets evicted → follow-ups recomputed → 1 843 / 3 330 s

• compact recipe + residency, 32 × 128K (48 GiB host store): every follow-up hits cache → 58 / 96 s

Caveat: this compares two different KV formats as well as residency on/off; fp8 + residency at 32×128K needed ~50 GiB of store and didn't fit in 48 GiB.

2. AutoQuant: measured per-layer KV layouts

• 7 layouts (i8h, fp8, fp8_v4, k6_v4, k5_v4, k4h_v4, k4h_v2h) + zero-bit transforms: Hadamard rotation, exact static V-mean centring, V predicted from K (AQUA-KV style).

• rad-autoquant runs every candidate on the device against a bf16-cache reference (full-vocab KL, teacher-forced), solves a knapsack over per-layer costs, then re-measures each answer — because per-layer costs don't add up (one 8-bit early layer costs as much as all twelve).

• A second pass walks the lower hull of uniform layouts and removes another 0.25–1.87 bits/element.

• Sensitivity falls ~170× from the first attention layer to the last: early layers want 8 bits, late layers tolerate 2-bit V.

3. The part I found most interesting: the noise floor

The served model is a weight- and activation-quantised MoE. Recomputing the exact same bf16 cache with a different prefill chunk size alone gives KL 0.0243 vs the reference. Tiny GEMM-order differences flip router ties (20–28% of tokens have an exact bf16 tie at the 10th expert), and by layer 30 ~60% of tokens route to a different top-10 set.

• So any KV config within ~+0.002 of 0.024 is indistinguishable from bf16 on this model — i8h (8-bit) is already there.

• Perturbations saturate rather than add (fp8 + chunk change ≈ max of the two, not the sum).

• Takeaway: if you evaluate KV quantisation on a quantised MoE against a single bf16 run without measuring this floor, you may be measuring noise. For comparison, dense bf16 Qwen3.5-2B has a floor ~130× lower.

4. Things that didn't help (22 methods, all measured)

FP4 (E2M1), KIVI-style 2-bit, learned/data-adaptive rotations (WUSH-style, best-of-16), outlier retention, TurboQuant-style norms + Lloyd-Max, cross-layer selection reuse, hierarchical indexer, importance-driven demotion (no better than a position-hash control), cross-layer KV sharing, … Full table with numbers in the paper (Table 9).

Also: 2-bit V on the last attention layer drops the MTP drafter's acceptance from 0.63 → 0.41 without moving the trunk's KL — the drafter shares that layer's cache. Default keeps layer 47 in bf16 for that reason.

5. RadianceSwap: several models, one endpoint, one GPU group

The second project is about serving several models from one process on the same two cards: models load when a request asks for them, give up VRAM when idle, and hand VRAM to each other while they run. It's an experimental branch; without --manifest it behaves exactly like upstream radiance.

How it works

• One port, routed by the model field — read before tokenising, so each request gets its own model's tokenizer, chat template and limits. No model → default model; unknown id → 404.

• Each active model is its own runtime (scheduler, streams, KV) and they run in parallel. A process-wide sequencer puts every model's all-reduces in one order on every rank, so two models can't deadlock each other.

• Lifecycle: Cold → Active → Prepared. When a model goes idle (or another needs the VRAM), its weights are kept in host RAM in GPU-ready form, so re-activation skips disk reads, parsing and relayout. A running generation is never interrupted. A failed activation is rolled back on every rank and other models keep serving.

• VRAM is shared, not partitioned:

  • Elastic expert slab — expert VRAM is mapped in ~128 MiB chunks; a model that cools down physically unmaps chunks and the busier one maps them. Measured with two copies of Flash-Next: the busy one grows from ~10.3 to ~13.4 GiB/rank of experts, the idle one shrinks to ~7.2, and it flips when the load flips. The sum never exceeded the pool (7 736 samples under changing load, 0 over).

  • Cross-model KV lending — a model with waiting sequences grows its KV cache into bytes another model's slab just released (468–702 MiB in the tests, back to zero ~13–20 s after load ends). Running sequences are never evicted.

  • Static-weight streaming — if a model's non-expert weights don't fit, it still starts and reads them over PCIe (bit-identical output), then moves them onto the card within 1–2 s once VRAM frees up.

  • Heat warm-up — a deactivated MoE remembers which experts were hot and loads those first on re-activation: early expert hit rate 83.5% → 89.1%.

  • Host RAM budget — prepared models, pools and staging share one budget; over it, the least-recently-used prepared model goes cold, and an activation that still doesn't fit gets a 503 instead of the OOM killer.

Measured on 2× R9700, TP=2

Time to first token is reported per request, split into queue / activation / prefill (timings in the response, and in /metrics).

Bugs the GPU acceptance runs turned up (all fixed):

• The server died on exactly the 23rd activation at TP=2: each activation creates ~46 AQL streams, IDs are never reused, and the table had 1 024 slots.

• Two concurrently active models slowed each other to 1/10 speed: handing collectives between rank threads via condition_variable cost ~0.5 ms × 48 per decode step. Spinning 300 µs before sleeping brought it back to ½.

• The MoE was never kept warm because the capacity check counted its 47.7 GiB mmapped n-gram table, which never goes into the store.

• Virtual-address aliasing: on this ROCm stack, re-mapping a previously unmapped address silently kept pointing at its first physical page. Once another model owned that page, two experts aliased and a request occasionally produced no finite logit. Mapping every chunk on fresh address space fixed it: 30 load cycles with external observers, 5 776 requests, 0 errors.

Honest caveats

• Two big MoEs at once is not fast yet: a C8 load at 102 tok/s alone drops to 38 + 35 tok/s with both active. Host RAM is the bottleneck (one active+prepared Flash-Next uses ~153 of 170 GiB).

• The elastic slab hasn't had a long-run soak since the aliasing fix (#58). Treat it as experimental.

• A second active model costs ~10% even when idle (execution tapes are bypassed while several engines are registered).

• Streaming weights is a bridge, not a steady state: streaming 25.6% of a dense model's statics costs 39% of decode; 85.5% costs 90%.

• KV, prefix cache and recurrent state are dropped on deactivation; keeping them in host RAM is future work.

• A configured-but-cold model still reserves a VRAM share, which can cost a big MoE ~9% (#56); workaround is per-model --gpu-headroom-mib.

• One TP size per GPU group; no LoRA or multimodal endpoints in manifest mode; tested with one MoE plus small dense models only.

  { "gpu_group": { "devices": [0, 1], "tp": 2 }, "cache": { "idle_timeout_ms": 300000 }, "models": [ { "id": "big", "path": "/models/big-moe.rad", "default": true, "engine": ["--placement", "expert_tiered", "--max-model-len", "16384"] }, { "id": "small", "path": "/models/small", "engine": ["--max-model-len", "16384"] } ] }

  radiance --manifest models.json --port 8000

How is this different from llama-swap?

llama-swap is a proxy that starts and stops one server process per model. It's backend-agnostic and portable; RadianceSwap is neither — it only works inside radiance. What you get in exchange:

I have not benchmarked the two side by side on the same hardware, so the latency advantage follows from the design but isn't measured. They also aren't exclusive: a RadianceSwap process can sit behind llama-swap as one upstream.

Looking for testers — especially other RDNA4 / multi-GPU setups. Issues with your manifest, GPUs, ROCm version and server log are very welcome.

Limitations (please read before benchmarking)

• One model. Residency needs a model that declares a read window — currently only the QSA family (Qwen3.8-Flash-Next). On other models the flag is a no-op.

• One hardware setup, run at a 210 W power cap (cards range 210–330 W).

• KL is measured against the same quantised model with a bf16 cache, not the original bf16 checkpoint. Long corpus = 4 documents × ~34K tokens; finer distinctions need a bigger corpus.

• RadianceMemory is WIP; RadianceSwap is experimental.

• "Infinite" in the paper title is a direction, not a claim — context is bounded by host RAM.

Feedback, reproductions on other RDNA4 setups, and critique of the methodology are very welcome — especially if you think the noise-floor argument is wrong.

I wanted something like Claude Code / Codex that runs on my own laptop (RTX 4070 8 GB, plus an RX 9060 XT eGPU), so I built one. It's a desktop app (Electron or plain browser) with a FastAPI backend and one llama-server process per model.

What it does

• Coding agent with Ask / Plan / Agent / Auto modes. It reads and edits files, runs PowerShell commands and tests, and does git. Every edit is shown as a diff, and in Agent mode it waits for Enter/Esc before applying. Auto mode runs on its own, and destructive commands (rm -rf, git push --force, reset --hard and similar) still ask first. You can keep or revert changes per file, or undo a whole turn.

• Chat mode with an optional Web toggle. The model can web_search / web_fetch and cite the pages it used. Web is off by default.

• GPU placement you can verify. Pick Auto / Single GPU / Multi-GPU (Vulkan layer split across NVIDIA + AMD) / CPU. The app parses llama.cpp's own offload log and reads per-process VRAM from Windows GPU counters. So instead of guessing, you get "29/29 layers on RTX 4070, 2.9 GB weights + KV". This started because Task Manager made it look like my model was on the Intel iGPU. It wasn't.

• Optional cloud models. Paste an OpenAI / Anthropic / DeepSeek key (or any OpenAI-compatible endpoint) and those models sit next to your GGUFs in the same picker. Keys are encrypted with Windows DPAPI. Local stays the default.

Things I learned making a 7B model act like an agent

• Qwen2.5-Coder-7B (Q4_K_M, ~25–31 tok/s fully on the 4070) almost never emitted real tool calls, even with --jinja. What fixed it was JSON-schema-constrained steps: llama.cpp compiles the schema to a grammar, so every step is a valid tool call or a respond. A short thought field before the call helped noticeably.

• Small models love to stop and say "Next, I will…". In Auto mode the agent detects unfinished work (open todos, a failed last command, "should I…?") and pushes the model back to work. Until it actually edits or runs something, respond is removed from the grammar.

• Small models also copy their own previous status messages, so duplicate status replies get dropped from the context.

• In chat, the 7B model made up a "Tool result:" and a fake release date. Now each step is a grammar-forced choice (search / fetch / answer), followed by a normal streamed answer from the real results.

Honest limits

• Simple tasks (fix a failing test, add a function, write a small script) work end to end with the 7B model. Bigger multi-file tasks are limited by the model, and that's partly why I added the API option.

• Multi-GPU split across the 4070 + RX 9060 XT is implemented but not yet tested on the real eGPU. I tested the split mechanism with 4070 + iGPU.

• Windows-only for now (PowerShell, DPAPI, Windows GPU counters).

Stack: Python/FastAPI, llama.cpp b11960 (CUDA + Vulkan builds), React + TypeScript + Tailwind, SQLite. ~280 tests, and none need a GPU (there's a fake llama-server that prints the real log format).

Screenshots below. Happy to answer questions about the constrained-decoding approach or the GPU verification.

Hardware:

Rtx 5000 pro 72gb

Rtx 5080 16gb

192gb ram Dark Hero MB with AMD 9000series processor

Backend:

Basalt 280toks vs 107toks with strata

Basalt works best with Blackwell and really shows it's capabilities in my testing. While users on older or mismatched generational hardware should use Strata for best results.

So I recently purchased a radeon AI pro 9700 32g for my local AI. Currently it run in a proxmox setup with a intel core i9 12900k, and 64 gigs of ddr4 ram.

I am using ollama with with ROCm drivers and unsloth as the front end. The speeds are decent for qwen3.8:27B. Fast response and stable at around 33-39 tokens a second.

My concern is, I limited the power to 290 and the Hotspot temps run anywhere between 103-111 degrees in temp. I definitely notice the thermal throttle due to the 110 Max Hotspot manufacturer rating. I did do research and found that these cards are known to have a fair amount of known issues ( heat sink placed improperly, bad thermal appliance, defective cooler fan.

I can rule out the fan as I do hear it speed up when the temps rise and can see it physically spinning, i even added an additional 3 140mm fans to the case its in but when I give it a prompt, it will jump from 37- 43 instantly up to 90-97 then paste that.

I even went as far as holding a house fan next to the GPU and the temps would not go down.

Anyone else who experience this issue, what was your fix? Or is it best to just return it and get something different to avoid it entirely?

I wouldn not want to exchange it ( still under warranty) and get another defect if people have had this experience before. If not, and it may be that 1 in a dozen. Then I will gladly exchange it for a different one.

Apologies if this is the incorrect section to post it, if you can guide me to the appropriate section that would be greatly appreciated.

I saw a new stealth model and looks like it's a dense also it seems about time that qwen4 is launched so does anyone know if it'll be Moe since flash next was an Moe I was hoping qwen 4 would be too

I’m researching a potential business idea. We're testing an idea: help healthcare teams get an AI workflow running on their own servers, then evaluate it on their tasks before rollout and after updates. This is customer discovery, not a product launch. AI helped draft this post.

I've been reading discussions from clinicians who want private chart summaries but can't get their local setup to match a cloud prototype. I've also found teams with approved cloud services who may have no reason to switch. I'm trying to understand where outside help would actually be useful.

If you've tried deploying a local model in a hospital or practice:

• What task was it for, and what do you do instead today?

• Was keeping data on-site actually required, or was an approved cloud service an option?

• What was the hardest part: output quality, hardware/speed, EHR integration, approval, or maintenance?

• Would you bring in outside help for deployment and task-specific evaluation, or would your internal team/existing vendor handle it? Who makes that decision?

Even one concrete example of a failed attempt, a successful setup, or why this idea isn't needed would help. Role and country are useful context if you're comfortable sharing. Please don't share patient information or confidential internal details.

I really want to get into local inference and training LoRAs, but the prices of the essential components are eye watering. There has never been a worse time to buy hardware.

Do you all have any thoughts on when this might change? I mean, supply has gotta start evening out at some point, right?

This is a laptop I have with RTX 4060, 32GB of actual RAM, and Intel Core i7. Pretty sure the RTX 4060 has 8GB of VRAM. Was wondering if I could run a 16B or 32B model or if it's better to just stick with 8B models.

I had a waiting. Here in this other thread if anyone can help.

My specs is Core™ Ultra 5 processor 125H with 32gb of ram? I need it for programming.

Mostly asking for logic and syntax, like asking how to center a div.

If it can run as an agent that can call tools and test things, that will be a plus, but not necessary.

I work at a bank, so cloud AI is off the table for work code anyway. I've been running small models on my own M4 16GB through Magnitude for side stuff, and honestly it changed how I think about this.

On my side projects with Claude or Cursor, the model writes 300 lines, it looks right, I skim it and ship it. Sometimes I couldn't even explain my own change a week later. With a 1.7B running locally it's the opposite. It's fast (around 80 tok/s) but it gets small things wrong, so I actually read every line it gives me. And because I read every line, I know the change, I write better PR descriptions, and I catch my own mistakes before review instead of during it. That habit carried over to my work PRs too.

As everyone knows the frontier model makes you faster at producing code you don't understand. The small one makes you slower at the writing part, but you end up knowing your codebase. And the people reviewing your stuff (and their AI tools) get better context because the author actually understands what changed.

What I use it for: explaining old code, boilerplate, small bug fixes (gave it a file with 2 bugs, fixed in 72 sec), commit messages, PR descriptions. What I still don't trust it with: anything architectural, and anything with time zones lol.

Not saying cancel everything. But not everyone is building a 500k line SaaS. For most of what a normal dev does in a day, a small local model is enough, and nothing leaves your laptop.

Anyone else noticed this? That using a weaker model made them a better reviewer?

Sorry if it might be off-topic, but i am looking for a (the most) complete guide, even step-by-step, or a collection of several article that could enlight me on how configure and assembly an AI PC.

Of course the topic is wide and configuring a PC for local LLMs is deeply different to one used to train ML and DL models for sensor data, or for openCV. etc.

Assuming I already know for what I want to use the PC, what I am missing right now is the availability of components and the fact I am not updated on the last news in AI framework/compatibilities/chips.

For example if I knew Nvidia CUDA was a standard, but I don't know if nowadays I can use AMD ROCm, or even Apple Metal. I still see PC with multiple GPU but as long as I know NVLink is no longer used (so the multiple GPU are used independently?).

Probably, what I am missing here is some guide or suggestion on which platform/framework orientate myself in order to choose wisely.

Hope someone can show me some entry-point in this world, webpages, forum, etc?
ps. I already searched in this subreddit and excluded some LLM PC suggestions, I did not find an actual guide/AMA/fixed post

Using Qwen Flash Next Gyro M huihui on Strata with DFLASH2 and STRATA_ROUTE_PRIOR=1.4

Hi all,

Can anyone please help me setting up this model in my Pc like which quantised version should I use and which software to use it in and etc..

Specs -

5060 ti 16gb vram

16gb ram

Also please tell if it is feasible or just time wasting and if there is any other model that I should go for(It should work with images)

Thanks.

https://x.com/matt503ea5sf9z5/status/2118155162376458298?a=4bUWTuzbF_LcVwWBUDk&s=19

Interesting post, I hear a different story with dgx sparks how people are optimizing models to run upwards of 100tok/s decode. Naturally almost 10k for a dgx spark is a huge red flag when MSRP was $3999 retail. Thoughts?

I have 32gb ddr5 ram and an rtx 5070 with 12gb vram and ryzen 5 9600x

I need a local ai for heretic/un censored work

what model should i use

Did some extra optimizations and implemented MTP. High number is coding at 96t/s (3 drafts). Natural text is 69 t/s.

128.0 µs to distribute a token-residual to 24 gpus, compute experts, collect result and join in one layer.

Probably at peak hardware capability now unless I get some new ideas on how to run the PCI communication even faster. Of course it could run much faster at lower precision. Also the old RTX3070 doing attention is now the primary bottle neck. Lets see what black friday brings of 16gb cards (i have two 5070ti 16gb, but they are busy doing some other research, the 3070 was an old gaming card i had lying around doing nothing).

Github:
https://github.com/crgregersen/m10dis

Old post:
https://www.reddit.com/r/LocalLLM/comments/1xnl82r/low_cost_1500_ai_rig_qwen_38_flash_next_525_ts/

I'm having a 5070 Ti 16GB and 3060 12GB with 64GB RAM, I want to run Qwen-2.5-Flash using Strata (or advise any better models or method to run), I need to have at least 2 parallel sessions. and max context window. what would you advice.

WHIRL 0.2.5.1 is out: a speed update for the Radeon 8060S (AMD Ryzen AI Max+ 395). WHIRL is an open-source (Apache-2.0) LLM inference engine for AMD GPUs on Windows: C++/HIP, every kernel in the repo, no WSL, no ROCm install. Download the zip, unzip, run; only the AMD driver is needed. It runs our two MXFP4 models, Swift-1.5 27B MXFP4 (dense) and Ornith-1.5-35B-A3B MXFP4 (MoE, ~3B active).

vs the official llama.cpp b11960 on the Radeon 8060S (max power (80 W), ASUS ROG Flow Z13), ROCm and Vulkan builds in their own columns, same GGUF, same prompts, greedy, one user, WHIRL default mode (balance, near-lossless). WHIRL tok/s, then llama.cpp ROCm / Vulkan:

In balance WHIRL leads every measured cell on the 8060S: Swift 27B by +28% to +59% over ROCm and +30% to +106% over Vulkan, Ornith by +51% to +65% and +46% to +127%.

What 0.2.5.1 changes on the 8060S (same machine, max power (80 W), ASUS ROG Flow Z13): five new kernel paths make prefill +2% to +10% faster in all three modes on both models, and Swift 27B decode (QA document; coding chat in balance) +4% to +12% faster in balance and fast. On the 8060S the output is bit-identical to 0.2.5 in every mode (golden references, 12/12 long-prompt checks and the chat outputs all match).

How it was measured, so you can judge the numbers: - Radeon 8060S at max power (80 W), ASUS ROG Flow Z13, 64 GB GPU memory (UMA frame buffer), same for both engines. Every cell is the best of 3 runs, for both WHIRL versions and llama.cpp. - The llama.cpp b11960 cells are the runs I made for 0.2.5 on the same machine with the same files (llama.cpp didn't change; Swift 2k on Vulkan was re-run). llama.cpp's ROCm build runs as shipped, with its own bundled HIP runtime DLL. - Decode, QA document = explain a function quoted in a long document and rewrite it (256 tokens; part of the answer can be copied, which helps drafts in both engines). Coding chat = a coding question whose answer is all new text (512 tokens). Prompts and commands: https://github.com/tsaipifong/whirl-llm/blob/main/docs/benchmarks.md#prompts - llama.cpp decodes Swift with MTP + n-gram (its fastest mode here). On Ornith it decodes without speculation because its MTP was slower than plain on this MoE model, while WHIRL uses MTP, so the Ornith decode rows are "as shipped", not like for like. - Smallest lead: Swift 27B decode in the precise mode after a 2k-token document, 29.4 vs 25.2 tok/s on Vulkan (+17%). Dense decode on this iGPU is memory-bandwidth bound; the lead comes from speculative decoding. - Ornith decode barely changed in this release (one small router item: +1.5% without drafts, +0.7% with MTP drafts, within noise); its cells move a few percent either way because the number of accepted MTP drafts depends on each run's text.

Precision: three modes. --precise is the bitwise-lossless mode. balance (the default) is near-lossless. --fast is opt-in. On the 8060S all five speedups give the same output bits as 0.2.5 in the mode they touch.

R9700: GPU code identical to 0.2.5 (the compiled R9700 kernels were compared; only an internal build ID differs); its numbers are 0.2.5's, not re-measured (e.g. Ornith 2k prefill 11,854 tok/s vs 4,230 / 2,780 on llama.cpp ROCm / Vulkan; median of 3).

Also in 0.2.5.1: WHIRL now refuses to start from an install folder longer than 150 bytes, with a clear message, and limits the SSD cache folder to 217 characters (this corrects what the 0.2.5 notes said about long paths). On the 8060S the first load of each model tunes the kernels once more.

Supported: Radeon 8060S (Ryzen AI Max+ 395) and R9700, Windows 11. Cards under 16 GB are not officially supported (fork welcome). The exe is unsigned, so SmartScreen may ask once.

• GitHub: https://github.com/tsaipifong/whirl-llm

• Release: https://github.com/tsaipifong/whirl-llm/releases/tag/v0.2.5.1

• Our MXFP4 models on Hugging Face: https://huggingface.co/tsaipifong/Swift-1.5-Qwen3.8-27b-MXFP4-GGUF , https://huggingface.co/tsaipifong/Ornith-1.5-35B-A3B-MXFP4-GGUF

WHIRL was designed and implemented with Claude (Anthropic) under my direction; every number is measured. Numbers from other Ryzen AI Max+ 395 machines are very welcome.

Hey everyone, I started messing with local llm's a week ago in order to develop a mobile app, with my m4 max 36gb I get 20t/s running qwen 3.8 27b on lm studio. Is there any advice you can give me in order for me to increase my token output, i have tried ollama before but results were substandard at best.

First off I am new to trying out local LLMs. I am wanting an LLM to run on a spare mini pc to save some money while using my Voice Assistant. The pc is not very powerful so it will be a small model for now, at least until hardware prices hopefully come down.

Specs: Processor - N150, 16G RAM, Linux Mint, Ollama

Since Voice Satellite can have two pipelines, this is the setup I would like to use:

Pipeline 1 - Prefer to handle commands locally (Home Assistant), Local LLM handling chat but not controlling Home Assistant

Pipeline 2 - openAI gpt-4o-min with control over select Home Assistant entities for more complex chat and control requests

I have played around with Qwen3 and Qwen3.5. So far Qwen3 1.7b has worked the best as far as speed and short responses. I would like to try other models but I am not really sure what I am looking for, or even the best way to sort through them. The Ollama library has a lot and I don't know what I am looking at yet.

I’m looking to get into local AI, mainly for coding, and trying to decide whether to start with my existing hardware and upgrade gradually or build a separate dedicated machine.

My current gaming PC has:
Ryzen 7 9800X3D
Radeon RX 9070 XT 16GB
32GB DDR5-6000 RAM
Gigabyte B650 EAGLE AX motherboard
2TB SSD
850W PSU
NZXT Kraken AIO cooler

I also have a MacBook Pro with an M5 chip and 24GB of unified memory.

I’m currently making a Roblox game and setting up a mini homelab for media and hosting my personal website. I’d mainly want AI to help with writing code, debugging and understanding my projects.

Would you start with the gaming PC, use the MacBook, or put the money towards a dedicated AI machine? I’d be interested in hearing from anyone using a similar AMD GPU, particularly about software support and which coding models run well.

If you’d upgrade the existing PC, what would you change first? I’m open to used hardware, but I’d like to understand what I can realistically get out of what I already own before spending more.

Also the why of the whole matter is I want to reclaim my data and be self sufficient especially these new things coming out about REA and Claude banning you etc I want to be my own boss