The stack at a glance

A local coding assistant has two pieces: a model server that runs the LLM on your hardware, and an editor integration that feeds it your code and shows you suggestions. This guide uses Ollama for the server and Qwen 3.6-35B-A3B for the model: Alibaba’s Apache 2.0 mixture-of-experts model, the LLMCheck index’s best pick for a Mac with 32 GB or less (Score 81, tied at the top of the index with MiMo-V2.6-Flash, which is listed first on the alphabetical tie-break and needs a 192 GB Mac Studio), with 73.4% on SWE-bench Verified (vendor-reported).[1]

It has 35B parameters but reads only about 3B per token, which is why it is fast: community59 tok/s community-measured on a 32 GB Mac mini M6 and community130 tok/s on an M5 Max. If you prefer quality over speed on the same memory, the dense Qwen3.8-27B (the index’s strongest dense model by capability) fits too, at community31 tok/s on an M5 Max but only community10 tok/s on the Mac mini M6. For the editor, you have three good choices, and this guide covers all of them: Continue.dev (VS Code), Zed (native Mac editor with built-in AI), and Cursor (pointed at a custom endpoint).

EditorBest forOffline?
Continue.devDeepest local-model control in VS CodeFully local
ZedFast native editor, least setupFully local
CursorAlready a Cursor userMostly (some cloud features)

Step 1: Hardware Check

Pick the model by unified memory. Check yours under Apple menu → About This Mac → Memory, and leave room for your editor and the code context you feed the model.

Buying a Mac for local coding? 32 GB is the sweet spot: it runs the index’s best small coding models with room for context. Our Mac hardware buying hub ranks configurations by real-world tok/s per dollar so you don't overspend on memory you won't use — or under-buy and stall.

Step 2: Install Ollama & Pull a Coding Model

Install Ollama with Homebrew or the Mac app (full walkthrough in the Install Ollama on Mac guide). Version 0.40.16 is current as of 14 November 2026; since 0.40.0 it runs models its MLX runtime supports on MLX by default on Apple Silicon. Then pull the model for your tier:

brew install ollama            # or: brew install --cask ollama-app
ollama pull qwen3.6:35b-a3b    # 32 GB Macs
ollama pull north-mini-code-1.0    # 24 GB Macs
ollama pull hf.co/JetBrains/Mellum2.1-12B-A2.5B-Thinking-GGUF:MXFP4_MOE    # 16 GB Macs

Ollama’s default context window is 4,096 tokens (Ollama FAQ), too small for an assistant that reads whole files. Start the server with a larger one; if you use the Mac app, set the variable with launchctl setenv and restart the app instead:

ollama list                                  # should show your model
OLLAMA_CONTEXT_LENGTH=32768 ollama serve     # API at http://localhost:11434

Ollama normally runs its server automatically in the background, so ollama serve is only needed if the API isn't already up. You can do a quick smoke test:

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"qwen3.6:35b-a3b","messages":[{"role":"user","content":"Write a Python one-liner to flatten a nested list."}]}'

Step 3: Install Continue.dev (or Zed / Cursor)

Pick the editor that fits how you work. The rest of this guide uses Continue.dev as the primary path because it offers the most control, with Zed and Cursor notes alongside.

Continue.dev (VS Code)

Open VS Code, go to the Extensions panel (Cmd+Shift+X), search for Continue, and click Install. A Continue icon appears in your sidebar. It also works in JetBrains IDEs via their plugin marketplace.

Zed

Download Zed from zed.dev. AI is built in — no extension needed. You'll configure its Ollama provider in the next step.

Cursor

If you already use Cursor, you can keep it and point it at your local model. Open Settings → Models, enable a custom OpenAI-compatible base URL, and you'll wire it up in Step 4.

Step 4: Point the Extension at Your Local Model

Continue.dev config

Open the Continue config (click the gear in the Continue sidebar, or edit ~/.continue/config.yaml) and add the model for chat, edit and apply:

models:
  - name: Qwen 3.6 (local)
    provider: ollama
    model: qwen3.6:35b-a3b
    apiBase: http://localhost:11434
    roles:
      - chat
      - edit
      - apply

Save the file. Continue picks up the change immediately — you'll see "Qwen 3.6 (local)" in the model dropdown. Tab autocomplete uses a separate model in the autocomplete role; a small fill-in-the-middle model keeps it responsive, so check Continue’s documentation for its current recommendation rather than pointing autocomplete at a 35B model.

Zed config

Zed finds the models Ollama has pulled on its own: open the agent panel and choose qwen3.6:35b-a3b from the model dropdown. To point it at a specific Ollama server, add this to settings.json (Cmd+,), as in Zed’s local-model docs:

{
  "language_models": {
    "ollama": {
      "api_url": "http://localhost:11434"
    }
  }
}

Cursor config

In Cursor's Settings → Models, add a custom model with the OpenAI-compatible base URL pointing at Ollama:

Base URL:  http://localhost:11434/v1
API Key:   ollama        (any non-empty string works locally)
Model:     qwen3.6:35b-a3b

Heads-up on Cursor: some Cursor features (like its tab autocomplete and indexing) still route through Cursor's cloud even with a custom model. For a guaranteed fully-offline assistant, prefer Continue.dev or Zed.

Step 5: Use It — Autocomplete, Chat & Agent Mode

With the model wired in, you now have a full coding assistant running on-device. Three things to try:

A good first prompt to feel it out, with a file open:

Refactor this function to use early returns and add a docstring.
Then write a pytest test that covers the edge cases.

Everything here runs through your local Ollama server — no network calls, no data sent to any vendor, and it keeps working on a plane or behind a firewall.

Tip: For autocomplete that stays snappy, pair a small fast model for tab completion with the larger model for chat and agent mode. Continue.dev lets you assign different models per role, as shown in Step 4.

Step 6: Tips & Scaling Beyond Your Mac

Give it more context on bigger Macs

The more of your codebase the model can see, the better its edits. On 32 GB+ Macs, raise the context window so it can hold larger files and more surrounding code. With Ollama you can bake a larger window into a custom model:

# Modelfile
FROM qwen3.6:35b-a3b
PARAMETER num_ctx 32768
ollama create qwen3.6-32k -f Modelfile
# then reference qwen3.6-32k in your editor config

On a 24 GB Mac, keep context moderate (8K–16K) so the model doesn't swap and slow down. With 64 GB, Alibaba’s coding-only qwen3-coder-next (a 52 GB download; 70.6% SWE-bench Verified on SWE-Agent, vendor-reported) becomes an option, at estimated~49 tok/s estimated on a 64 GB Mac mini M5 Pro.

When you need a coder bigger than your Mac

Some 2026 frontier coders — DeepSeek V4 Pro, Kimi K3 — are simply too large for any Mac's unified memory. When a hard task outruns what your local model can do, the practical option is to rent a GPU by the hour and run the big model there, keeping the same Ollama/OpenAI-compatible workflow — just point your editor at the remote endpoint instead of localhost.

A cost-effective place to do this is Vast.ai, a marketplace for on-demand GPUs where an H100 or 80GB card runs a few dollars an hour — far cheaper than buying hardware for an occasional frontier-model task.

Disclosure: the Vast.ai link is a referral; if you sign up through it, LLMCheck may earn a small credit at no extra cost to you. We only recommend it because renting beats buying for occasional big-model jobs.

You're set. You now have a private coding assistant — autocomplete, chat, and agent edits — running entirely on your Mac, with a clear path to rent extra horsepower only when you actually need it.