Three new local models on a 48 GB MacBook: what I measured
I ran Liquid's LFM3-1.7B, NVIDIA's Nemotron 3.5 Bolt, and Ricursive's Ripple-65B on an M5 Pro with Ollama. Real speeds, memory, swap, pass rates, and the default settings that changed the results.
Last checked:
SectionsOctober was a good month for models you can run on your own computer. NVIDIA published a 74-billion-parameter model squeezed to fit in 24 GB. Liquid AI released a family of small models, with the text one at about a gigabyte. Ricursive put out an open 65-billion-parameter coding model under Apache 2.0.
Launch posts for local models all carry the same kind of sentence: so many tokens per second, on hardware you probably don't own. I wanted to know what happens on the laptop I do own, with other work still running on it.
So I ran all three and wrote everything down. This post has the numbers, the setup, and the surprises. The short version: the smallest one is very fast, the middle one is capable and slow, and the largest one passed every test while pushing the laptop about 15 GB into swap. For two of the three, the default settings got in the way.
The machine and the rules
The laptop is a MacBook Pro with an Apple M5 Pro and 48 GB of memory, on macOS 27.0.1. It was not a clean machine. A Linux virtual machine that I keep running for other work held about 19.7 GiB of memory for the whole test. I left it running on purpose. Most people who try a local model will try it next to whatever they already have open.
The runtime was Ollama 0.40.16. I used the models' default 32K context window as Ollama reported it.
Every run used the same settings:
- Temperature 0 and seed 0, to make runs as repeatable as the runtime allows.
- A limit of 400 output tokens.
- No system prompt. Ollama applied each model's own chat template.
- Three runs per prompt.
Memory figures are what the model's process held at its peak, in GiB.
There were three prompts:
- A, extraction. A voicemail-style message from a landlord in Ohio about a tenant's broken AC in Cape Coral, with a callback number, a gate, and a dog. The model had to return the service address, callback number, problem, and access notes as JSON.
- B, code. "Write a Python function that merges overlapping [start, end] intervals and returns them sorted. Include three assert-based tests."
- C, prose. A 150-word explanation for a plumbing company owner. I timed this one and didn't grade it.
Grading was done by a script, not by eye. For A, the output had to contain JSON that parsed, with all four fields correct: the street number, street, unit, and city in the address, the right ten digits in the phone number, the AC in the problem, and the gate, the dog, and the property manager in the access notes. For B, the script pulled out the Python, ran it, and passed it only if it exited cleanly and contained at least one assert.
That's six graded runs per setting, plus three timed ones. It's a small test. It tells you how these models behaved on my prompts on my machine, and nothing about how they rank in general.
LFM3-1.7B: fast, once thinking is off
Liquid describes LFM3-1.7B as a text model "for local agents and specialized applications." The Ollama page says it takes about 1 GB of memory at 4-bit precision, supports tool calling and structured output, and is "not recommended for agentic coding or complex multi-step reasoning due to its small size."
The surprise was that with default settings it never answered anything.
Ollama tags the model as "thinking," and thinking is on unless you turn it off. In all nine default runs, the model spent the entire 400-token budget reasoning and returned an empty answer. Zero of three on extraction, zero of three on code. If I'd stopped there, I'd have written the model off.
With thinking turned off, it was a different model:
- Extraction: correct JSON with all four fields in 3 of 3 runs. Each took about half a second, start to finish, for 69 tokens.
- Code: 0 of 3. It was still explaining the algorithm when it hit 400 tokens, and the code was cut off before any tests.
- Speed: about 140 tokens per second of generation, and a third of a second or less to the first token.
- Memory: a peak of 1.74 GiB, and no swap.
- Loading: under a second.
The code failure fits what Liquid says the model is for. It also reflects my token limit, since the code might have been fine with more room. I didn't test that, so I'll leave it as a fail.
Half a second for a correct structured extraction, in under 2 GiB of memory, is the result worth remembering. That's a model you could run beside everything else on an ordinary office computer.
One caveat for anyone who needs repeatable output. Even at temperature 0 with a fixed seed, LFM3 didn't always produce the same text. The first run often differed from the second and third. The extraction answers were identical across runs, but the code and prose prompts each produced two distinct outputs.
Nemotron 3.5 Bolt: capable, and slow on this laptop
NVIDIA's research page for Nemotron 3.5 Bolt, published October 15, describes a mixture-of-experts model with 74 billion parameters in total and 9 billion active for any given token. It was compressed from a larger model and, in NVIDIA's words, "designed to fit into 24GB of memory." Most of the expert weights are stored at about two bits each.
I ran NVIDIA's own file from Hugging Face through Ollama.
The results, with default settings:
- Extraction: 3 of 3 correct, in both full passes I ran.
- Code: 3 of 3 passed, with three asserts each, in both passes.
- Speed: 10 to 17 tokens per second of generation. Reading the prompt ran at 36 to 78 tokens per second on a first run.
- Time to first token: between 1.1 and 1.9 seconds on a first run.
- Memory: a peak of 24.3 GiB for the model process, a little over the 24 GB in the name.
- Swap: the Mac went from no swap to about 3 GiB during the first pass and stayed there.
- Loading: 2 to 9 seconds.
So the accuracy was there, and the wait was real. An extraction that took LFM3 half a second took Nemotron about 30 seconds with thinking on, because it produced 311 tokens of reasoning and answer at around 10 tokens per second. The code prompt ran into the 400-token limit every time, at 33 to 39 seconds.
With thinking off, extraction dropped to about 5 seconds for 79 tokens and was still correct in 3 of 3 runs. Generation was faster too, at 15 to 18 tokens per second.
The code prompt with thinking off is the result I'd flag as unfair to the model. It scored 0 of 3, and the reason was my limit. The model wrote the function and was partway through a fifth assert when it hit 400 tokens, which left a broken line. With that one line deleted, the function ran and the first four asserts passed. The grading script counts it as a failure, and I've left the score alone, but it's a cap failure and not a wrong answer.
Unlike LFM3, Nemotron gave byte-identical output across all three runs of every prompt.
Ripple-65B: every test passed, on borrowed memory
Ricursive's Ripple-65B Preview is the odd one out. The Ollama page describes it as "a 65B dense model from Ricursive Intelligence, built for agentic coding," released under Apache 2.0. Dense means all 65 billion parameters are used for every token. Nemotron has more parameters in total and uses 9 billion at a time.
I used the 4-bit build, which is 38.8 GB on disk.
On paper this shouldn't fit. The laptop has 48 GB, and about 20 of it was already taken. It ran anyway:
- Extraction: 3 of 3 correct, in 65 tokens.
- Code: 3 of 3 passed. It wrote a complete function with three asserts in 201 tokens, with nothing cut off.
- Speed: 2.9 to 6.8 tokens per second of generation. Reading the prompt ran at 16 to 44 tokens per second on a first run.
- Time to first token: 2.1 to 2.4 seconds on the first extraction run.
- Memory: a peak of 38.3 GiB for the model process. Ollama put 92% of the model on the GPU and 8% on the CPU.
- Swap: it climbed from about 2.5 GB to a peak near 16 GB. The system's free-memory reading touched 0% at one point.
- Loading: 10 to 16 seconds.
Ripple was the only model of the three to pass both graded tasks in every run, and the only one that never ran into the 400-token limit. Its answers were short. The extraction took 65 tokens where Nemotron used 311 with thinking on.
That brevity is why the total times look better than the speed suggests. An extraction took 10 to 25 seconds, and the code prompt took 30 to 44 seconds, which is about what Nemotron took at twice the token rate.
Three more things I noticed:
- Thinking made no difference. Ollama lists thinking as a capability, but the model wrote no thinking text with default settings. The results with thinking on and off were byte-identical.
- Speed was uneven. The same extraction prompt, producing the same 65 tokens, ran at 2.9 tokens per second on one run and 6.5 on the next. That fits a model that's partly swapped out to disk.
- Swap costs disk space. Free disk fell by about 5 GB during the test because macOS grew its swap files. After I unloaded the model, about 13 GB of swap was still in use.
Nothing crashed, and no request took longer than 44 seconds. But a laptop with no free memory isn't one I'd want to do other work on, and I didn't measure what the swapping did to anything else running at the time.
About that 84 tokens per second
NVIDIA's page reports 84 tokens per second for this model. I measured 10 to 17. Both numbers can be true.
NVIDIA's figure is from a coding benchmark on its RTX Spark hardware, running Windows, with a second small model drafting tokens ahead of the main one to speed it up. My run was a different chip, a different operating system, and no drafter. NVIDIA says the model is "optimized for use on RTX Spark with llama.cpp." A MacBook isn't the target.
I also had 20 GB of memory committed to something else, and the machine dipped into swap. I can't tell you how much of the gap that explains, because I didn't run it on an idle machine.
What I take from it is narrow: a vendor's speed belongs to the vendor's setup. If speed matters for your use, measure on the computer that will do the work.
The default settings mattered more than I expected
Three things about defaults changed the results for the two smaller models more than I expected.
| Model and setting | A · Extraction | B · Code |
|---|---|---|
| LFM3-1.7Bdefault, thinking on | 0 of 3Spent all 400 tokens thinking. Empty answer. | 0 of 3Same: no answer at all. |
| LFM3-1.7Bthinking off | 3 of 3About 0.5 s each. | 0 of 3Still explaining at 400 tokens. |
| Nemotron 3.5 Boltdefault, thinking on | 3 of 3About 30 s: 311 tokens of reasoning and answer. | 3 of 3Hit the limit every time, 33–39 s. |
| Nemotron 3.5 Boltthinking off | 3 of 3About 5 s. | 0 of 3Cut off mid-assert by the limit, not wrong. |
| Ripple-65Bon or off, identical output | 3 of 310–25 s for 65 tokens. | 3 of 3Complete in 201 tokens, 30–44 s. |
Thinking is on by default, and it spends your token budget. LFM3 used all 400 tokens thinking and answered nothing. Nemotron spent most of its tokens the same way. If your application sets a modest output limit, a thinking model can return an empty answer and report no error. For short, structured tasks, test with thinking off first.
Reasoning can leak into the answer. For LFM3, Ollama kept the thinking text separate from the answer. For Nemotron in this setup, it didn't. The answer field contained the model's reasoning, then a literal closing think tag, then the real answer. The extraction check still passed because the script looks for the JSON block. The code check passed in default mode on code the model wrote inside its reasoning. If you were to feed that output straight into another program, you'd need to strip the reasoning yourself.
A fixed seed is not a guarantee. Two models repeated themselves exactly. The third didn't. If you're building tests around a local model, check this before you write assertions against exact text.
None of these are flaws in the models so much as things the runtime decides for you. They'll also change as Ollama updates its handling of each model. Check them on the version you install.
What I'd use each one for
Based on six graded runs per setting, which is thin evidence, here's how I'd place them.
LFM3-1.7B is the one I'd try for small, fast, structured jobs: pulling fields out of a message, tagging, routing, turning a sentence into JSON. It was correct and nearly instant on that task, and it fits beside anything. I wouldn't hand it code or long reasoning, and neither would Liquid. Read its license before shipping it in a product. It uses Liquid's own LFM Open License, not a standard open-source one.
Nemotron 3.5 Bolt did everything I asked correctly when it had room to finish. On this laptop it's a model for work where nobody is waiting: overnight batches, drafts, tasks where 30 seconds is fine and the data shouldn't leave the building. It takes half of a 48 GB machine. On a 32 GB machine, or one that's already busy, I'd expect a worse time than I had.
Ripple-65B gave the best answers of the three on my two small tasks, and it was the least comfortable to run. On this laptop it needs memory the machine doesn't have. I'd try it on a 64 GB machine, or on this one with nothing else running, before judging its speed. It's built for coding agents working through long tasks, and three short prompts say nothing about that.
None of them replaces a hosted model for interactive coding on this hardware. For private, well-defined tasks, all three are usable today, and one of them is quick.
What I didn't test
Agent work. Ripple is built for multi-step coding in a terminal, and Nemotron is pitched at local agents. I ran single prompts only.
Other runtimes. I only used Ollama. Running llama.cpp directly, or adding NVIDIA's speculative drafter, might be faster.
An idle machine. Every number here was measured with a 20 GB virtual machine running. Ripple and Nemotron would both have more room without it.
Longer outputs. The 400-token limit was involved in every failing result for LFM3 and Nemotron. A higher limit would likely change the code scores, and I can't say by how much.
Images, tools, and long context. Nemotron accepts images and LFM3 supports tool calling. I tested neither. I also didn't go anywhere near the long context windows these models advertise.
Quality beyond pass or fail. The prose prompt was timed and not graded.
Run this on your own machine
The method is more useful than my numbers. It takes an afternoon.
- Pick three prompts from your real work. One short and structured, one that needs reasoning, one that writes prose.
- Write the pass rule before you run anything. Which fields must be present, or which test must pass. Have a script check it.
- Fix the settings. Same temperature, seed, and output limit for every model.
- Run each prompt three times, with thinking on and with it off.
- Record five things per run: time to first token, tokens per second, total time, peak memory, and swap before and after.
- Use the first run for prompt speed. Ollama caches the prompt, so second and third runs report reading speeds in the thousands or millions of tokens per second, which mean nothing.
- Keep the raw outputs. Two of my results only made sense after reading what the model actually wrote.
- Leave your normal programs open. That's the machine the model will really run on.
Then look at where the failures came from. In my case, every one involved a default setting or the token limit, so I still don't know where these models' real limits are. And watch swap as closely as speed. The model that scored best here was also the one that used up the machine.
If you're weighing a local model against a hosted one for a specific job, and want help setting up a fair test or building the integration around whichever wins, that's custom software work I do. Tell me what the job is.
Related: when a flagship model is worth it covers the other end of the scale, and decision models, one month after Jev covers small models built to pick an answer and not write one.