Ollama and LM Studio system requirements: minimum specs, RAM and VRAM by model size

Ollama and LM Studio ask little of the PC itself: a supported OS, plus an AVX2 CPU for LM Studio on x64. The model you load decides how much RAM and VRAM you need; on the 8GB GeForce RTX 4060, Qwen3 8B fits fully on the GPU and Runs great. On the GeForce RTX 5060 Ti 16GB, gpt-oss-20b Runs great, and a public benchmark backs that speed. On the 24GB GeForce RTX 3090, the MoE model Qwen3.6 35B-A3B fits entirely on the GPU and Runs great.

What Ollama and LM Studio need to install

Ollama

Ollama's Windows page asks for Windows 10 22H2 or newer (Home or Pro), with NVIDIA driver 551.61 or newer on NVIDIA cards (Ollama docs, checked 2026-10-19). It installs into your home folder without administrator rights. Models need disk space of their own, many gigabytes for large ones; to move them, set OLLAMA_MODELS under "Edit environment variables for your account".

Ollama's hardware support page asks for an NVIDIA GPU with compute capability 5.0 or higher and driver 550 or newer; cards with compute capability 5.0–6.2 need driver 570 or newer (Ollama docs, checked 2026-10-19). The two pages give different minimum NVIDIA drivers. nvidia-smi shows yours; if it is older than either page asks, update it. The RTX 4060, RTX 3060, RTX 5060 Ti, RTX 3090 and RTX 5090 all appear in that page's compute capability table.

On a Mac, Ollama needs macOS Sonoma (14) or newer on an Apple M-series chip (CPU and GPU) or an Intel (x86) Mac; Intel Macs run on the CPU only (Ollama docs, checked 2026-10-19). None of these requirement sections lists a RAM or VRAM minimum. Ollama's quickstart recommends VRAM only for its example model, Gemma 4 E2B, and adds that with less VRAM Ollama can use system RAM but may answer more slowly. In CanRun's calculation, E2B at Q4_K_M fits fully on an 8GB card such as the RTX 4060.

LM Studio

For Windows PCs, LM Studio lists a CPU with AVX2 on x64 PCs, with at least 16 GB of RAM and 4 GB of dedicated VRAM recommended (LM Studio docs, checked 2026-10-19). AVX2 is required on x64, while the RAM and VRAM figures are recommendations, not minimums. It also runs on Windows on Arm (Snapdragon X Elite).

For Macs, it lists an Apple Silicon Mac (M1–M4; Intel Macs are not supported) on macOS 14.0 or newer, with 16 GB of RAM or more recommended (LM Studio docs, checked 2026-10-19). So an Intel Mac can run Ollama, on the CPU only, but not LM Studio.

AMD, Intel and Linux

Ollama runs supported Radeon cards through ROCm; its hardware support page has separate Windows and Linux lists, and the Windows list is shorter. Other GPUs, AMD and Intel included, run through Vulkan, which is on by default and comes with most Windows drivers. For some RX 6000-series (RDNA2) systems that may not expose ROCm on current Windows drivers, the Windows page recommends Vulkan.

LM Studio has separate llama.cpp runtimes for CUDA, Vulkan, ROCm and the CPU, and Ctrl+Shift+R opens the screen where you pick one.

On Linux, Ollama installs with a script, and the CUDA and ROCm drivers are separate, optional installs. LM Studio ships as an AppImage for x64 and ARM64. For Radeon and Arc cards, see AMD Radeon and Intel Arc for local LLMs: ROCm, Vulkan and what runs.

Minimum and recommended specs come from the model

Neither app decides how much memory you need; the model, its quant and the context do. Qwen3 8B, the smallest model here, needs 6.5 GB at 8k, which is already more VRAM than LM Studio's recommendation. Qwen3.6 35B-A3B needs 21.8 GB.

The table uses Q4_K_M, the usual 4-bit default, except for gpt-oss-20b in MXFP4, its native 4-bit format. Totals include the KV cache, the memory that holds the conversation. Three models are MoE: a mixture-of-experts model reads only a few experts per token, so experts that do not fit can sit in system RAM.

Read "minimum" as the smallest card whose usable memory covers the 8k total. The OS keeps some VRAM on a display GPU, so an 8GB card has 7.4 GB to use. Qwen3 8B fits on 8GB. Gemma 4 12B needs more than that, so part of it goes to system RAM, but it fits fully on 12GB. Qwen3 14B fits on 12GB with little margin — check ollama ps.

gpt-oss-20b needs just over what a 12GB card can use, so some experts go to RAM there, and it fits fully on 16GB. Gemma 4 26B-A4B and Qwen3.6 35B-A3B keep experts in RAM on 16GB and fit fully on 24GB.

"Recommended" means the minimum plus room for the context you want, because the KV cache grows with it. How much VRAM do local LLMs need? 8–32 GB tiers (2026) works through that headroom tier by tier.

System RAM counts too, because spilled layers and experts live there. In CanRun's calculation, Qwen3.6 35B-A3B on an 8GB card does not fit with 16GB of system RAM, and at 32GB it fits with experts in RAM.

What to run on 8GB to 32GB cards

The summary counts our whole catalog by verdict on one card per tier, at 8k, f16 KV cache and 32GB of DDR5.

The grid shows this guide's six models under the same conditions; the Qwen3 14B and gpt-oss-20b cells link to combo pages. Its legend sets one rule for MoE models: a model with experts in system RAM is capped at Runs well, because Runs great needs the whole model on the GPU.

8GB: 8B models, and MoE models with system RAM

On the RTX 4060, qwen3:8b Runs great. At 8k it has little margin — check ollama ps — but Ollama starts this card at 4k anyway. gemma4:12b puts a small part in system RAM and Runs well; the IQ4_XS route is in the LM Studio section.

On the same card, qwen3:14b puts part of its weights in system RAM and Runs slowly. A dense model reads every weight per token, so the part in system RAM slows every token.

The three MoE models do better on this card. gpt-oss-20b, Gemma 4 26B-A4B and Qwen3.6 35B-A3B each Runs well with experts in RAM, all as theoretical estimates (±30%). Qwen3.6 35B-A3B needs 32GB of system RAM for this, not 16GB.

12GB: Gemma 4 12B and Qwen3 14B on the GPU

On the RTX 3060 12GB, gemma4:12b Runs great. qwen3:14b stays on the GPU and Runs well, with little margin — check ollama ps.

Our page for Qwen3 14B on the GeForce RTX 3060 12GB shows where longer contexts start to spill.

gpt-oss:20b needs just over what the card can use, so experts go to RAM and it Runs well, a theoretical estimate.

16GB: gpt-oss-20b on the GPU alone

On the RTX 5060 Ti 16GB, qwen3:14b Runs great. gpt-oss:20b fits on the GPU alone and Runs great, and its speed comes from a public llama.cpp benchmark (llama-bench, not an Ollama run).

gemma4:26b Runs well with experts in RAM, a theoretical estimate. The smaller IQ4_XS file fits fully, with about a gigabyte to spare, and Runs great:

ollama run hf.co/unsloth/gemma-4-26B-A4B-it-GGUF:UD-IQ4_XS

qwen3.6:35b also Runs well with experts in RAM, again as a theoretical estimate. Even its IQ4_XS file keeps experts in RAM on this card.

24GB and 32GB: the whole grid on the GPU

On both the GeForce RTX 3090 and the GeForce RTX 5090, each of the six grid models Runs great: Qwen3 8B, Gemma 4 12B, Qwen3 14B, gpt-oss-20b, Gemma 4 26B-A4B and Qwen3.6 35B-A3B. Here the standard gemma4:26b and qwen3.6:35b tags need no smaller quant.

What 32GB adds is room for context. In CanRun's calculation, Qwen3.6 35B-A3B stays fully on the GPU of the RTX 5090 even at 128k with an f16 KV cache. The Qwen3.6 35B-A3B page compares other cards.

Ollama tags and the context Ollama starts with

Ollama picks its default context length from the GPU memory it finds: 4k tokens below 24 GiB, 32k tokens from 24 to 48 GiB, and 256k tokens at 48 GiB or more (Ollama docs, checked 2026-09-29). Ollama's code puts the cut-offs slightly below the documented values, so 24GB cards such as the RTX 3090 start at 32k, as does the 32GB RTX 5090. The 8, 12 and 16GB cards start at 4k.

On the RTX 4060, Qwen3 8B fits fully at 4k, while Gemma 4 12B spills even at 4k. Raising Qwen3 8B to 16k with an f16 KV cache pushes part of its weights into system RAM, and a q8_0 KV cache keeps it on the GPU. Ollama quantizes the KV cache only when the server starts with OLLAMA_KV_CACHE_TYPE (f16, q8_0 or q4_0) and flash attention on; the setting applies to every model the server runs (Ollama docs, checked 2026-09-29). Ollama slow or forgetting your prompt? Context length defaults shows how to change the context.

On the RTX 3090, Qwen3.6 35B-A3B at Ollama's 32k fits on the GPU with little margin — check ollama ps, because the qwen3.6:35b tag also bundles a vision projector that CanRun does not count. At 64k with an f16 KV cache, some experts move to system RAM; with a q8_0 KV cache, 64k stays on the GPU. The table shows the speeds.

In a public report, an Ollama user on Windows 11 with an RTX 3090 ran gemma4:26b at a 32k context with flash attention off, and ollama ps showed 100% GPU. Gemma 4 26B-A4B Runs great on the RTX 3090, and the table below shows this report's speed. That build is now listed as gemma4:26b-a4b-it-q4_K_M; gemma4:26b points to a different one. CanRun also keeps 32k fully on the GPU.

What the tag pages listed when we checked (= marks the same build):

• qwen3:8b = qwen3:8b-q4_K_M = qwen3:latest, and qwen3:14b = qwen3:14b-q4_K_M.
• gpt-oss:20b = gpt-oss:latest, Ollama's own MXFP4 build.
• gemma4:12b and gemma4:26b (= gemma4:26b-a4b) list MLX and llama.cpp variants. The llama.cpp one is Q4_K_M plus a vision projector and a small "draft" model.
• qwen3.6:35b = qwen3.6:35b-a3b = qwen3.6:latest, with the same two variants; the llama.cpp one is Q4_K_M plus a vision projector.
• Bare gemma4 is the small E4B, which fits fully on the RTX 4060 in CanRun's calculation; name the size to get the 12B or 26B. Gemma 4 12B vs 26B-A4B vs 31B: differences, VRAM and which size fits your GPU covers E4B and E2B.

These are Ollama's own builds, not the Hugging Face GGUF files CanRun calculates. For the exact files, use the hf.co form:

ollama run hf.co/unsloth/Qwen3-8B-GGUF:Q4_K_M
ollama run hf.co/unsloth/Qwen3-14B-GGUF:Q4_K_M
ollama run hf.co/ggml-org/gpt-oss-20b-GGUF:MXFP4
ollama run hf.co/bartowski/Qwen_Qwen3.6-35B-A3B-GGUF:Q4_K_M

To match CanRun's 8k on Windows, use the context slider in the app's settings, or quit the app and start the server in PowerShell:

$env:OLLAMA_CONTEXT_LENGTH="8192"; ollama serve

On macOS and Linux, run OLLAMA_CONTEXT_LENGTH=8192 ollama serve. ollama ps then shows SIZE, PROCESSOR (100% GPU, 100% CPU or a CPU/GPU split) and CONTEXT; for a split you did not expect, see Ollama or LM Studio not using your GPU? Check the split and fix the offload.

LM Studio: memory estimate and GPU offload

LM Studio's model search (Ctrl+Shift+M) browses Hugging Face, so you can download the same GGUF repos CanRun calculates. Search for unsloth/gemma-4-12b-it-GGUF, for example.

Gemma 4 12B's IQ4_XS file fits fully on the RTX 4060 and Runs well, with little margin — check ollama ps if you run it as ollama run hf.co/unsloth/gemma-4-12b-it-GGUF:IQ4_XS. UD-Q2_K_XL Runs great, but it is a Heavy loss quant, and LM Studio's own advice is to choose a 4-bit option or higher if your machine can run it. Q8_0 spills part of its weights and Runs slowly.

The load panel has sliders for context length and GPU offload. The memory estimate updates as you move them, and LM Studio warns you before loading if you are likely to run out of memory, a guardrail you can override. From the command line, without loading:

lms load --estimate-only <model> --context-length 8192 --gpu max

--gpu takes max, off or a value from 0 to 1; left unset, LM Studio picks the offload itself. For LM Studio, its own estimate is a better guide than CanRun's tables. Its documentation gives no default context, so set 8192 to match CanRun.

No graphics card, or a Mac

Without a GPU, the whole model sits in system RAM. Qwen3 8B fits in 16GB, and on dual-channel DDR5-5600 it lands at Runs slowly, the cap CanRun puts on every CPU-only setup. gpt-oss-20b does not fit in 16GB but fits in 32GB. Running LLMs without a GPU: CPU-only speed and how much RAM you need covers each RAM size.

On a Mac, CanRun counts the whole model as needed memory and about 70% of unified memory as usable by the GPU. On a 16GB M4, Qwen3 8B stays on the GPU and Runs well. gpt-oss-20b needs 12.9 GB on a Mac, so it does not fit on the 16GB M4 and needs the 24GB configuration. Both apps' MLX engines are outside CanRun's calculation. See Running local LLMs on a Mac (M4, M5): how much unified memory?.

How sure are these numbers?

Memory is calculated by formula from the GGUF files and model configs. Speeds are estimates with a band and a confidence label. Calibrated means ±12% for dense models fully on an NVIDIA or AMD card, and ±20% for MoE models, partial offload and other hardware. Theoretical (±30%) covers every cell with MoE experts in RAM on the 8, 12 and 16GB cards. Measured cells rest on a public benchmark: gpt-oss-20b on the 16, 24 and 32GB cards, Gemma 4 26B-A4B on the 24 and 32GB cards, and Qwen3 8B on the RTX 5090.

CanRun counts only the language-model file, not the vision projector and draft model that the gemma4 and qwen3.6 tags bundle. Ollama's builds also differ from CanRun's files, so check ollama ps. The tables assume Windows with the card driving the display, 32GB of DDR5 system RAM, and one model and one request at a time.

Verdict names in the text refer to 8k with an f16 KV cache. Qwen3 8B, Qwen3 14B and Qwen3.6 35B-A3B think by default and gpt-oss-20b always thinks, so their speed thresholds are 1.5× higher. Gemma 4 has thinking off by default. The thresholds:

Where to go next

• Ollama vs llama.cpp vs LM Studio: same engine, different defaults: how the three apps differ.
• Ollama slow or forgetting your prompt? Context length defaults: setting Ollama's context and keeping it in VRAM.
• Running MoE models bigger than your GPU: gpt-oss-120b with system RAM: how MoE experts in system RAM work.
• KV cache explained: how context length eats VRAM: how the KV cache grows and what q8_0 saves.
• Korean open LLMs (EXAONE, Kanana, HyperCLOVA X SEED, Solar): hardware guide: Korean models and how to run them.
• Gemma 4 12B vs 26B-A4B vs 31B: differences, VRAM and which size fits your GPU: the Gemma 4 sizes side by side.

FAQ

What are Ollama's minimum requirements?

Ollama's requirement pages set OS and GPU-driver requirements, not a RAM or VRAM minimum, so the model you load decides the memory. On Windows it asks for Windows 10 22H2 or newer (Home or Pro), with NVIDIA driver 551.61 or newer on NVIDIA cards (Ollama docs, checked 2026-10-19). For scale, Qwen3 8B fits fully on an 8GB card, and without a GPU it fits in 16GB of system RAM.

What can I run on 8GB of VRAM?

Qwen3 8B fits fully on an 8GB card, and on the RTX 4060 it Runs great. On the same card, Gemma 4 12B puts a small part in system RAM and Runs well. gpt-oss-20b fits with experts in system RAM; its speed there is a theoretical estimate (see the grid).

Does LM Studio need a better PC than Ollama?

Not for the model: both run GGUF files on llama.cpp, so the weights and KV cache take the same memory in either app. The differences are platform rules and defaults. LM Studio needs AVX2 on x64 PCs and does not support Intel Macs, while Ollama starts at a 4k context on cards below 24GB. Ollama vs llama.cpp vs LM Studio: same engine, different defaults compares the rest.

How much system RAM do I need?

Enough for the part of the model that does not fit in VRAM, plus what the OS uses; CanRun's tables assume 32GB. With an 8GB card, gpt-oss-20b fits with 16GB. Qwen3.6 35B-A3B does not fit with 16GB and needs 32GB. Without a GPU the whole model sits in RAM, so gpt-oss-20b does not fit in 16GB but fits in 32GB.

Which model should I pull for Korean?

CanRun does not rank models for Korean, because it does not rate answer quality in any language; it shows fit and speed. Korean models such as EXAONE, Kanana and HyperCLOVA X SEED are covered in Korean open LLMs (EXAONE, Kanana, HyperCLOVA X SEED, Solar): hardware guide, with hf.co commands. Kanana 1.5 8B, for example, fits fully on the RTX 4060 with about a gigabyte to spare.

Sources

• Ollama: Windows: requirements, install, OLLAMA_MODELS, AMD.
• Ollama: macOS: macOS and chip requirements.
• Ollama: hardware support: NVIDIA requirements, AMD lists, Vulkan.
• Ollama: Linux: install script and optional drivers.
• Ollama: quickstart: the example model's VRAM recommendation.
• Ollama: context length: defaults, slider, ollama ps.
• Ollama FAQ: PROCESSOR column, KV cache type.
• Ollama: server/routes.go: default-context thresholds in code.
• Ollama library: qwen3 tags: Qwen3 aliases.
• Ollama library: gpt-oss tags: the MXFP4 build.
• Ollama library: gemma4 tags: E4B default, 26B builds.
• Ollama library: gemma4:12b: variants, projector, draft model.
• Ollama library: gemma4:26b: variants, projector, draft model.
• Ollama library: qwen3.6 tags: Qwen3.6 aliases.
• Ollama library: qwen3.6:35b: variants, vision projector.
• Hugging Face: Ollama: the hf.co form.
• LM Studio: system requirements: Windows, Mac and Linux.
• LM Studio: download a model: the 4-bit advice.
• LM Studio blog: load estimates: memory estimate and guardrail.
• LM Studio: lms load: --estimate-only and --gpu.
• LM Studio blog: Model Search: the shortcut.
• llama.cpp: gpt-oss benchmarks: the RTX 5060 Ti 16GB run.
• Ollama issue: gemma4 on RTX 3090: the 32k run, flash attention off.