Mac or PC for Running Models Locally

You are about to spend real money on a computer, and you want it to run language models on your own desk. One camp tells you to buy a Mac; the other tells you to buy a PC with a big graphics card. Both are right about something, and neither says what. This guide sets the two side by side, with the figures their makers publish, and shows you where each one wins — so the choice is made by the models you want to run, not by the camp you happened to read first.

Two figures decide it, and this site's first hardware guide, Which Machine Runs a Model Locally, explains both on the machine you already have. The first is memory: a model is a file, and it runs only if that file fits in the memory of the part that does the work — a Mac's unified memory, or a PC's graphics card's own memory. The second is memory bandwidth: how many gigabytes per second that memory can be read, which sets how fast the words come out of a model that fits.

This time you will not read your own machine. You will write one short file that holds eleven models' published file sizes and eight machines' published specifications — four Mac configurations and four NVIDIA graphics cards — and prints what fits where, and how fast each could go at most. Nothing in it is measured on this site. Every size and every specification is quoted from its maker's own page, with the source named below, and the file only does arithmetic on them. That is also why its output is the same on every computer, yours included.

No prices appear on this page. A price changes from week to week and from one country to the next; a machine's memory and bandwidth do not change once it is sold. Take the two figures this guide gives you to the shop, narrow the list with them, and compare prices there, between the machines that are left.

By the end of this guide you will

• List the models you want to run and say how much memory each one needs, with one file you run yourself.
• Say which of eight current machines — four Mac configurations and four NVIDIA graphics cards — can hold each of eleven common models, and which cannot.
• Work out the fastest each machine's memory could let a model write, and explain why a graphics card that holds a model beats a Mac that holds it, and why a Mac beats a card that does not.
• Choose between a Mac and a PC in the right order: by the largest model you need first, and by speed second.

Before you start

You need two things, and neither costs anything.

• Node.js 22 or newer. Run node --version. It prints a version such as v24.14.1, which is what the output on this page came from. If it prints an error, install Node.js from its official site.
• A terminal in an empty folder. Run mkdir mac-or-pc, then cd mac-or-pc. The file you write next reads nothing on your computer and sends nothing anywhere: no key, no network, no installation. There is no key to keep out of the code, on Windows or on a Mac, because nothing here asks for one.

You do not need a Mac or a graphics card to follow this guide. The file answers for eight machines you probably do not own, and that is the point: you can decide before you buy.

Step 1 — List the models and the memory each needs

Create a file named compare.mjs and put this in it:

// The download size of each model at the size Ollama serves by default, as its library page lists
// it (the guide cites each). A file this size has to sit in memory to run.
const models = [
  ['llama3.2:1b', 1.3],
  ['llama3.2:3b', 2.0],
  ['qwen3:4b', 2.5],
  ['gemma3:4b', 3.3],
  ['llama3.1:8b', 4.9],
  ['qwen3:8b', 5.2],
  ['gemma3:12b', 8.1],
  ['qwen3:14b', 9.3],
  ['gemma3:27b', 17],
  ['qwen3:32b', 20],
  ['llama3.1:70b', 43],
];

// The rule of thumb of this site's first hardware guide, not a measurement: a model's file should
// take no more than three quarters of the memory it lives in, leaving the rest for the text it holds.
const fits = (sizeGb, memoryGb) => sizeGb <= memoryGb * 0.75;

console.log('model           file      needs at least');
for (const [name, sizeGb] of models) {
  console.log(`${name.padEnd(15)} ${(sizeGb.toFixed(1) + ' GB').padEnd(9)} ${(sizeGb / 0.75).toFixed(1)} GB`);
}

model           file      needs at least
llama3.2:1b     1.3 GB    1.7 GB
llama3.2:3b     2.0 GB    2.7 GB
qwen3:4b        2.5 GB    3.3 GB
gemma3:4b       3.3 GB    4.4 GB
llama3.1:8b     4.9 GB    6.5 GB
qwen3:8b        5.2 GB    6.9 GB
gemma3:12b      8.1 GB    10.8 GB
qwen3:14b       9.3 GB    12.4 GB
gemma3:27b      17.0 GB   22.7 GB
qwen3:32b       20.0 GB   26.7 GB
llama3.1:70b    43.0 GB   57.3 GB

Run it with node compare.mjs. A table of eleven rows comes back. Here is what it printed, and how to read it.

• model file needs at least — three columns: the model's name as Ollama spells it, the size of its file, and the least memory a machine needs to hold it by this guide's rule.
• llama3.2:1b 1.3 GB 1.7 GB — the smallest model on the list. A 1.3 GB file wants at least 1.7 GB of memory: 1.3 divided by 0.75.
• qwen3:8b 5.2 GB 6.9 GB — the middle of the list, and a common first model. It wants 6.9 GB. Step 3 uses it as the model every machine can hold.
• qwen3:14b 9.3 GB 12.4 GB — the last row that needs less than 16 GB. Remember it: it is the largest model a 16 GB machine holds.
• gemma3:27b 17.0 GB 22.7 GB and qwen3:32b 20.0 GB 26.7 GB — the first two rows that need more than 16 GB. Step 2 turns on these two.
• llama3.1:70b 43.0 GB 57.3 GB — the largest. It wants more than 57 GB of memory in one place.

The rule in the code is fits, and its comment says what it is: a rule of thumb, not a measurement. A model's file should take no more than three quarters of the memory it lives in; the last quarter is for the text the model holds while it works, and for the system around it. The third column is the same rule turned around — the file size divided by 0.75 — so you can read off the memory to look for before you look at any machine.

The sizes are not measured here either. Ollama's library lists llama3.2:1b at 1.3GB and llama3.2:3b at 2.0GB. It lists qwen3:4b at 2.5GB , qwen3:8b at 5.2GB , qwen3:14b at 9.3GB and qwen3:32b at 20GB. It lists gemma3:4b at 3.3GB , gemma3:12b at 8.1GB and gemma3:27b at 17GB. And it lists llama3.1:8b at 4.9GB and llama3.1:70b at 43GB. Each is the size of the compressed form the library serves by default, which is why an eight-billion-parameter model is a file of about 5 GB; the first hardware guide explains that compression, called quantisation, in one paragraph.

If the model you want is not on the list, find its size on its library page and add a row. The table only needs a name and a size.

Step 2 — Set them against eight machines

Add this below Step 1's code, in the same file:

// Each machine's memory and memory bandwidth, as its maker's page states them (the guide cites
// each). On a Mac the memory is unified: all of it is where the model lives. On a PC it is the
// graphics card's own memory; the rest of the PC's memory is not counted here.
const machines = [
  ['Mac mini M6', 16, 153],
  ['Mac mini M6', 32, 170],
  ['MacBook Pro M5 Pro', 48, 307],
  ['MacBook Pro M5 Max', 128, 614],
  ['PC + RTX 5070', 12, 672],
  ['PC + RTX 5070 Ti', 16, 896],
  ['PC + RTX 5080', 16, 960],
  ['PC + RTX 5090', 32, 1792],
];

console.log('machine              memory  bandwidth   models that fit  largest that fits');
for (const [name, memoryGb, bandwidthGbs] of machines) {
  const fitting = models.filter(([, sizeGb]) => fits(sizeGb, memoryGb));
  const [largest, largestGb] = fitting.at(-1);
  console.log(
    `${name.padEnd(20)} ${(memoryGb + ' GB').padEnd(7)} ${(bandwidthGbs + ' GB/s').padEnd(11)} ` +
      `${(fitting.length + ' of ' + models.length).padEnd(16)} ${largest} (${largestGb} GB)`,
  );
}

machine              memory  bandwidth   models that fit  largest that fits
Mac mini M6          16 GB   153 GB/s    8 of 11          qwen3:14b (9.3 GB)
Mac mini M6          32 GB   170 GB/s    10 of 11         qwen3:32b (20 GB)
MacBook Pro M5 Pro   48 GB   307 GB/s    10 of 11         qwen3:32b (20 GB)
MacBook Pro M5 Max   128 GB  614 GB/s    11 of 11         llama3.1:70b (43 GB)
PC + RTX 5070        12 GB   672 GB/s    7 of 11          gemma3:12b (8.1 GB)
PC + RTX 5070 Ti     16 GB   896 GB/s    8 of 11          qwen3:14b (9.3 GB)
PC + RTX 5080        16 GB   960 GB/s    8 of 11          qwen3:14b (9.3 GB)
PC + RTX 5090        32 GB   1792 GB/s   10 of 11         qwen3:32b (20 GB)

Run node compare.mjs again. Step 1's table prints first; then a second table, one row per machine. Here is what it printed:

• machine memory bandwidth models that fit largest that fits — for each machine, the memory a model can live in, how fast that memory can be read, how many of Step 1's eleven fit by the rule, and the largest one that does.
• Mac mini M6 16 GB 153 GB/s 8 of 11 qwen3:14b (9.3 GB) — the Mac mini as it comes, with 16 GB. Eight of the eleven fit, up to qwen3:14b.
• Mac mini M6 32 GB 170 GB/s 10 of 11 qwen3:32b (20 GB) — the same Mac mini configured with 32 GB. Two more fit, gemma3:27b and qwen3:32b; only the 70B model does not. The bandwidth moved too, from 153 to 170.
• MacBook Pro M5 Pro 48 GB 307 GB/s 10 of 11 qwen3:32b (20 GB) — 48 GB fits the same ten as 32 GB. On this list, the 16 GB between them buys no new model, because the next one, llama3.1:70b, needs 57.3. What it does buy is bandwidth, and that is Step 3.
• MacBook Pro M5 Max 128 GB 614 GB/s 11 of 11 llama3.1:70b (43 GB) — the only machine on the list that holds all eleven.
• PC + RTX 5070 12 GB 672 GB/s 7 of 11 gemma3:12b (8.1 GB) — the fewest. qwen3:14b needs 12.4 GB, and the card has 12.
• PC + RTX 5070 Ti 16 GB 896 GB/s 8 of 11 qwen3:14b (9.3 GB) and PC + RTX 5080 16 GB 960 GB/s 8 of 11 qwen3:14b (9.3 GB) — the same eight as the 16 GB Mac mini, no more and no fewer.
• PC + RTX 5090 32 GB 1792 GB/s 10 of 11 qwen3:32b (20 GB) — the largest card fits exactly what the 32 GB Mac mini fits.

Now read the columns rather than the rows. At the same memory, a Mac and a card hold exactly the same models: 16 GB fits eight either way, and 32 GB fits ten either way. What you can run is decided by how much memory you can have in one place, and on this list the Macs go to 128 GB while the largest card stops at 32. How fast it runs is the bandwidth column, and there every card is ahead of every Mac: the slowest card on the list, at 672 GB/s, is faster than the fastest Mac, at 614.

The specifications come from the makers' own pages. NVIDIA's comparison page sets its cards side by side, starting with the RTX 5090, the RTX 5080, the RTX 5070 Ti and the RTX 5070, in that order. In that order, it lists their standard memory as 32 GB, 16 GB, 16 GB and 12 GB of GDDR7 , and their memory bandwidth as 1792, 960, 896 and 672 GB/sec.

Apple's Mac mini specifications list the M6 chip with 153GB/s memory bandwidth , and 16GB of unified memory, configurable to 24GB or 32GB, with 170GB/s memory bandwidth. That is why the Mac mini has two rows with two bandwidths: the 16 GB machine as it comes, and the 32 GB configuration. Apple's MacBook Pro specifications list the M5 Pro chip with 307GB/s memory bandwidth , and the M5 Max at 460GB/s with the 32-core GPU and 614GB/s with the 40-core GPU. The same page lists 48GB as a configuration of the M5 Pro, and 128GB as a configuration of the M5 Max with the 40-core GPU only — which is why the 128 GB row carries 614 and not 460.

The four PC rows count the card's memory and nothing else. A PC has system memory of its own as well, and the comment in the code says it is left out on purpose; the first pitfall below says why.

Step 3 — Work out the fastest each machine could write

Add this below Step 2's code:

// This guide's estimate, not a measurement: to write each token the model reads its whole file from
// memory once, so memory bandwidth divided by the file size is the most tokens per second that
// memory could allow. Real runs come in under it. A model that does not fit gets no number.
const picks = ['qwen3:8b', 'gemma3:27b'];

console.log(`ceiling in tokens per second  ${picks.map((pick) => pick.padEnd(14)).join('')}`.trimEnd());
for (const [name, memoryGb, bandwidthGbs] of machines) {
  const cells = picks.map((pick) => {
    const [, sizeGb] = models.find(([model]) => model === pick);
    return fits(sizeGb, memoryGb) ? `${Math.floor(bandwidthGbs / sizeGb)} t/s` : 'does not fit';
  });
  console.log(`${name.padEnd(29)}${cells.map((cell) => cell.padEnd(14)).join('')}`.trimEnd());
}

ceiling in tokens per second  qwen3:8b      gemma3:27b
Mac mini M6                  29 t/s        does not fit
Mac mini M6                  32 t/s        10 t/s
MacBook Pro M5 Pro           59 t/s        18 t/s
MacBook Pro M5 Max           118 t/s       36 t/s
PC + RTX 5070                129 t/s       does not fit
PC + RTX 5070 Ti             172 t/s       does not fit
PC + RTX 5080                184 t/s       does not fit
PC + RTX 5090                344 t/s       105 t/s

Run node compare.mjs a third time. After the two tables comes a third, for two models: qwen3:8b, which every machine holds, and gemma3:27b, which only four do. Each number is a ceiling in tokens per second — t/s, where a token is a word or a piece of one.

• Mac mini M6 29 t/s does not fit — the 16 GB Mac mini could write qwen3:8b at no more than 29 t/s, and cannot hold gemma3:27b at all.
• Mac mini M6 32 t/s 10 t/s — with 32 GB, gemma3:27b fits, with a ceiling of 10.
• MacBook Pro M5 Pro 59 t/s 18 t/s and MacBook Pro M5 Max 118 t/s 36 t/s — the M5 Max has twice the M5 Pro's bandwidth, 614 against 307, and twice its ceiling on qwen3:8b, 118 against 59.
• PC + RTX 5070 129 t/s does not fit, PC + RTX 5070 Ti 172 t/s does not fit and PC + RTX 5080 184 t/s does not fit — on qwen3:8b every card is ahead of every Mac, the smallest card included. On gemma3:27b none of the three has a number, because none of them holds it.
• PC + RTX 5090 344 t/s 105 t/s — the highest ceiling on both, and on gemma3:27b more than ten times the 32 GB Mac mini's: 105 against 10.

The arithmetic is in the code, and its comment says plainly that it is this guide's estimate and not a measurement. To write each token, a model reads all of its numbers from memory once. So if the memory can deliver 153 gigabytes a second and the file is 5.2 GB, the file can be read at most 29 times a second: 153 divided by 5.2 is 29.4, and the code rounds down. A real run comes in under its ceiling, because a machine does more for each token than read the file. The ceilings are for comparing machines with each other, never a promise of what you will see.

Is that the right shape? A published test says it is. A discussion on the llama.cpp project keeps a table of Apple chips generating text with one model. In it, the M4 with 120 GB/s and a 10-core GPU generates 24.11 t/s at Q4_0 , and the M5 Max with 614 GB/s and a 40-core GPU generates 119.92 t/s. From the first chip to the second, bandwidth grows 5.1 times (614 divided by 120) and tokens per second grow 5.0 times (119.92 divided by 24.11). Speed followed bandwidth almost exactly. That table measures a different model from Step 3's — Llama 2 7B, as its plot's caption names it — so its numbers are not to be set against Step 3's rows. What carries over is the proportion, and the proportion is what the ceiling assumes.

The one rule

Memory decides which models you can run; bandwidth decides how fast they run. A Mac sells you the first: on this list, more memory in one place than any card. A graphics card sells you the second: more bandwidth than any Mac, up to the edge of its memory and not a byte past it.

So choose in that order. Find the largest model you need in Step 1's table, keep only the machines in Step 2's table that hold it, and among those, take the highest ceiling in Step 3.

The first row is where a card wins outright: the 16 GB cards hold the same eight models as the 16 GB Mac mini, with ceilings about six times higher. The last row is where a Mac wins outright: no card on the list holds the model at all. The middle row is the one to think about, and the answer depends on how much you care about speed there.

When to use it, and when not

Terms that came up

• Unified memory — a Mac's single pool of memory, shared by the processor and the graphics cores; the model lives in it directly.
• Graphics card memory — the memory on a PC's graphics card, separate from the PC's system memory; on a PC, the model has to fit here to run at the card's speed.
• Memory bandwidth — how many gigabytes a second the memory can be read, written GB/s; the figure that sets how fast a model that fits can write.
• Configuration — one of the memory sizes a maker offers for a machine; the Mac mini's 16 GB and its 32 GB are two configurations with two bandwidths.
• Token and t/s — a token is a word or a piece of one; t/s is tokens per second, the speed a model writes at.
• Speed ceiling — this guide's estimate: bandwidth divided by the model's file size, the most tokens per second the memory could allow. Real runs come in under it.
• Rule of three quarters — this guide's rule of thumb: a model's file should take no more than three quarters of the memory it lives in.
• AI TOPS — trillions of operations per second, a card's compute figure; it follows how fast a prompt is read, not how fast an answer is written.
• Prompt processing and text generation — reading what you gave the model, and writing the answer; the first leans on compute, the second on bandwidth.
• Quantisation — storing a model's numbers with fewer bits so the file shrinks; the reason an eight-billion-parameter model is a 5 GB file.

In short

Choose by the largest model you need first: at 16 or 32 GB a Mac and a card hold the same models, and only a Mac on this list holds a 43 GB one. Then, among the machines that hold it, bandwidth sets the speed, and every card on the list is faster than every Mac. Compare prices last, and only between the machines that passed both.

What changed recently

No source of this guide has changed since the last check.