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:

Sections

October 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:

Memory figures are what the model's process held at its peak, in GiB.

There were three prompts:

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:

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:

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:

Measured / MacBook Pro M5 Pro, 48 GB One model fit. One filled the laptop. One didn't fit. Peak memory of each model's process, added to the 19.7 GiB the Linux VM held for the whole test.
  • LFM3-1.7B1.74 GiB peak, 21.4 with the VM · no swap
  • Nemotron 3.5 Bolt24.3 GiB peak, 44.0 with the VM · swap rose to ~3 GiB
  • Ripple-65B38.3 GiB peak, 58.0 with the VM · swap peaked near 16 GB
FIG. 01 Ripple's process plus the VM came to about 58 GiB on a 48 GiB machine, so macOS compressed and swapped the rest. macOS itself and my other apps aren't in these bars, which is why Nemotron pushed the Mac into swap even though its bar stays under the line.

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:

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.

Measured / Generation speed, tokens per second Fast, slow, and slower. Range across runs of all three prompts. The dashed line is NVIDIA's published figure, from a different machine and setup.
  • LFM3-1.7Bthinking off
    about 140
  • Nemotron 3.5 Boltdefault, thinking on
    10–17NVIDIA: 84
  • Nemotron 3.5 Boltthinking off
    15–18
  • Ripple-65Bthinking made no difference
    2.9–6.8
FIG. 02 Ollama 0.40.16, temperature 0, 400-token limit, with a 19.7 GiB VM running. NVIDIA's 84 tokens per second is from its RTX Spark hardware on Windows with a draft model, so it isn't a like-for-like comparison.

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.

Measured / Graded runs, three per cell The setting decided more than the model. Extraction (A) and code (B), graded by a script. Times are for the extraction prompt, start to finish.
Model and settingA · ExtractionB · Code
LFM3-1.7Bdefault, thinking on0 of 3Spent all 400 tokens thinking. Empty answer.0 of 3Same: no answer at all.
LFM3-1.7Bthinking off3 of 3About 0.5 s each.0 of 3Still explaining at 400 tokens.
Nemotron 3.5 Boltdefault, thinking on3 of 3About 30 s: 311 tokens of reasoning and answer.3 of 3Hit the limit every time, 33–39 s.
Nemotron 3.5 Boltthinking off3 of 3About 5 s.0 of 3Cut off mid-assert by the limit, not wrong.
Ripple-65Bon or off, identical output3 of 310–25 s for 65 tokens.3 of 3Complete in 201 tokens, 30–44 s.
FIG. 03 Every failing cell involves either the thinking default or the 400-token limit. Six graded runs per setting is a small test of my prompts on my machine, not a ranking.

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.

  1. Pick three prompts from your real work. One short and structured, one that needs reasoning, one that writes prose.
  2. Write the pass rule before you run anything. Which fields must be present, or which test must pass. Have a script check it.
  3. Fix the settings. Same temperature, seed, and output limit for every model.
  4. Run each prompt three times, with thinking on and with it off.
  5. Record five things per run: time to first token, tokens per second, total time, peak memory, and swap before and after.
  6. 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.
  7. Keep the raw outputs. Two of my results only made sense after reading what the model actually wrote.
  8. 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.

More notes

All notes · Contact