> ## Content Index
> Fetch the complete content index at: https://blog.binarius.ca/llms.txt
> Use this file to discover other available public pages before exploring further.

# Going fully local: running AI on my average machine (Macbook Air M3 16GB) with LM Studio
- URL: https://blog.binarius.ca/going-fully-local-running-ai-on-my-average-machine-macbook-air-m3-16gb-with-lm-studio/
- Published: 2026-07-28T16:16:37.000Z
- Updated: 2026-07-28T16:16:38.000Z
- Author: Ricky Sohal

As you already know, I use Claude for most of my day-to-day be it coding, admin, client work, all of it. But not everything I want to run through an LLM is something I'm comfortable sending to someone else's servers. Client contracts, personal notes, anything with financial details, half-formed business ideas I'm not ready to share — some of it I just want to keep on my own machine.

For a long time, "run it locally" meant a rough setup, a model that felt noticeably dumber than what you're used to, and enough friction that most people gave up before they got anything useful out of it.

That's changed recently. Local models have gotten good enough to be genuinely useful, not just a novelty, and the tooling around them, specifically LM Studio, has gotten easy enough that I can point a non-technical person at it and they'll have a model running in ten minutes.

Here's the whole setup: what LM Studio is, how to install it, and two very different ways to actually use it depending on whether you write code or not.

**What "fully local" actually means**

No API calls, no cloud, nothing leaving your laptop. The model file sits on your hard drive, and when you send it a prompt, your own CPU/GPU does the work and hands you back a response. There's no internet connection required once the model is downloaded.

The tradeoff is real: a model that fits on a laptop is smaller than what's running behind Claude or GPT, so don't expect the same ceiling. But for a lot of day-to-day use like drafting, summarizing, brainstorming, coding on smaller tasks, it's closer than people expect, and it's free and private after the initial setup.

**What you need — a heads up on hardware**

I run this on a 16GB MacBook Air. That's a normal, not-souped-up machine, and it's enough to comfortably run models in the 7B–14B parameter range at usable speed. More RAM gets you bigger models with better reasoning, but 16GB is a completely fine place to start, and it's probably the machine most of you reading this already own.

The three models I actually keep loaded and reach for:

- **Gemma 3 12B QAT** — my go-to general-purpose model. The QAT (quantization-aware training) version is built specifically to stay sharp at a smaller file size, so you get noticeably better quality per GB than a standard quant of a similarly sized model.
- **Qwen 3.5 9B** — my other daily driver. Slightly smaller than the Gemma model, very capable, and a good pick if you want something a touch faster.
- **Nemotron Nano 4B** — smaller and less capable on raw reasoning, but on 16GB of unified memory, context length is often the thing you're actually short on, not model quality. A smaller model like this leaves a lot more memory headroom for a longer context window, which matters if you're feeding it longer documents or long conversations.

![](https://blog.binarius.ca/content/images/2026/07/Screenshot-2026-07-27-at-10.02.34---PM.png)

That last point is worth sitting with if you're on 16GB specifically: memory is shared between the model weights and the context window, so a bigger model eats into how much conversation or document you can actually hand it. If you find yourself running out of context with the bigger models, dropping to something like Nemotron Nano 4B is a real trade worth making.

Worth setting expectations on speed too. On the 16GB Air, Gemma 3 12B QAT and Qwen 3.5 9B both take roughly 10–12 seconds just to start processing a prompt before they even begin responding, and then generate at around 10–12 tokens per second — noticeably slower than what you're used to from Claude or GPT. Nemotron Nano 4B is a good chunk quicker on both counts, which is why it's the one I reach for when I've got a well-defined task or just want a quick back-and-forth chat, and I save the two bigger models for when I actually need the extra reasoning and don't mind the wait.

Quick note on Windows: LM Studio supports Windows the same way it supports Mac, and if you've got an NVIDIA GPU in that machine, you'll actually see faster generation than Apple Silicon does. The setup steps below are basically identical on Windows — download, install, open, download a model. I'm going to stay focused on Mac for the rest of this, since that's what I actually use, but don't let that stop you if you're on Windows.

**Step by step: installing LM Studio on Mac**

1. Go to [lmstudio.ai](https://lmstudio.ai/?ref=blog.binarius.ca) and download the Mac version. It'll detect Apple Silicon automatically.
2. Open the downloaded file and drag LM Studio into your Applications folder like any other Mac app.
3. Launch it. You'll land on the home screen with a search bar at the top — this is the model browser.
4. Search for a model. If you want to skip straight to what I actually use: Gemma 3 12B QAT or Qwen 3.5 9B are both strong general-purpose picks that run well on 16GB. If you want more context length for longer documents or conversations at the cost of some raw capability, Nemotron Nano 4B is worth grabbing too. Look for a quantization label like Q4\_K\_M — that's a compressed version that trades a small amount of quality for a much smaller file size and faster speed.
5. Click download. Model files are a few GB, so give it a few minutes depending on your connection.
6. Once it's downloaded, click the chat icon on the left sidebar, select your model from the dropdown at the top, and load it.
7. Type a message and hit enter. That's it — you're now talking to a model running entirely on your own machine, no internet required from this point on.

That's the whole install. Everything past this point is about what you actually do with it.

**Use case #1 — for non-technical people: using it from your phone**

The problem with the setup above is that it's stuck on your laptop. You have to be sitting at it to use the model, which isn't how most people actually want to use an assistant day to day.

LM Studio recently added a feature called LM Link, paired with a companion phone app called Locally, that lets you reach the model running on your Mac from your phone. Your laptop does all the actual work; your phone is just the screen and keyboard. The connection is end-to-end encrypted, and your chat history stays on your own devices rather than sitting on someone's server — which is the whole point of this exercise.

One honest caveat: at launch, LM Link's Locally app is iPhone and iPad only, and both devices need to be signed into the same LM Studio account. If you're on Android, the straightforward path right now is turning on LM Studio's local server (Developer tab → Start Server, then check "Serve on Local Network") and reaching it from your phone's browser over the same Wi-Fi — it's a bit more manual, but it works, and there are also third-party Android apps built specifically to auto-discover LM Studio on your network if you want something closer to a native app feel.

For iPhone/iPad users, the steps are:

1. Update LM Studio on your Mac to the latest version and sign in with an LM Studio account.
2. Download Locally from the App Store on your iPhone or iPad, and sign into the same account.
3. With your Mac awake and LM Studio open, the app should discover it automatically and let you pick a model to chat with — the same one loaded on your laptop.
4. From there, it works like any chat app, except every response is coming from your own hardware, not a cloud provider.

![](https://blog.binarius.ca/content/images/2026/07/image.png)

Where this is genuinely useful for non-technical people: journaling and personal notes you don't want in a cloud chat history, drafting messages you're not ready to send anywhere yet, working through sensitive personal or financial questions, or just wanting an assistant on your phone with zero subscription and zero data leaving your house.

**Use case #2 — for coders: using it inside your actual dev workflow**

If you write code, a separate chat window isn't where you want this. You want the local model wired into the tool you're already coding in. Two solid options, depending on whether you live in a terminal or in VS Code.

*Option A: Opencode CLI*

![](https://blog.binarius.ca/content/images/2026/07/Screenshot-2026-07-27-at-9.57.35---PM.png)

Opencode is a terminal-based AI coding agent, similar in spirit to Claude Code, that supports pointing at any OpenAI-compatible endpoint — including your local LM Studio server.

1. In LM Studio, load a coding-capable model and start the local server from the Developer tab. Qwen 3.5 9B or Gemma 3 12B QAT (the same models I use for general chat) both handle code reasonably well, or you can grab a dedicated coding variant like Qwen Coder if you want something tuned specifically for it. By default the server runs at `http://127.0.0.1:1234`.
2. Install Opencode (via npm or Homebrew, depending on your setup).
3. In your project folder, add or edit `opencode.json` with a provider block pointing at your LM Studio server, something like:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "lmstudio": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "LM Studio (local)",
      "options": {
        "baseURL": "http://127.0.0.1:1234/v1"
      },
      "models": {
        "qwen2.5-coder-14b": {
          "name": "Qwen 2.5 Coder 14b (local)"
        }
      }
    }
  }
}

```

1. Run `opencode` in your project directory, then use `/model` inside the session to switch to your local model.

Worth knowing: a genuinely large model over a local link can feel slow for real coding work, so this tends to work best for smaller tasks — quick refactors, explaining a function, writing a script — rather than driving a whole feature end to end in one go.

That said, the bigger models can do real work on bigger projects too, just not the way you'd drive Claude Code. The move is to break the project into phases yourself upfront — planning documents, task lists, one phase at a time — and then have the model work through them one at a time rather than handing it the whole project and hoping. This puts more work on you at the front end, and it leans on your own judgment as a developer to actually scope the phases sensibly and catch it when it drifts. But it's a completely workable way to get real output out of a local model on something bigger than a single function.

*Option B: Continue extension in VS Code*

![](https://blog.binarius.ca/content/images/2026/07/Screenshot-2026-07-27-at-10.01.12---PM.png)

Continue is a VS Code extension that plugs an LLM directly into your editor for chat, inline edits, and autocomplete.

1. Install Continue from the VS Code extensions marketplace.
2. With LM Studio's local server running (same Developer tab → Start Server step as above), open Continue's sidebar and go to its config file — accessible via the gear icon next to your agent/model selector.
3. Add a model entry pointing at your LM Studio server:

```yaml
name: Local Config
version: 1.0.0
schema: v1
models:
  - name: Local Coder
    provider: lmstudio
    model: qwen2.5-coder-14b
    apiBase: http://localhost:1234/v1
    roles:
      - chat
      - edit
      - apply

```

1. Save, and the model shows up in Continue's model dropdown right inside VS Code.

One thing to get right if you're setting up autocomplete specifically: use a small, fill-in-the-middle-capable model for that role (1.5B–3B range) rather than your bigger chat model — autocomplete needs to respond in well under half a second, and a large general model will feel laggy and won't understand the fill-in-the-middle format properly anyway. Keep the bigger model for chat and edits.

**What I've learned from setting this up**

It's not a replacement for Claude in my day-to-day — the quality gap for anything genuinely hard is still real, and I'm not pretending otherwise. But for the slice of work where privacy matters more than raw capability, this is a legitimate option now in a way it wasn't a year ago.

Start with the plain LM Studio chat before you touch the coding integrations. Get comfortable with loading and swapping models first — it'll save you time when you get to the config files.

For non-technical folks, the phone access is the part that actually changes how you use it day to day. A local model stuck on your laptop mostly stays unused; one you can reach from your phone gets used.

And the honest version: some of this is still rough around the edges, especially the mobile side if you're on Android. But the direction is right, and it costs nothing but a bit of setup time to have a private assistant that never leaves your hardware.