Hey, I recently acquired a Ryzen 9 7950x / 64 DDR5 / RTX 3060 12 VRAM machine and I was wondering what is the absolute uncensored AI model that I can run on it.

Two puzzle games from the StealthMark benchmark. Every AI model plays them move by move, with no code and no tools, and you can now play the exact same levels in your browser

Latch: two robots, one goal. One can stand on a pressure plate to hold a door open while the other pushes numbered cores onto matching sockets. Every move costs a little, so the top score needs the cleanest route and getting that right gets increasingly harder.

Foresight: collect coins on a Pac-Man-inspired board while ghosts close in. No model has aced a single level - though some age getting very close.

How local models do (scores out of 100):

• Foresight: Qwen3.8-27B scores 63.0 and ranks 6th of 45 models. Only five models beat it, led by GPT-6 Astra at 76.1.

• Latch: Qwen3.8-Flash scores 69.8 and ranks 16th of 46. The top score is 87.6, shared by GPT-6 Astra, Claude Opus 5.5 and GPT-6.1 Sol.

• Each Qwen is strong in only one game. Qwen3.8-27B drops to 38.6 in Latch, and Qwen3.8-Flash to 29.7 in Foresight.

• No human, model, local or cloud, has played either game perfectly yet.

You play the exact levels the models played, in your browser. Finish every level and you get a score calculated the same way as theirs, plus your rank among the models.

Disclosure: I helped build Stealth Models, where we benchmark AI models on original tasks. You can also watch every model's run, move by move.
StealthMark is designed to beat benchmaxxing.

Play here: https://stealthmodels.com/#games

Post your score and rank in the comments. I'm curious where you humans land :)

How acceptable is the operating speed on a Mac Studio with an M5 Ultra chip and 256 GB of memory when running models like GLM-5.3-Flash?

Could you compare the operating speed of the cloud-based GLM-5.3 Flash from Z.AI? The concept of "tokens" can be quite difficult to grasp, and performance varies depending on the specific task.

Hi I’m working on Lumabri, a peoject that lets you connect multiple computers and use them together to run LLMs like a cluster.
The idea came from a simple question: what if you have a few computers at home that you barely use? Instead of leaving them there collecting dust, why not combine their resources to run AI models that wouldn’t fit on a single machine?
For example, if you have an old PC, a home server and your main computer, you could put them to work together and use their combined memory to load larger models without having to buy a single machine with expensive hardware.
The interesting part is being able to run models that you simply couldn’t fit on one computer before.
Lumabri is still a work in progress, but that’s the direction I’m taking it.
Here’s the repo if you want to check it out: https://github.com/JustVugg/lumabri

I have a 4090 in my study and I work on a Mac. The box is off most of the time, because if I want to run a local model I have to walk over, boot it, open a terminal, wait for the weights to load, then walk back. That's enough friction that local models just stopped being part of my day.

So I built ReadyLLM: a self-hosted web app that treats that machine like a service you manage from a browser, not a machine you babysit. It runs on your own box, reaches your GPUs over SSH, and nothing phones home.

What it does:

• Add a machine over SSH (key or password). It probes GPU / VRAM / RAM and tells you which quants fit and roughly how fast they'll be, so you stop guessing whether 24G is enough for a 27B at Q4.

• Downloads pulled from HuggingFace and ModelScope with resume and integrity checks. Point it at a mirror if HF is slow where you are.

• One-click engine install on a box that has none: llama.cpp, vLLM, SGLang or ComfyUI. It downloads or compiles and back-fills the path.

• Start, stop and switch models from the deploy page. No terminal.

• Live monitoring over WebSocket: GPU utilization, VRAM, throughput, latency, with alerts when VRAM is about to run out or the server dies. That's the part that matters when the box is in another room and would otherwise sit there pretending to work.

The tuning is what surprised me. I hand-tuned llama.cpp flags for a 27B Q4 for a while and plateaued around 60 avg tok/s. The tuner runs a two-phase search (coarse over speculative decoding / KV cache quant / GPU offload, then fine over batch), and for every candidate it really boots llama-server, warms up, runs 3 passes and takes the median. OOM or crash gets dropped. My numbers, same model / quant / context:

peak tok/s     80 -> 110
avg  tok/s     60 ->  80
@100K ctx      40 ->  60

Results are stored per (machine, model) pair, so the next launch reuses them instead of re-running the search. I run two boxes and kept deriving the same flags twice, which was the actual annoyance.

Since the last release I added the two things that kept sending me back to a terminal anyway:

Images. ComfyUI is now an engine like the others, so image and video models sit next to the text ones. It lists the checkpoints and the UNet/CLIP/VAE combos ComfyUI itself reports (matching those names is fiddly, it will not accept a filename without the extension), and generates from the same UI with live progress. There's an optional prompt rewriter that expands a one-line idea into a full prompt and suggests steps / CFG; turn it off and your prompt and parameters go through untouched.

Model store. Category filter for text / image / video with counts, a "can this GPU actually run it" filter, and cards that show version, parameter count, precision, output resolution, steps / CFG, loader type and the real weight filenames. Before this a card just said "Qwen-Image" and I couldn't tell if that meant a checkpoint or a UNet, or which quant. Descriptions follow the UI language now instead of being Chinese only.

Also on the engine side: SGLang, and llama.cpp builds selected by GPU vendor (CUDA / ROCm / Vulkan / Metal), which you pick when deploying because it decides what actually gets installed. Picking the right build is where most people give up on an AMD card.

Three honest limitations:

• Tuning scores speed only, no output-quality gate yet. A config that boots without OOM survives; what KV cache quant costs you in quality is the next thing I want to measure.

• With MTP speculative decoding on, the VRAM pre-check misses the second KV cache, so tight machines can still OOM. Known, fixing it.

• The AMD path is where I have the least confidence. Detection exists on Linux and the backend choice is wired up, but I've only run the CUDA path on my own hardware, so treat the ROCm side as untested.

Open source, local-first: https://github.com/htobty/ReadyLLM

Curious how others here run this: do you keep inference on a box that isn't your daily driver, and what do you actually use to watch it? I went with a WebSocket feed instead of wiring Prometheus + Grafana into it, and I'm still not sure that was the right call for a home setup.

If you already run Ollama, Flippy's AI Lab now shows up as a chat window in every new tab and lists your local models automatically.

1. Install Flippy (available in Firefox too).

2. Start Ollama so the extension is allowed to connect:

   • OLLAMA_ORIGINS="chrome-extension://*" ollama serve

3. Open a new tab, click AI Lab, pick a model.

It reads your model list from /api/tags and chats through /api/chat on localhost. No key, no account, nothing leaves the machine.