AXOlotlvaNschmozelot/run-open-weights-locally

Run your first local open-weights model in 5 minutes

Part 3 of The Open-Weights Lifecycle — acquire → verify → run → maintain → retire.

You've acquired a model (Part 1) and worked out which quant fits your machine (Part 2). Now the fun part: actually running it — on your own hardware, offline, no API key, no monthly bill.

The surprise most people don't expect: you don't need a big GPU, or any GPU at all. A mainstream laptop runs small models comfortably on the CPU alone. Here's the whole thing, start to finish.

The 5-minute path (Ollama)

1. Install Ollama — one installer from the official site. It's code-signed; if you like to be careful, confirm the publisher is Ollama Inc. before running it.
2. Open a new terminal window. This trips everyone up exactly once: a terminal you already had open before installing won't recognise the ollama command yet — the command only appears in terminals opened after the install. Close the old one, open a fresh one.
3. Run a model:

   ollama run llama3.2:1b
   

   The first run downloads the model once (~1 GB), then you get a >>> prompt. Type a question, read the answer, type /bye to leave.

That's genuinely it. No Python, no CUDA, no config files.

Terminal or the app — two ways in, and how to close each

There are two ways to talk to a local model, and it's worth knowing both — including how to shut each one down cleanly, which isn't obvious the first time.

• Terminal — ollama run <model>, as above. Leave a chat with /bye. The model stays in memory for a few idle minutes in case you come back, then unloads on its own. ollama ps shows what's currently loaded; ollama stop <model> frees that RAM immediately if you want it back now.
• The app — the Ollama window you get from the desktop icon. Same models, a friendlier chat box. It lists whatever you've already downloaded, so open it after pulling a model (or reopen it to refresh the list). There is no per-model "stop" button — the app loads and unloads for you, which is why you won't find one. Closing the window with the X is fine; the model unloads when idle. To shut the whole thing down, including the small background helper, right-click the Ollama icon in the system tray (bottom-right by the clock, possibly hidden under the ^ arrow) and choose Quit.

Under the hood both are the same local engine — neither sends anything anywhere. Pick whichever you prefer.

What it actually feels like on a modest laptop

I ran this on an ordinary ~8 GB-RAM ultrabook with a low-power Intel "U"-class CPU and no dedicated GPU — the kind of machine millions of people already own. Same prompt, two model sizes:

Model	Generation speed	Size on disk
Llama 3.2 1B	~14 tokens/sec	1.3 GB
Llama 3.2 3B	~7 tokens/sec	2.0 GB

Fourteen tokens per second is faster than most people read — a 1B model is genuinely pleasant for chat on a plain laptop. The 3B is slower but perfectly fine when you're not in a hurry.

A rule of thumb you can extrapolate from

Notice the pattern: 3× the parameters ≈ half the speed — not a third. CPU inference is limited by memory bandwidth, not raw compute, so speed degrades more slowly than the parameter count grows. From those two measured points you can estimate the rest of the ladder:

• ~0.5B → ~25+ tok/s (instant)
• 1B → ~14 tok/s
• 3B → ~7 tok/s
• 7–8B → ~3–4 tok/s (if it fits in RAM)

Your mileage varies with the CPU, but the shape of the curve holds on any CPU-only machine.

And the other direction, as a one-line takeaway from that same curve: a genuinely large frontier-class open model is simply a different weight class — you'd be looking at a workstation with many tens of gigabytes of memory, or a real GPU, not a thin laptop. That's a rough conclusion, not a spec sheet; for a specific model-and-machine pairing, the Part 2 calculator gets you closer — but it too is a calibrated estimate, a rule of thumb rather than a guarantee. The only truly real number is the one your own machine gives you when you run it.

Measure it yourself

Don't take my two numbers on faith — get your own in about ten seconds. Add --verbose and Ollama prints the timing after every reply:

ollama run llama3.2:1b --verbose

Ask it anything, and underneath the answer you'll see a few lines like:

load duration:        4.2 s
prompt eval rate:     55 tokens/s
eval rate:            14.2 tokens/s

The one that matters is eval rate — that's the generation speed, how fast the model writes its answer. (load duration above it is the one-time cost of loading the model into RAM on the first reply; prompt eval rate is how fast it reads your question.) Run the same short prompt on two different model sizes and you've reproduced the table above for your own hardware.

That is exactly how the numbers here were taken — nothing fancier: the same one-sentence prompt on each model, on a ~8 GB CPU-only laptop, each model unloaded afterwards (--keepalive 0) so the two runs couldn't interfere with each other. The load times you see will depend on how much free RAM you have at that moment; the eval rate is the stable figure to compare.

The one real constraint: RAM

On an 8 GB machine the ceiling is memory, not the processor. The weights have to fit in RAM — there's no GPU to offload to:

• A 1B needs roughly 1–1.5 GB while running, a 3B about 2–2.5 GB.
• Close your browser first. A browser with a dozen tabs can eat 3–4 GB; on 8 GB that's the whole difference between a model loading in a couple of seconds and grinding through disk swap. (In my 3B run, loading took 10 seconds because I'd left barely any RAM free — the generation speed itself is hardly affected, but the wait to start is.)
• The operating system reclaims cached memory to make room, so "fits" is a little more forgiving than the raw free-memory number suggests — but don't lean on it. Use Part 2's calculator to pick a quant that leaves headroom.
• Done for now? The model unloads from RAM after a few idle minutes on its own; ollama stop <model> frees it immediately.

"It fits" ≠ "it's fast." A model can load and still crawl if you're sitting right at the memory limit. Leave headroom, and prefer a smaller model or a smaller quant over squeezing.

Is this safe for my laptop?

Yes. Running a model is ordinary CPU-and-RAM work — like exporting a video or compiling a large project. The chip throttles itself long before it overheats, and the OS ends a process before memory truly runs out. The worst case is temporary sluggishness, cleared instantly with Ctrl+C or by closing the terminal. No hardware is ever at risk. Two small habits: run on AC power (a pegged CPU drains the battery fast), and keep the vents clear — the fan will spin up, and that's completely normal.

It runs offline — and that's the whole point

Internet is needed exactly twice, once each: to install Ollama, and to download each model the first time (ollama run <model> pulls it, ~1 GB). After that — nothing. The weights sit on your own disk and the maths happens on your CPU, so you can switch on airplane mode and the model still answers. No API key, no account, no server; your prompts go nowhere and no data leaves the machine.

(Honest small print: the Ollama app itself occasionally checks for its own updates, like most apps. But inference never needs the network — if you're fully offline it keeps working, and you can firewall Ollama off entirely without touching the models.)

This is exactly why the earlier "acquire and verify" effort pays off: an API provider can revoke your access overnight — a model on your own disk, running offline, is yours to keep. That independence is the thread running through the whole series.

Cheat-sheet

ollama run llama3.2:1b      # chat with a 1B model (downloads on first run)
ollama run llama3.2:3b      # larger, a bit slower
ollama list                 # models you've downloaded
ollama ps                   # models currently loaded in RAM
ollama stop llama3.2:3b     # unload from RAM right now
/bye                        # leave the chat

Three rules that save all the pain: open a new terminal after installing, start with the smallest model, and step up only while it stays snappy.

---

Part 1 — Acquire & verify: the Open-Weights Archiving Playbook. Part 2 — Choose your format: which GGUF quant fits your hardware. Next up — Keep it alive: re-verifying and maintaining a local model library over time.