Ollama System Requirements: Minimum RAM, GPU and Disk Size

Published on April 10, 2026 · Updated November 2, 2026 -- 26 min read

Short answer: Ollama's minimum requirement is 8 GB of RAM, 10 GB of free disk, and a 64-bit CPU with AVX2 -- no GPU required. For comfortable daily use, target 16 GB RAM plus an 8-12 GB GPU (NVIDIA RTX 3060 12GB or a 16 GB Apple Silicon Mac). As a rule of thumb at Q4 quantization: 8 GB of VRAM runs 7B-8B models, 12 GB runs 14B, and 24 GB+ runs 32B. NVIDIA needs CUDA compute capability 5.0+ and driver 550+; AMD needs ROCm v7 (other Radeons use Vulkan); Apple Silicon uses Metal and, since v0.40, MLX automatically.

How big is Ollama? The app is small next to the models it runs. Sizes of the official Ollama v0.40.13 release files (October 28, 2026):

On speed: generation reads the whole model once per token, so memory bandwidth sets a ceiling. An RTX 3060 12GB (360 GB/s) cannot exceed ~73 tok/s on a 4.9 GB 8B model or ~40 tok/s on a 9 GB 14B; real speeds land below that. Every speed on this page is a labelled ceiling of that kind, except the one Mac we measured.

Updated November 2, 2026 for Ollama v0.40.13 (released October 28, 2026). Since v0.40.0 (September 25, 2026), supported models run on Apple's MLX runtime by default on Apple Silicon; AMD support now needs the ROCm v7 driver, with Vulkan as the default fallback for other Radeons; the Windows installer still installs per-user without Administrator rights. The base hardware floor (8 GB RAM, no GPU) has not changed -- but the newer models shift where the sweet spot sits. If you want a deeper breakdown of memory by component, see our RAM requirements for local AI guide, the dedicated VRAM requirements guide for 2026, and the model-by-model Ollama RAM & VRAM table for exact pull sizes.

Ollama's documentation says "macOS, Linux, Windows" and leaves it at that. But when you pull a 14B model and your system grinds to a halt, the missing details matter. How much VRAM for a 32B model? Does your AMD GPU work? Can a CPU-only machine handle it?

This guide gives you the specific specs from Ollama's own documentation and release files (v0.40.13), model sizes from Ollama's tag lists, speed ceilings you can recompute from vendor bandwidth figures, and the commands to check whether your system is ready.

---

How Big Is Ollama? Download & Install Size

The Ollama app itself is a 230 MB download on macOS, a 1.68 GB installer on Windows (1.56 GB as Windows Explorer counts it), and a 1.53 GB bundle on Linux (file sizes of the official v0.40.13 GitHub release assets, October 28, 2026). The app is not what fills your drive -- models are. Every model you pull adds 2-40+ GB on top of the app.

Why is the Windows installer about seven times the size of the Mac download? GPU libraries. Ollama ships the CUDA runtime inside the Windows and Linux packages so acceleration works without you installing anything else. On a Mac, Metal is part of the operating system, so the app stays small.

Two practical notes on disk space:

• The unpacked install is larger than the download. The Windows and Linux packages are compressed, so leave some headroom beyond the download size. The 10 GB minimum free space in the specs table below covers the app plus one small model.
• Models dominate disk use, not the app. A single 7B model is ~4.7 GB (qwen2.5:7b) and a 70B model is 43 GB (llama3.3:70b), so a typical 3-5 model library needs 15-30 GB. The model sizes on disk table further down lists exact sizes per model and quantization.

If you need to reclaim space later, models live in ~/.ollama/models on Linux and Mac (C:\Users\<you>\.ollama\models on Windows), ollama rm modelname deletes one cleanly, and setting OLLAMA_MODELS moves the whole library to another drive.

---

Minimum vs Recommended Specs

Absolute Minimum (Will Run, But Slowly)

With minimum specs, a 7B-8B model runs on the CPU. The ceiling is set by RAM bandwidth: dual-channel DDR4-3200 (51.2 GB/s) cannot exceed ~10 tok/s on a 4.9 GB model, and real CPU speeds land below that. Usable for testing. Painful for actual work.

Recommended (Comfortable Daily Use)

This setup runs 7B-14B models fully on the GPU. On the RTX 3060 12GB the bandwidth ceiling is ~73 tok/s for a 4.9 GB 8B model and ~40 tok/s for a 9 GB 14B (360 GB/s ÷ file size). Good enough for code assistance, chat, and RAG pipelines.

Optimal (Power User / Small Team)

Handles 32B models at interactive speeds. Serves multiple concurrent users through Ollama's API.

---

GPU Requirements: NVIDIA, AMD, Apple

NVIDIA GPUs (Best Support)

Ollama uses CUDA for NVIDIA GPU acceleration. Ollama's hardware support docs list compute capability 5.0+ as the minimum, with driver 550 or newer (570+ for compute capability 5.0-6.2).

Supported NVIDIA GPUs:

Driver requirements (Ollama docs, v0.40.13):

• Linux: NVIDIA driver 550 or later (570+ for GTX 900 / 10-series and other compute capability 5.0-6.2 cards)
• Windows: NVIDIA driver 551.61 or later

Check your driver and CUDA version:

# Linux/Windows
nvidia-smi

# Look for "CUDA Version" and "Driver Version" in output

Ollama bundles its own CUDA runtime, so you do not need to install the CUDA Toolkit separately. Just the NVIDIA driver.

AMD GPUs (Linux ROCm)

AMD support works through ROCm, and Ollama v0.40 requires the ROCm v7 driver on both Linux and Windows. Cards outside the ROCm list run through Ollama's Vulkan backend, which is enabled by default.

Supported AMD GPUs:

Bandwidth sets the token-generation ceiling on AMD exactly as on NVIDIA: an RX 7900 XTX cannot exceed ~196 tok/s on a 4.9 GB 8B model (960 ÷ 4.9). How close a card gets depends on the ROCm or Vulkan kernels for your model, so treat the ceiling as an upper bound, not a forecast.

ROCm installation (Ubuntu):

# Install AMD's amdgpu-install package for your Ubuntu release first,
# following https://rocm.docs.amd.com/projects/install-on-linux/en/latest/
# (Ollama v0.40 needs ROCm v7)

# Install ROCm
sudo amdgpu-install --usecase=rocm

# Then add Ollama's ROCm package
curl -fsSL https://ollama.com/download/ollama-linux-amd64-rocm.tar.zst | sudo tar x -C /usr

# Verify
rocminfo | grep "Name:"

Where AMD falls behind NVIDIA on the same bandwidth, the cause is software: CUDA kernels have had far longer to mature than ROCm's. On the ROCm list, setup is now a driver install plus one extra package; off the list, Vulkan is the path.

Apple Silicon (Metal)

Every Apple Silicon chip supports Ollama through Metal GPU acceleration -- no configuration needed.

Speed ceilings by Apple Silicon chip (Apple's published memory bandwidth ÷ the Ollama file size: llama3.1:8b 4.9 GB, qwen2.5:14b 9.0 GB, qwen2.5:32b 20 GB):

These are upper bounds, not measurements. The one Mac we have measured: an Apple M3 Pro with 18 GB (150 GB/s) ran llama3.1:8b at a median 27.2 tok/s on Ollama 0.40.13 (2 November 2026), against a ~31 tok/s ceiling, so roughly 89% of the bound on that chip.

Apple Silicon benefits from unified memory -- the GPU accesses the same RAM as the CPU with no copy overhead. A 32 GB M2 Max can run models that would need a 24 GB-plus NVIDIA card, though macOS keeps part of the memory for itself, and an RTX 4090's 1,008 GB/s gives it a 2.5x higher ceiling than the M2 Max's 400 GB/s.

For detailed Apple Silicon setup, see our Mac local AI setup guide.

---

RTX 50-Series & Blackwell Support

If you bought a 2025-2026 NVIDIA card, the good news is Ollama handles it with zero manual setup. The RTX 5090, 5080, 5070 Ti, 5070, 5060 Ti and 5060 are all "desktop Blackwell" cards (compute capability 12.0, per Ollama's hardware docs). Ollama auto-detects them through CUDA and uses flash attention automatically where the backend supports it -- no driver flags or rebuilds needed beyond driver 550+.

Two things matter for Ollama on Blackwell:

• FP4 in silicon. Blackwell adds 4-bit floating-point tensor-core math in hardware, and OpenAI's gpt-oss models ship in the 4-bit MXFP4 format. Whether a given Ollama build takes the hardware path depends on the backend, so count it as headroom rather than a promised speed-up.
• Memory bandwidth, not just capacity. NVIDIA lists the 5090 at 1,792 GB/s against 1,008 GB/s for the 4090, so its bandwidth ceiling on any dense model that fits both cards is 1.78x higher. For Ollama, bandwidth is the real bottleneck once a model fits in VRAM.

The practical takeaway: a 16 GB card (5070 Ti / 5080) is the new mainstream sweet spot for 7B-22B work, and the 32 GB RTX 5090 is the first single consumer card that runs 32B models comfortably without any CPU offload. Not sure whether your specific card and RAM combo will run a given model? Run it through our free "Can I run local AI?" hardware checker before you download anything.

---

VRAM Needs Per Model Size

This is the table that answers the most common question: "Can my GPU run this model?"

All values are for Q4_K_M quantization (the recommended sweet spot) with 4K context:

Context length increases memory usage. Each additional 1K context tokens adds roughly:

• 7B model: ~0.3-0.5 GB
• 14B model: ~0.5-0.8 GB
• 32B model: ~0.8-1.5 GB
• 70B model: ~1.0-2.0 GB

A 32B model at Q4_K_M with 32K context might need 28-32 GB instead of 20 GB.

What happens when a model exceeds VRAM? Ollama automatically offloads layers to system RAM (CPU). This works, but the offloaded layers run at system-RAM bandwidth (tens of GB/s) instead of VRAM bandwidth (hundreds), so speed drops sharply. If a GPU system suddenly generates in single digits, partial CPU offloading is the usual cause. Check with:

# Load a model, then look at the PROCESSOR column
ollama run llama3.1:8b "test"
ollama ps
# "100% GPU" = fully on the card; "48%/52% CPU/GPU" = partially offloaded

Ollama also picks a default context window from your VRAM (docs, v0.40.13): 4K below 24 GiB, 32K from 24 to 48 GiB, 256K at 48 GiB and above. ollama ps shows the context it allocated in the CONTEXT column.

For a model-by-model lookup beyond the summary above -- including exact pull sizes and the minimum card for each -- see our Ollama model RAM & VRAM table, which lists every popular model in one reference.

Which Models Fit Your GPU: Picks by VRAM Tier

Once you know your VRAM, skip the guesswork -- we maintain pick lists for each tier:

Sitting between tiers (a 10 GB RTX 3080 or a 20 GB RX 7900 XT)? Use the picks from the tier below your card and spend the spare VRAM on longer context. Planning to run video generation on the same GPU? That workload is far hungrier than anything in this table -- the Wan 2.2 VRAM requirements by GPU breakdown covers 8 GB through 24 GB cards.

---

Requirements for 2026 Models (gpt-oss, Gemma 4, Llama 4)

The 7B/13B/32B rules of thumb still hold, but the headline 2026 models are mostly mixture-of-experts (MoE) designs, which changes how you should read the numbers. An MoE model only activates a fraction of its parameters per token, so it runs faster than a dense model of the same total size -- but you still need enough memory to hold all the weights resident. Here is what the current crop actually needs in Ollama at the recommended quantization:

A few things worth calling out:

• gpt-oss 20B is the new "fits a 16 GB card" flagship. OpenAI ships it natively in MXFP4, so it lands around 16 GB of memory without you quantizing anything yourself. On a Blackwell card (RTX 5070 Ti/5080/5090) the 4-bit math runs in hardware, so it is fast.
• Gemma 4 is multimodal, and the "E2B" name is not the disk size. Ollama's gemma4:e2b tag is a 4.6 GB download (the model has 2.3B "effective" parameters but 5.1B including its embeddings, per the Ollama library) -- plan on a 6-8 GB GPU or a 16 GB Mac, not a 4 GB card. gemma4:e4b is bigger at 6.6 GB. Both are lighter than the 12B (7.7 GB), 26B (16 GB) and 31B (19 GB) tiers above them.
• The 100B+ tier is still a workstation/server story. gpt-oss 120B needs an 80 GB-class GPU (or a high-memory Mac / multi-GPU rig). Do not expect to run it on a single consumer card.

The base Ollama floor (8 GB RAM, AVX2 CPU, no GPU) has not moved -- but if your goal is specifically to run the 2026 models well, plan for 16 GB of VRAM as the practical entry point and 24-32 GB if you want the 26B-32B tier with headroom.

---

CPU-Only Performance

No GPU? Ollama still works. Here is what to expect:

CPU Speed Ceilings by Processor

On CPU, every generated token streams the whole model out of system RAM, so dual-channel memory bandwidth sets the ceiling. Bandwidth below is the CPU's maximum rated memory speed in dual channel (Intel lists it as "max memory bandwidth"; for AMD it is the rated DDR speed × 2 channels × 8 bytes). Files: llama3.1:8b 4.9 GB, qwen2.5:14b 9.0 GB.

These are ceilings at the CPU's rated memory speed; a slower kit lowers them, and CPUs usually land well below the ceiling because compute limits them too.

CPU inference tips:

• RAM speed matters. Dual-channel DDR5-6000 (96 GB/s) has a 1.9x higher ceiling than DDR4-3200 (51.2 GB/s).
• More cores help prompt processing; generation stops scaling once memory bandwidth is saturated.
• AVX-512 (on CPUs that have it, such as AMD Zen 4) speeds up the math llama.cpp runs on CPU.
• Close memory-hungry applications so the model is not pushed into swap.

# Force CPU-only mode even if a GPU is present (set on the server)
CUDA_VISIBLE_DEVICES=-1 ollama serve

# Set the thread count: there is no OLLAMA_NUM_THREADS variable;
# use the num_thread parameter instead
ollama run llama3.1:8b
>>> /set parameter num_thread 12

Bottom line: CPU-only is viable for 7B models if you have a modern 8+ core processor. Anything above 14B on CPU is an exercise in patience.

---

OS-Specific Requirements

Windows

Windows-specific install:

# Download and install (native Windows app, no WSL needed)
winget install Ollama.Ollama

# Or put the app on another drive
OllamaSetup.exe /DIR="D:\Ollama"

# Verify installation
ollama --version

# Check GPU detection
ollama run llama3.2:1b "hello" 2>&1

For detailed Windows setup, see our Ollama Windows installation guide.

macOS

macOS install:

# Homebrew (recommended)
brew install ollama

# Or download from ollama.com
curl -fsSL https://ollama.com/install.sh | sh

# Start the service
brew services start ollama

Intel Macs work but run on the CPU only (Ollama's macOS docs). A 2019 Intel i9 MacBook Pro with dual-channel DDR4-2666 (42.7 GB/s) has a ceiling of ~9 tok/s on a 4.9 GB 8B model, and real CPU speeds land below that. If you have an Intel Mac, consider upgrading to Apple Silicon or using a cloud GPU.

Linux

Linux install:

# One-line install (recommended)
curl -fsSL https://ollama.com/install.sh | sh

# Verify GPU detection
ollama run llama3.2:1b "test"

# Check which GPU library was picked
journalctl -u ollama --no-pager | grep -i "cuda\|rocm\|vulkan"

# And confirm the model is on the GPU
ollama ps

Linux is the most direct path for GPU work: the install script sets up a systemd service, and the ROCm list is broadest on Linux (the RX 9000 and RX 6000 cards are Linux-only on ROCm; Windows covers the RX 7000 series and uses Vulkan for the rest).

---

Storage Requirements

Model Sizes on Disk

Sizes are the instruct tags as listed on ollama.com (read November 2, 2026).

Disk Speed Impact on Load Times

The first load reads the whole file from disk, so file size ÷ read speed is the floor. The speeds below are interface or class limits, not measurements: PCIe 4.0 NVMe drives top out around 7 GB/s, SATA III at about 550 MB/s, a 7200 RPM hard drive at roughly 200 MB/s sequential, and gigabit Ethernet at 125 MB/s.

A second load of the same model is usually much faster because the operating system caches the file in RAM. Model loading only happens once per session. After the first load, the model stays in memory until it times out (default: 5 minutes of inactivity).

# Keep model loaded indefinitely (no timeout)
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Check where models are stored
du -sh ~/.ollama/models/

# Move model storage to another drive: stop Ollama, move the files,
# then point OLLAMA_MODELS at the new folder
mv ~/.ollama/models /mnt/fast-ssd/ollama-models
OLLAMA_MODELS=/mnt/fast-ssd/ollama-models ollama serve

---

Docker and Container Setup

Running Ollama in Docker is common for team deployments and reproducible environments. Here are the requirements:

Docker with NVIDIA GPU

# Prerequisites: Docker 20.10+ and NVIDIA Container Toolkit
# Install NVIDIA Container Toolkit
distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

# Run Ollama with GPU
docker run -d --gpus all \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

# Pull and run a model
docker exec -it ollama ollama pull llama3.1:8b
docker exec -it ollama ollama run llama3.1:8b "Hello"

Docker with AMD GPU

# Requires ROCm installed on host
docker run -d \
  --device /dev/kfd \
  --device /dev/dri \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama:rocm

Docker CPU-Only

# No special flags needed
docker run -d \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

The container talks to the host GPU driver directly, so Docker itself adds little. The main consideration is ensuring GPU passthrough works correctly: docker exec -it ollama ollama ps should show the model at 100% GPU.

---

Cloud GPU Options

If your local hardware falls short, cloud GPU instances let you run Ollama remotely.

Cloud Provider Comparison

RunPod and Lambda prices read from their pricing pages on November 2, 2026; cloud prices move, so check before you commit.

Setting Up Ollama on a Cloud GPU

# SSH into your cloud instance
ssh user@your-cloud-ip

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Bind to all interfaces (so you can access remotely)
OLLAMA_HOST=0.0.0.0:11434 ollama serve &

# Pull model
ollama pull qwen2.5:32b

# From your local machine, connect:
export OLLAMA_HOST=http://your-cloud-ip:11434
ollama run qwen2.5:32b "test"

Cost comparison: A RunPod RTX 4090 at $0.89/hr for 8 hours/day costs about $214/month. Divide what a 24 GB card costs you today by that figure for your break-even in months. If you need 32B+ models daily, buying hardware is usually cheaper long-term. For occasional use or testing large models, cloud is more economical.

---

What Changed in Ollama in 2026?

If you last set Ollama up in 2024 or early 2025, a few things are worth knowing before you check requirements -- none of them raise the minimum bar, but several change what your existing hardware can do:

• MLX by default on Apple Silicon. Since v0.40.0 (September 25, 2026), model architectures the MLX runtime supports run on MLX automatically on M-series Macs, with llama.cpp still handling the rest. No setting to change.
• Blackwell is on the supported list. RTX 50-series cards (compute capability 12.0) and the DGX Spark's GB10 (12.1) are in Ollama's hardware table; they need driver 550 or newer like every other NVIDIA card.
• AMD moved to ROCm v7, with Vulkan as the fallback. The ROCm package now needs the v7 driver; Radeons outside the ROCm list run through the Vulkan backend, which is enabled by default on Windows and Linux.
• No WSL on Windows, per-user install, and an ARM64 build. The Windows installer runs without Administrator rights and installs into your profile; each release also ships a Windows ARM64 CLI zip.
• Context defaults follow your VRAM. Ollama picks 4K context below 24 GiB of VRAM, 32K up to 48 GiB and 256K above that, and OLLAMA_CONTEXT_LENGTH overrides it. Several 2026 models support 128K+ context, so if you raise it for long documents, budget the extra KV-cache memory.

On the Linux side, the NVIDIA floor is driver 550+ and AMD needs ROCm v7, and Ubuntu remains the smoothest distro for GPU acceleration. If Linux specifically is your target, our Linux local AI setup guide covers driver setup and the exact commands to confirm CUDA/ROCm is active.

---

Performance Optimization Tips

1. GPU Layer Allocation

There is no OLLAMA_NUM_GPU server variable; the number of layers on the GPU is the num_gpu model parameter. Ollama sets it automatically from free VRAM, so only touch it to force a partial offload.

# Set GPU layers for one session (useful for partial offload)
ollama run llama3.1:8b
>>> /set parameter num_gpu 28

# Or bake it into a model
cat > Modelfile << 'EOF'
FROM llama3.1:8b
PARAMETER num_gpu 28
EOF
ollama create llama-28layers -f Modelfile

2. Context Length Tuning

Shorter context = less VRAM = faster inference.

# Set context length in Modelfile
cat > Modelfile << 'EOF'
FROM llama3.1:8b
PARAMETER num_ctx 4096
EOF
ollama create fast-llama -f Modelfile

3. Concurrent Request Handling

# Allow 2 parallel requests per model (default 1; KV-cache memory scales with it)
OLLAMA_NUM_PARALLEL=2 ollama serve

# Max models loaded at once (default: 3 per GPU, or 3 on CPU)
OLLAMA_MAX_LOADED_MODELS=2 ollama serve

# Default context length for every model
OLLAMA_CONTEXT_LENGTH=16384 ollama serve

4. Flash Attention

Ollama uses flash attention automatically when the backend and device support it (Ollama FAQ). It cuts the memory the KV cache needs as context grows, and with it on you can also quantize the KV cache. Force it on or off, and shrink the cache:

OLLAMA_FLASH_ATTENTION=1 ollama serve        # force on (0 = off)
OLLAMA_KV_CACHE_TYPE=q8_0 ollama serve       # f16 (default), q8_0 or q4_0

5. System-Level Optimizations

# Linux: increase shared memory (for large models)
echo "vm.overcommit_memory=1" | sudo tee -a /etc/sysctl.conf
sudo sysctl -p

# Linux: disable GPU power management (prevents throttling)
sudo nvidia-smi -pm 1

# macOS: disable Spotlight indexing on model directory
sudo mdutil -i off ~/.ollama

# All platforms: check if swap is being used (bad for performance)
free -h  # Linux
vm_stat  # macOS

For more on the latest Ollama performance improvements, check the official blog.

---

Checking Your System

Run these commands to verify your system meets the requirements before installing Ollama:

GPU Detection

# NVIDIA GPU check
nvidia-smi
# Output should show GPU name, VRAM, driver version

# AMD GPU check (Linux)
rocminfo | grep "Name:"
# Should list your GPU model

# Apple Silicon check
system_profiler SPDisplaysDataType | grep "Chipset Model\|Metal\|VRAM"
# Should show Metal: Supported

Memory Check

# Linux
free -h | grep Mem
# Look at "total" column

# macOS
sysctl hw.memsize | awk '{printf "%.1f GB\n", $2/1073741824}'

# Windows (PowerShell)
(Get-CimInstance Win32_PhysicalMemory | Measure-Object -Property Capacity -Sum).Sum / 1GB

Storage Check

# Linux/macOS
df -h ~/.ollama 2>/dev/null || df -h ~

# Windows (PowerShell)
Get-PSDrive C | Select-Object Free

AVX Support Check (Required for CPU Inference)

# Linux
grep -o 'avx[^ ]*' /proc/cpuinfo | head -1
# Should output "avx2" at minimum

# macOS (Apple Silicon always supports equivalent)
sysctl -a | grep machdep.cpu.features | grep AVX

Post-Install Verification

# After installing Ollama, run this to verify everything works
ollama --version
ollama pull llama3.2:1b  # Small model for testing
ollama run llama3.2:1b "What is 2+2?"
# If you get a response, your setup is working

# Check which acceleration backend is being used
OLLAMA_DEBUG=1 ollama run llama3.2:1b "test" 2>&1 | head -20

---

Conclusion

Ollama runs on almost anything with a CPU and 8 GB of RAM. But there is a wide gap between "runs" and "runs well." The sweet spot for most users is a 12-16 GB NVIDIA card (RTX 3060 12GB, RTX 4060 Ti 16GB) or an Apple Silicon Mac with 16 GB unified memory. Either setup holds 7B-14B models fully in fast memory, and that covers the majority of local AI use cases.

If you need bigger models, an RTX 4090 opens up the 32B tier, which is where local AI quality starts matching cloud APIs. And if you occasionally need 70B-class models, an 80 GB cloud A100 at $1.79/hr on RunPod (November 2, 2026) makes more sense than buying dual GPUs for sporadic use.

Check your system with the commands above, pick a model that fits your VRAM, and start with ollama pull. You can always upgrade hardware later -- the models and configuration carry over unchanged.

If you want the whole Ollama workflow in order -- install, model library, Modelfiles, GPU offload, serving -- that is what the Ollama Mastery course covers; the first chapter is free with an account. And if you are still deciding which model your specific card should run, the local model picker course walks through matching hardware to model size step by step.

---

Already have Ollama installed? Check our complete Ollama guide for advanced configuration, browse the best Ollama models to find what works best for your hardware, or look up exact pull sizes in the Ollama model RAM & VRAM table.