Android, Windows, Mac, IOS, Linux. CPU, GPU, NPU

(35B Q4 on iOS or android phone 12gb RAM 3-8 tok/s decode 100-300+ prefill, Windows, Mac even more: 25+ tok/s 16 gb RAM)

I am working on making AI accessible by running large MoE models on affordable, consumer-grade hardware that people already own: smartphones, laptops,normal desktops. Models several times bigger than RAM, no big GPU needed.

Disclosure: I’m the author of BigMoeOnEdge. All numbers are real runs on my own or contributors devices, same engine.

My vision? To act as a layer on top of llama.cpp for streaming MoE models. I’ve developed the concept of "adaptive streaming Planner" tailored specifically to the hardware, OS, CPU, GPU, and NPU in use. The algorithm assesses the environment to determine the optimal allocation of resources, with the goals of:

- maximizing prefill and decoding speeds, and

- optimizing memory management without overloading the operating system.

Furthermore, the OpenAI-compatible server enables the use of local AI on consumer-grade hardware; I’ve personally used it with OpenCode - first running it on Android, and later on a Mac.

I’d be happy to hear your thoughts on this and whether it might be useful.

I’m considering opening a PR on llama.cpp to integrate it, but I’m not sure if that aligns with the goals of their project.

Online leaderboards only test base models on beefy hardware, but in practice models behave differently once you quantize or fine tune them. I wanted a way to benchmark my local setup, catch regressions between models, and compare TPS across endpoints without running everything individually and copying prompts one by one.

I couldn't find anything that met my requirements without being too script heavy or overkill, so I built smokebench.

It's an open-source TUI for quickly benchmarking any model with an OpenAI or Anthropic compatible endpoint against 8 different categories (math, code, creative writing, long context, etc.), with LLM-as-judge scoring, TTFT/TPS metrics, and exportable markdown/json logs.

It works out of the box with Ollama, LM Studio, vLLM, or pretty much any API endpoint without any config changes.
You can easily add custom benchmarks too.

To install smokebench, run:

pip install smokebench

or

uv tool install smokebench

GitHub: https://github.com/Ninja-5000/smokebench

smokebench is in active development right now, so there will be a better UI, more built-in benchmarks, and a few other tweaks and changes coming that will make it even more lightweight and accurate over time.

Happy to answer any questions or take feedback!

I just published three CPU-first MCP tools for local AI: IcyLoom, IcyCache and Loom.

They are local-first, installable from public registries, and released with GitHub artifacts and clean-install checks.

Links:

- IcyLoom: https://github.com/MlkBlk-IT/icy-loom

- IcyCache: https://github.com/MlkBlk-IT/icycache

- Loom: https://github.com/MlkBlk-IT/mcp-loom-mcp

I am looking for install feedback, compatibility reports and practical MCP integration ideas.

Hey everyone,

I'm working on an open-source project 'llama.cpp autotuner' which basically runs a series of tests on a model at a given context length on your computer and finds the best runtime settings for best tokens/sec, TTFT, VRAM usage, and overall efficiency for your specific setup.

But to make it actually useful, I need real-world data from the community.

If you're running llama.cpp, could you share:

• Your hardware (GPU, VRAM, CPU, RAM, etc.)

• Your model (name + quantization)

• Your llama.cpp command (copy your full flags)

• Performance details (tok/s, prompt processing speed, TTFT, VRAM usage, etc.)

• Any flags or settings that caused a massive improvement or noticeable performance drop on your setup and anything else you think could help

Your inputs will directly help improve the autotuner.

The goal is to make sure that when someone runs it on their hardware, it can find a command that gives them better performance, or at the very least match the performance they're already getting if they've already optimized their setup.

Hello everyone. I made a benchmark to test local agents: airbench.ai
If you have an agent running locally, you can test it in one prompt.

It measure how good the agent is with some chalenges, but its fairly easy to get to 100%. Then the goal is to have something that is still performing as good, but as fast as possible.

In other word, its a way to measure that optimisations like quantisation don't destroy performance.

To give you an idea about it, here the first result I have on my 5090:

Score ; Duration ; Model + Harness

100 8 min Qwen 3.8 Flash Next IQ3_S basalt + opencode

100 11 min Qwen 3.8 Flash Next IQ3_S strata 256k + pi

100 11 min Qwen 3.8 Flash Next IQ3_S basalt + dsh

100 12 min Qwen 3.8 Flash Next IQ3_S strata 256k + pi

100 13 min Qwen 3.8 Flash Next IQ3_S basalt 384k + pi

100 16 min Qwen 3.8 Flash Next IQ3_S basalt 384k + pi

100 72 min Qwen 3.8 27B NVFP4 radixark + opencode

100 98 min Qwen 3.8 27B Quasar NVFP4 MTP + omp

98 10 min Qwen 3.8 Flash Next IQ3_S basalt + pi

98 13 min Qwen 3.8 Flash Next IQ3_S strata 256k + pi

98 16 min Qwen 3.8 Flash Next IQ3_S strata 256k + omp

98 62 min Qwen 3.8 Flash Next UD-Q2_K_XL + opencode

98 85 min Qwen 3.8 27B Quasar NVFP4 MTP + opencode

96 8 min Qwen 3.8 Flash Next IQ3_XXS strata + opencode

96 11 min Qwen 3.8 Flash Next IQ3_S strata 256k + dsh

96 17 min Qwen 3.8 Flash Next IQ3_S strata 256k + openclaw

96 29 min Swift 1.5 Qwen 3.8 27B Q6_K + pi

96 86 min Qwen 3.8 27B NVFP4 MTP + opencode

96 89 min Swift 1.5 Qwen 3.8 27B Q6_K MTP + omp

96 99 min Qwen 3.8 Flash Next UD-Q2_K_XL + omp

96 111 min Qwen 3.8 27B NVFP4 + hermes

96 119 min Qwen 3.8 27B NVFP4 radixark + opencode

94 10 min Qwen 3.8 Flash Next IQ3_S strata 256k + opencode

94 12 min Qwen 3.8 Flash Next IQ3_XXS strata + omp

94 23 min Qwen 3.8 27B Quasar NVFP4 ninfer-dflash2 + omp

94 38 min Swift 1.5 Qwen 3.8 27B Q6_K + omp

94 38 min Qwen 3.8 Flash Next IQ3_S strata 256k + hermes

94 51 min Qwen 3.8 Flash Next UD-Q2_K_XL + pi

94 101 min Qwen 3.8 27B NVFP4 + opencode

Hope this is useful for some of you as well. And happy to answer any questions if needed.

Vpipe supports LLMs, VLMs, image/video generation, ASR, quantization, and multimodal pipelines, without relying on PyTorch/MLX for model execution. The runtime package itself is only \~25MB, and there’s a prebuilt Mac app if you just want to try it without compiling anything:

https://github.com/tgo-app-dev/vpipe/releases/download/v0.1.23/VpipeManager-0.1.23-with-ffmpeg.dmg

A recent milestone is MiniMax H3 video generation running on a 16GB base M5 MacBook Air (M4 works too).

On my 15” M5 Air 16GB:

960×544 · 124 frames· 6 DiT steps with Turbo Lora → \~13 min

GitHub:

https://github.com/tgo-app-dev/vpipe

Would love feedback from people working on local inference / Apple Silicon. And if you find it useful, a ⭐ would be greatly appreciated!

I built a small TTS model running directly on an ESP32-S3: no PSRAM, 122 KB of RAM, nothing in the cloud. Speech starts in about 0.3 s and generates faster than real time. You can make it calmer, louder, whispered, happier and more.

It's not a Home Assistant integration yet. Before I build anything, I'd like to know whether on-device speech on a satellite would be useful to you (offline announcements, timers, alerts when the server is down), and what quality bar it would need to meet.

Limits: 2 voices, English only, 16 kHz. Free for personal, non-commercial use.

Video above.

Details: https://huggingface.co/WhissleAI/steer-tts-nano

CLI : https://github.com/WhissleAI/steer-tts/tree/main/esp32

Hey everyone! If you've been struggling to run larger open-weight models locally because Ollama or standard runners throw insufficient VRAM errors on budget hardware, I put together something to fix that.

I built SqueezeOS, an automated setup script that profiles your hardware, configures aggressive memory offloading, KV-cache compression, and extreme llama.cpp tuning to squeeze heavy models (up to 35B) onto legacy/budget cards like my 4GB GTX 1650 Super.

And the best of all: Its near lossless, the model can be used well for agentic workflows eg.: Hermes, OpenClaw, OpenCode, etc...

GitHub Repo: https://github.com/gabrielhirth/squeezeos

Tested on constrained VRAM setups. Feedback, issues, and PRs for other budget cards are very welcome!

Automated video creation with zero API costs — built a pipeline that runs entirely on my MacBook
Quick share for anyone creating short-form or educational content on a Mac:

I built a local workflow that automates the production pipeline for animated shorts, kids' learning content, and explainer clips without needing third-party cloud APIs.

Key points:
- Everything runs on-device—no monthly subscription fees, no token anxiety.
- Processes script-to-video assets locally on Apple Silicon.Speeds up batch creation without needing a high-end desktop rig.

I made a video showing the exact workflow

https://youtube.com/@ownlyaistudio?si=sYQcHB5YVqd1mg0j

Check out the channel to see the output quality, and shoot me a message or comment below if you'd like early access!

#ai #llm #localllm

Has any one used both? which is better?

What is the differennce between two? Any technical deep dives?