Frontier models. Your Mac. No cloud.
Quadpoint AI Studio runs 27B to 290B-parameter open-weight models on a 16 GB Mac by paging expert weights straight off the SSD. One self-contained bundle per model, a Swift and Metal engine written from each model's spec, and an OpenAI-compatible server on localhost for Xcode and your agents.
Apple silicon · macOS · Swift only · every number on this page was measured on a Mac mini M4 with 16 GB.
An inference engine built for machines that are smaller than the model.
Most local-AI tools load a whole model into memory and stop at whatever fits. Quadpoint treats RAM as a cache. Weights are sliced into a single 16 KB-aligned file, mapped read-only, and demand-paged. Mixture-of-experts sparsity means a token touches a few percent of the weights, and the hot experts stay page-cached. That is the entire story of running a 30B, a 125B, or a 290B model on a Mac mini.
.QPX One file per model
Weights, tokenizer, config and provenance in one self-contained bundle with a stamped trailer. Sliced anywhere, loads byte-identically everywhere. Whole-file mmap, pointer offsets inside, 16 KB alignment on every platform.
METAL Spec-to-silicon engines
Every model family gets its own runtime, written fresh from the reference modeling file, with kernels for MXFP4, Q4, Q8, IQ3/IQ4 and F16 weights. No lane ships until its Metal logits match the CPU reference to four decimal places.
PAGING Slot arenas and router-ahead
Expert-major slabs, a bounded GPU arena with hit-tracked eviction, and a router that predicts the next layer's experts and warms their pages while the current layer computes. The bandwidth math is honest; see the hardware table below.
Two native macOS apps that share one library.
Quadpoint AI Studio
Open a bundle, prompt, generate. The Studio is the engine's home: a chat surface with streaming, a heads-up display of tokens per second and paging stats, per-model sampling and thinking controls, and a settings gear for the kernel picker and prefetch.
- Local server. OpenAI-compatible routes on localhost. Xcode's model bridge, coding agents and curl all talk to it.
- Web chat. Open the server's address in any browser on the Mac for a chat page with streaming answers, a thinking pane, a stop button and a system prompt. One switch in settings turns it off.
- Run what you generate. A play button renders generated HTML live inside the app, with JavaScript alerts bridged to native dialogs.
- Fix turns. Search-and-replace patch turns ride the cached prefix, so a fix costs tens of tokens instead of a regeneration.
- Curated catalog. Download, verify against the official SHA-256, and auto-slice to a stamped bundle on completion.
Quadpoint AI Studio Companion
A native terminal agent that drives the Studio's server. Point it at a project folder and it explains, patches, builds and repairs real Swift code through a deterministic loop that surfaces every failure in plain text.
- F5 / F6 / F7 / F9. Workspace brief, composer patch, build from the enclosing Xcode project, and send the compile errors back as a patch turn.
- Assembler rules. Build errors are matched against the Swift compiler's own diagnostic templates, and the verified fix is injected into the model's context.
- Exact patches. Search-and-replace blocks are applied atomically with a permission diff gate. No block may empty a file.
- Workspace-aware. Bare filename mentions resolve through the project tree. Applied patches compact to receipts in history.
Four steps, no quant decisions.
Customers never pick a quantization. The catalog only lists models that have run on our hardware and passed the three-probe quality gate.
Pick a model
Choose from the curated catalog. Each entry is a model, a URL, an official checksum and a slice recipe.
Download and verify
The verified queue checks the SHA-256 before anything moves into the library. Every failure is loud.
Slice to .qpx
The source is cut into one stamped bundle: experts on a 16×8 grid, trunk quantized, trailer written at birth.
Generate
Open the bundle. The tokenizer attaches, the parity check runs, and the first token streams.
Heavy hitters, each with its own lane.
A lane is a runtime, a CPU reference engine, a Metal engine and a slicer for one model family. Speeds are on the Mac mini M4 with 16 GB; a Studio with 36 to 512 GB is a different product.
| Model | Architecture | Bundle | Mac mini 16 GB | Status |
|---|---|---|---|---|
| Qwen 3.6 35B-A3B | MoE, 128 experts top-8, GDN hybrid attention | v4, Q4 · resident | 14–19 tok/s | Live |
| Qwen 3 Coder 30B | MoE, 128 experts top-8 | v4, Q4 · resident | ~15 tok/s | Live |
| Qwen 3.8 27B | Dense · self-drafting MTP depth 2 | v4, mixed-precision · resident | 11.9 tok/s | Live |
| gpt-oss 20B | MoE, harmony format, reasoning effort selector | v8, MXFP4 grid | ~19 tok/s | Live |
| Qwen 3.8 Flash Next (~125B) | MoE, 512 experts top-10, hyper-connections, sparse attention | v6, IQ4 · 87 GB, paged | 3.95 tok/s | Live |
| DeepSeek V4 Flash (~290B) | MoE, 256 experts top-6, compressed attention, lightning indexer | v11 grid · 144 GB, paged | 1.1 tok/s | Live |
| DeepSeek V4.1 Flash | MoE + Engram memory tables, FP8 trunk | v12 grid · 466 GB, paged | 0.37 tok/s | First light |
| Gemma 4 (E4B first) | Dense, per-layer embeddings | v9 grid | — | Lane written |
| GLM-5.3 Flash | MoE, DeepSeek-style hybrid | v7 · 163 GB | — | Engine shipped |
| Kimi K3 · MiniMax H3 | Queued for the next system | Queued | ||
The bigger-than-RAM models are bounded by SSD read speed on a 16 GB machine, not by compute. Their ceiling on the mini is about 2 to 3 tok/s. They exist here because the same bundle and the same code become conversational on hardware with more memory.
Measured math, not marketing.
Paging is the portable asset. VRAM versus host RAM is the same physics as RAM versus SSD, so a machine with a bigger pipe makes the same code faster. Estimates for hardware we have not run on are marked as projections.
| Tier | Memory bandwidth | DeepSeek V4 Flash | 30B-class MoE | Basis |
|---|---|---|---|---|
| Mac mini M4, 16 GB | ~120 GB/s | 1.1 tok/s (2–3 ceiling) | 14–19 tok/s | Measured |
| Mac Studio, 36 GB | ~400–550 GB/s | 3–4 tok/s | 50–80 tok/s | Projection |
| M4 Max, 128 GB | ~546 GB/s | 4–8 tok/s | ~60 tok/s | Projection |
| M3 Ultra, 512 GB | ~819 GB/s | 40–100 tok/s, fully resident | 100+ tok/s | Projection |
Parity before speed
Every lane passes a chain of logit comparisons between the Metal engine and the CPU reference before anyone looks at tokens per second. The chain reports max |Δlogit| and argmax agreement at multiple positions, deep into generation.
Quality gate
A model enters the catalog after a three-probe quality check on our hardware. Ternary experts were retired by that gate: knowledge held, generation broke. Experts stay MXFP4.
Sampling that survives quantization
Temperature and nucleus sampling over a top-K prefilter with a min-p floor, per-model configs at each model's official parameters. Greedy argmax was locking in rank-flipped tokens; sampled decoding fixed it.
One endpoint, every client.
The Studio serves the loaded model on localhost with OpenAI-compatible routes. Streaming starts with the first byte, pre-stream errors come back as JSON, and array-form message content is read directly. Xcode's model bridge and the Companion both use it, and so does curl.
- Chat and reasoner routes. The chat route runs without thinking; the reasoner route streams the model's thought channel separately.
- Prefix reuse. A prompt that shares a prefix with the last request skips straight to the new tokens.
- Honest limits. A prompt longer than the model's context returns an error instead of tripping the engine.
- One model at a time. Switching models fully unloads the previous one and clears the cache. Two big models never coexist on a 16 GB box.
- Web chat page. The server's root address serves its own chat client, so a browser on the Mac is a client too. Nothing is installed and nothing leaves the machine. The page is off by a switch in the settings gear.
curl http://127.0.0.1:8080/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{
"model": "qwen3.6-35b-a3b",
"stream": true,
"messages": [
{"role": "system", "content": "You are a Swift engineer."},
{"role": "user", "content": "Write a SwiftUI counter view."}
]
}'The port and model id are shown in the Studio's server panel. Point Xcode's model provider at the same base URL.
Get the apps.
Both apps are native macOS builds for Apple silicon, available September 30th. Install the Studio first; the Companion talks to it.
Quadpoint AI Studio
The engine, the chat surface, the local server and the model library.
Quadpoint AI Studio Companion
The terminal agent with the build-fix loop. Requires the Studio's server.
Quadpoint AI Studio is made by iSovereign Software LLC. Questions, or a machine to spec for the frontier lanes? Call 765-203-1506.
The short answers.
Does anything leave my machine?
No. The engine, the server and the Companion run locally. The only network traffic is the model download from the catalog, which is verified against the publisher's checksum.
Can I chat from a browser?
Yes. With the server running, open its address in any browser on the Mac. The page streams the answer and the model's thinking channel separately, keeps history in the browser, and has a stop button that cancels the generation. The same switch in the Studio's settings gear turns the page off while leaving the server routes up.
Why can a 290B model run on 16 GB at all?
Mixture-of-experts models activate a small fraction of their weights per token. Quadpoint stores experts as fixed-size slabs on a 16 KB grid, keeps a bounded arena of hot slabs on the GPU, and pages the rest from the SSD. The cost per token is a few hundred slab reads, which is why those lanes are SSD-bound on the mini.
Can I bring my own GGUF?
The customer flow uses the curated catalog and slices on completion. In-app slicing of a GGUF you already have is the next piece of the library, with family auto-detect, recipe flags as UI and per-layer progress.
What does the Companion actually do to my code?
It applies search-and-replace blocks the model writes, with an exact match first and a whitespace-tolerant fallback. Every application is atomic, gated by a permission diff, and reported in plain text. Failed matches, missing files and malformed blocks are shown in the transcript and fed back to the model.
Which hardware should I buy for the frontier models?
See the tier table above. A 512 GB-class Mac makes DeepSeek-scale models fully resident and conversational. A 36 to 128 GB machine makes the 30B lanes very fast and the frontier lanes usable. The mini is the proving ground.