How to Check if Your Computer Can Run a Local AI Model Before You Download

By Austin Little

Local AI has a polite way of failing. You download a model for an hour, press enter, and then wait. And wait. Or the app quietly says it ran out of memory. Most of that is avoidable. Your computer already tells you everything you need to know before you download anything; you just have to know which four numbers to look at and what to compare them against.

AI disclosure. This page was drafted with AI assistance and edited for Apiary. Facts that need a live check are marked. We don't invent quotes, stats, people, or events.

Where this fits on Apiary

This is the "before you start" check. If you already know your machine and want help choosing a model, go next to Which Local Model for Writing on 8GB RAM or Small Language Models Explained: Why Smaller Can Be Better at Home. If you have a gaming PC, Running a Local AI Model on a Gaming PC You Already Own goes deeper on graphics cards, and our companion explainer What Is VRAM and Why Local AI Cares About Your Graphics Card explains the "why" behind the memory numbers below.

This article is narrower on purpose: how to read your own machine, how to read a model listing, and how to decide "yes, try it," "try a smaller one," or "use a free cloud option for now," without guessing.

The short answer

A local AI model has to be loaded into memory to run. So the questions are simple:

1. Does the model file fit on my disk, with room left over for everything else?
2. Does the model fit in my memory (graphics memory if I have a separate graphics card, or regular RAM if I don't), with room left for the conversation and for my other apps?
3. Does my operating system and processor meet the app's minimums?
4. Is my graphics chip one the app actually uses, or will it fall back to the slower main processor?

If the answers are yes, yes, yes, and yes, you'll likely have a good time. If you get a "no" on number 4, it will usually still work, just slower. A "no" on 1, 2, or 3 means pick a smaller model, a different app, or wait.

None of this needs a paid tool. Everything below uses screens that are already on your computer, plus free apps.

The four numbers that matter

1. System memory (RAM)

RAM is the computer's short-term workspace. When a model runs on your main processor (the CPU), the model has to sit in RAM. Even when a graphics card does the work, RAM still matters because the app, your browser, and the operating system all live there too.

2. Graphics memory (VRAM), or "unified memory" on Apple silicon Macs

If your computer has a separate graphics card (common in gaming PCs), that card has its own memory, called VRAM. Local AI apps prefer to load the model there because graphics chips do this kind of math quickly. If the model doesn't fit in VRAM, apps can split it between the graphics card and regular RAM, which works but is slower.

Ollama's own documentation describes this split: the ollama ps command shows a PROCESSOR column where "100% GPU means the model was loaded entirely into the GPU," "100% CPU means the model was loaded entirely in system memory," and a mixed figure like "48%/52% CPU/GPU" means it was split across both (Ollama FAQ).

Apple silicon Macs work differently: the processor and graphics share one pool of memory. So on those Macs, the "Memory" figure is the number to watch.

3. Free disk space

Model files are large. Ollama's Windows page warns that beyond the app itself you'll "need additional space for storing the Large Language models, which can be tens to hundreds of GB in size" (Ollama for Windows). You won't need hundreds of gigabytes to get started, but you do need enough for the model you pick plus breathing room.

4. Operating system version and processor type

Apps have minimums. Some won't install at all on older systems, and some only use your graphics chip if it's a supported model with recent drivers.

Step 1: Find your numbers on Windows

RAM and processor

Microsoft's support page gives the route: right-click Start, choose Settings, select System, then About. Under Device specifications you'll see the processor type and the amount of RAM installed (Microsoft Support: Find information about your Windows device). The same page, under Windows specifications, shows your Windows edition and version.

Write down:

• Installed RAM: ______
• Processor: ______
• Windows version: ______

Graphics card and VRAM

Task Manager shows this. Microsoft's DirectX team explains that under the Performance tab, each GPU appears in the left panel, and the memory graphs are split into "dedicated" and "shared." They write that "dedicated memory represents memory that is exclusively reserved for use by the GPU," and "on discrete GPUs this is your VRAM, the memory that sits on your graphics card" (Microsoft DirectX Developer Blog: GPUs in the Task Manager).

So: open Task Manager, click Performance, click each GPU entry, and note the Dedicated GPU memory figure. <!-- NEEDS_FOUNDER_EYEBALL: Confirm current Windows 11 Task Manager labels ("Dedicated GPU memory") on a live machine; source is a Microsoft developer blog, not a current support page. -->

A useful detail from the same post: "shared" memory is ordinary system RAM the graphics chip can borrow, and Windows has a policy where "the GPU is only allowed to use half of physical memory at any given instant." On a laptop with only integrated graphics, that shared figure is not extra memory; it's your RAM being lent out.

Write down:

• Graphics chip name(s): ______
• Dedicated GPU memory: ______

Free disk space

Open File Explorer, click This PC, and look at the bar under each drive. Or go to Settings > System > Storage, which Microsoft references in its drive-space guide (Microsoft Support: Free up drive space in Windows).

Write down:

• Free space on the C: drive: ______
• Any second drive and its free space: ______

Does your graphics card count?

If you have an NVIDIA card, Ollama's hardware page says it supports NVIDIA GPUs "with compute capability 5.0+ and driver version 550 and newer," and that cards with compute capability 5.0 through 6.2 "require driver version 570 or newer." The page includes a table mapping card families to compute capability, and links to NVIDIA's own lookup (Ollama hardware support). For AMD Radeon on Windows, the same page lists specific supported cards and notes extra support through Vulkan.

If your card isn't on the list, that's not the end. The app will usually run on the CPU instead. It will just be slower.

Step 2: Find your numbers on a Mac

Chip or processor, and memory

Choose the Apple menu > About This Mac. Apple explains the tell: "On a Mac with Apple silicon, About This Mac shows an item labeled Chip, followed by the name of the chip," while "on an Intel-based Mac, About This Mac shows an item labeled Processor" (Apple Support: Mac computers with Apple silicon). The same window shows Memory.

Write down:

• Chip or Processor: ______
• Memory: ______
• macOS version: ______

Why the chip line matters so much

The type of chip changes which apps you can use and how fast they run:

• Ollama's macOS page lists "MacOS Sonoma (v14) or newer" and "Apple M series (CPU and GPU support) or x86 (CPU only)" (Ollama for macOS). "x86" means Intel. So on an Intel Mac, Ollama runs on the processor only.
• LM Studio's requirements page says for macOS: Apple Silicon, "macOS 14.0 or newer is required," "16GB+ RAM recommended," and "Intel-based Macs are currently not supported" (LM Studio system requirements).
• Jan's Mac install page says "Intel-based Macs are not supported" and lists macOS 13.6 or higher as the minimum (Jan: Mac install).

If you're on an Intel Mac, read our companion piece, Running Local AI on an Older Intel Mac: Honest Options, before downloading anything.

Free disk space

Apple's guidance: in macOS Ventura 13 or later, choose System Settings from the Apple menu, click General, then Storage (Apple Support: Free up storage space on Mac).

Write down:

• Available storage: ______

Step 3: Find your numbers on Linux

Linux gives you exact numbers in the terminal. Open one and run these. None of them change anything; they only report.

free -h

free reports total, used, and available memory; -h makes it human-readable (free(1) manual). Look at the Mem row and note total and available.

df -h ~

df reports free disk space for the file system that holds a path; here, your home folder (df(1) manual). Note the Avail column.

If you have an NVIDIA card with drivers installed:

nvidia-smi

nvidia-smi is NVIDIA's System Management Interface tool; it reports the card name and memory use (NVIDIA nvidia-smi documentation). Note total memory.

Two Linux-specific notes from Ollama's docs: by default on Linux, models live in /usr/share/ollama/.ollama/models (Ollama FAQ), which is on your system drive, not necessarily your home folder. So run df -h /usr/share too if your system and home are on different partitions. And for AMD cards, Ollama "requires the AMD ROCm v7 driver on Linux" for its ROCm path, with Vulkan as an additional route (Ollama hardware support).

For a fuller walk-through, see How to Run a Free Local AI Model on Linux as a Beginner.

Step 4: Read the model listing before you click download

Now look at the other side: the model. Most model pages show a size. That size is the best single clue you have.

Example: reading a real Ollama listing

The Ollama library page for the deepseek-r1 family lists each size variant with its download size. As of today, it shows deepseek-r1:1.5b at 1.1GB, 7b at 4.7GB, 8b at 5.2GB, 14b at 9.0GB, 32b at 20GB, 70b at 43GB, and 671b at 404GB (Ollama library: deepseek-r1).

Notice the pattern. The tag (1.5b, 7b, 14b) is the number of parameters, in billions. The bigger the number, the bigger the file, and the more memory you need. The jump from the smallest to the largest here is from about a gigabyte to hundreds of gigabytes. That's why "which size?" matters more than "which model?"

The simple fit test

Take the download size and compare it with your memory:

• If you have a graphics card: is the download size comfortably smaller than your dedicated GPU memory? If yes, the model will likely load fully onto the card.
• If you don't, or it won't fit on the card: is the download size comfortably smaller than your available RAM (not total), after your browser and other apps are open?

"Comfortably" is doing real work there. The model file isn't the only thing in memory. The app also sets aside room for the conversation itself, called the context. Ollama's docs say plainly that "setting a larger context length will increase the amount of memory required to run a model" (Ollama: Context length). Ollama sets that default based on your graphics memory: 4k context below 24 GiB of VRAM, 32k between 24 and 48 GiB, and 256k at 48 GiB or more (same page).

We're not going to give you a magic multiplier for "how much headroom," because it depends on the app, the model, and the context length, and we couldn't find an official one-size rule. The honest test is the one in Step 5: try it and look at what the app reports.

What published rules of thumb say

Some app makers do publish rough guidance. Jan's Mac page, for example, says that with 8GB of memory you can "typically" run "up to 3B models comfortably," with 16GB "typically up to 7B models comfortably," and with 32GB "typically up to 13B models comfortably," and adds that fit "depends heavily on quantization, context length, and how much memory macOS is already using" (Jan: Mac install). Continue's guide to using Ollama for coding lists "Minimum 8GB (16GB+ recommended)" of RAM and "At least 10GB free space" (Continue: Using Ollama with Continue).

Treat these as starting points from one vendor each, not laws. Different apps and models behave differently.

What the letters after the size mean

You'll often see tags like Q4_K_M or Q8_0. Those are quantization levels: ways of storing the model's numbers with fewer bits so the file is smaller. Lower numbers mean smaller files and a little less precision. Hugging Face's Ollama integration page notes that by default, "the Q4_K_M quantization scheme is used, when it's present inside the model repo" (Hugging Face: Use Ollama with any GGUF model). If quantization is new to you, What Is a Quantized Model (Q4, Q8) in Plain English explains it.

The practical takeaway: if a model is a little too big, a smaller quantization of the same model may fit.

Step 5: The safe test drive

Reading specs gets you close. The real answer comes from a small, cheap test. Here's the order we suggest.

Start with the smallest version

Pick the smallest size of a model family you're curious about. Download it. Small models download fast, so a "no" costs you minutes, not an evening.

With Ollama, that looks like:

ollama pull deepseek-r1:1.5b
ollama run deepseek-r1:1.5b

ollama pull downloads, and ollama run starts a chat (Ollama CLI reference). Ask it something short.

Check where it loaded

In a second terminal window, while the model is loaded:

ollama ps

Look at the PROCESSOR column. If it says 100% GPU, your graphics chip is doing the work. If it says 100% CPU, it's on the main processor. A split like 48%/52% CPU/GPU means it didn't fully fit on the card (Ollama FAQ). Newer versions also show a CONTEXT column with the context length allocated (Ollama: Context length).

Measure speed

Run the same question with timing turned on:

ollama run deepseek-r1:1.5b --verbose

The --verbose flag "show[s] timings for response," and at the end Ollama prints lines including eval rate, in tokens per second (Ollama source: cmd.go; Ollama source: api/types.go). A token is roughly a word piece. Our companion What Is Tokens per Second and How Fast Local AI Needs to Be explains how to read that number.

Step up one size at a time

If the small model loaded on the GPU and felt quick, try the next size up. Check ollama ps again. The moment the PROCESSOR column starts showing a CPU share, you've found roughly where your graphics memory runs out. The size just below that point is often your sweet spot for speed.

If you're on CPU only, step up until the speed stops being pleasant for you. "Pleasant" is personal. Someone drafting emails can tolerate slower output than someone chatting back and forth.

Clean up what you don't keep

Every model you try takes disk space until you remove it:

ollama ls
ollama rm deepseek-r1:1.5b

ollama ls lists models; ollama rm removes one (Ollama CLI reference). More on that in How to Free Up Disk Space Used by Old Ollama Models.

Worked examples

These are illustrations of the reasoning, not benchmarks. Your results will vary with the specific model, app version, and what else is running.

Example A: The family laptop with integrated graphics

Settings > About shows a mid-range processor and a modest amount of RAM. Task Manager shows one GPU, an integrated chip, with little or no dedicated memory and a "shared" figure.

Reading: No separate graphics card, so the model will mostly live in system RAM. Remember the Windows policy that the GPU can borrow at most half of physical memory at a time (Microsoft DirectX blog); shared memory isn't a bonus pool.

Plan: Close the browser tabs you don't need. Start with the smallest model in a family. Expect slower replies than a gaming PC. If you want writing help specifically, our 8GB RAM model guide narrows the field.

Example B: The gaming PC

Task Manager shows an NVIDIA card with a healthy dedicated memory figure. Ollama's GPU table lists the card's family.

Reading: You can likely run mid-sized models fully on the GPU if the download size is comfortably under the card's dedicated memory.

Plan: Update the graphics driver first (Ollama's Windows page lists "NVIDIA 551.61 or newer Drivers if you have an NVIDIA card" (Ollama for Windows)). Start with a mid-sized model and confirm 100% GPU in ollama ps. Then step up.

Example C: The Apple silicon Mac

About This Mac shows Chip and a Memory figure.

Reading: One shared pool. The model, the context, macOS, and your apps all share it.

Plan: Use the Memory figure with a published guide like Jan's as a starting point, then test with ollama ps or your app's own memory indicator. See also Ollama on a Mac Mini for Home Writing: Realistic Setup.

Example D: The older Intel Mac

About This Mac shows Processor with an Intel name.

Reading: Ollama needs macOS 14 Sonoma and runs CPU-only on Intel (Ollama for macOS). LM Studio and Jan say Intel Macs aren't supported.

Plan: First check if your Mac can run Sonoma using Apple's list (Apple Support: macOS Sonoma compatibility). If yes, small models on CPU are possible. If not, a free cloud option may be the honest answer for now. Details in our Intel Mac guide.

A fill-in checklist you can print

Copy this into a note and fill it in once. You'll reuse it every time you look at a new model.

MY MACHINE
- Operating system and version:
- Processor / Chip:
- Installed RAM (or Mac "Memory"):
- Graphics card name:
- Dedicated GPU memory (VRAM):
- Free disk space on the drive where models will live:

APP CHECK
- App I plan to use:
- Its minimum OS:            Do I meet it?  Y / N
- Does it support my chip?   Y / N
- Does it use my graphics card? Y / N / Not sure

MODEL CHECK
- Model and size tag:
- Download size:
- Fits on disk with room to spare?  Y / N
- Comfortably under VRAM (or available RAM)?  Y / N
- Smaller size or quantization available?  Y / N

A sample prompt to help you read your own specs

If the numbers on your screen are confusing, you can paste them into any AI chat (local or free cloud) and ask for a plain reading. Leave out serial numbers and your name.

Here are my computer specs, copied from my settings screen: [paste processor, RAM, graphics card and dedicated memory, free disk space, OS version]. I want to run a local AI model using [app]. Explain in plain English: (1) whether I have a separate graphics card, (2) how much memory is realistically available for a model, (3) what size of model I should try first. Don't guess at numbers you can't see in what I pasted; say "unknown" instead.

That last sentence matters. Ask the AI to say "unknown" rather than fill in blanks. Then check its answer against the official pages linked above. AI explains, it doesn't decide; the app's own requirements page is the authority.

Troubleshooting: when the specs said yes but it still struggles

"It's really slow, even though the model is small"

Run ollama ps. If it says 100% CPU and you expected your graphics card to help, the card may not be supported, or the driver may be too old. Check Ollama's hardware table and driver minimums (Ollama hardware support). On Linux after sleep, Ollama's docs note that "sometimes Ollama will fail to discover your NVIDIA GPU, and fallback to running on the CPU," with a driver-reload workaround on the same page.

"It loaded, but my whole computer froze up"

The model plus everything else exceeded your memory, and the computer started juggling. Close other apps, try a smaller size, or reduce the context length. Ollama's context-length page explains how to adjust it in the app's settings slider or with an environment variable (Ollama: Context length).

"The download failed partway"

Check free disk space first. Then check whether the drive that holds models is the one you think. On Windows, Ollama stores models under your user folder by default (C:\Users\%username%\.ollama\models), per the FAQ (Ollama FAQ). If your C: drive is small, see How to Move Ollama Model Storage to a Second Drive.

"The app won't install at all"

That's almost always the operating system minimum or the chip. Compare against the requirements pages: Ollama on Windows needs "Windows 10 22H2 or newer" (Ollama for Windows); Ollama on Mac needs Sonoma or newer (Ollama for macOS); LM Studio on Windows says "AVX2 instruction set support is required (for x64)" (LM Studio system requirements).

"Output is garbled or nonsense"

That's usually not a hardware problem. See What to Do When Your Local AI Gives Gibberish: Common Fixes.

When the honest answer is "not on this computer"

Sometimes the check says no. The machine is too old for the app, there's very little memory, or the disk is nearly full. That's fine. You have options that don't require buying anything:

• Use a smaller model. The smallest sizes in a family are often surprisingly useful for drafting and summarizing.
• Use a different free app whose requirements you do meet.
• Use a free cloud tier for now. Our How to Use AI Without Paying guide covers free options and their limits, and How to Choose Between Cloud and Local AI for Each Task helps you decide which tasks are fine in the cloud.
• Free up space first. If disk is the only blocker, clearing old downloads may be enough.

What we won't tell you is that you need to buy a new computer. You may want one eventually. You don't need one to start learning.

A word on privacy while you check

Specs screens are safe to read. When you copy specs into an AI chat for help, leave out device names, serial numbers, and anything that identifies you or your household. Processor, RAM, graphics card, and free space are all you need.

Quick checklist

• [ ] I know my RAM (or Mac Memory) figure.
• [ ] I know whether I have a separate graphics card, and its dedicated memory.
• [ ] I know my free disk space on the drive where models will be saved.
• [ ] I checked the app's minimum OS and chip support on its official page.
• [ ] I compared the model's download size against my memory, with room to spare.
• [ ] I started with the smallest size and checked ollama ps (or my app's equivalent).
• [ ] I removed test models I'm not keeping.

FAQ

Is RAM or VRAM more important? If you have a supported graphics card, VRAM decides how big a model runs fast. If you don't, RAM is what counts. On Apple silicon Macs they're the same pool.

Can I run a model bigger than my VRAM? Often yes. Apps can split the model between the graphics card and system memory. Ollama's ollama ps will show a CPU/GPU split when that happens (Ollama FAQ). Expect it to be slower than a model that fits entirely on the card.

Does the download size equal the memory needed? Not exactly. The context (the conversation) needs memory too, and it grows with longer context settings (Ollama: Context length). Use the download size as the floor, not the total.

Do I need an internet connection to check? No. All the settings screens and commands above work offline.

Is there a website that tells me if a model will fit? Some model sites and apps show hints, but the most reliable answer is your own test with a small model and the app's own load report. We'd rather you trust what your machine shows you than a generic chart.

Sources

• Ollama FAQ (model locations, ollama ps processor column): https://docs.ollama.com/faq (fetched 2026-10-08)
• Ollama hardware support: https://docs.ollama.com/gpu (fetched 2026-10-08)
• Ollama for Windows: https://docs.ollama.com/windows (fetched 2026-10-08)
• Ollama for macOS: https://docs.ollama.com/macos (fetched 2026-10-08)
• Ollama context length: https://docs.ollama.com/context-length (fetched 2026-10-08)
• Ollama CLI reference: https://docs.ollama.com/cli (fetched 2026-10-08)
• Ollama source, --verbose flag and eval rate output: https://github.com/ollama/ollama/blob/main/cmd/cmd.go and https://github.com/ollama/ollama/blob/main/api/types.go (fetched 2026-10-08)
• Ollama library, deepseek-r1 sizes: https://ollama.com/library/deepseek-r1 (fetched 2026-10-08)
• LM Studio system requirements: https://lmstudio.ai/docs/app/system-requirements (fetched 2026-10-08)
• Jan Mac install and requirements: https://www.jan.ai/docs/desktop/install/mac (fetched 2026-10-08)
• Continue guide to Ollama: https://docs.continue.dev/guides/ollama-guide (fetched 2026-10-08)
• Hugging Face, Ollama with GGUF: https://huggingface.co/docs/hub/ollama (fetched 2026-10-08)
• Microsoft Support, device information: https://support.microsoft.com/en-us/windows/which-version-of-windows-operating-system-am-i-running-628bec99-476a-2c13-5296-9dd081cdd808 (fetched 2026-10-08)
• Microsoft Support, free up drive space: https://support.microsoft.com/en-us/windows/free-up-drive-space-in-windows-85529ccb-c365-490d-b548-831022bc9b32 (fetched 2026-10-08)
• Microsoft DirectX blog, GPUs in Task Manager: https://devblogs.microsoft.com/directx/gpus-in-the-task-manager/ (fetched 2026-10-08)
• Apple Support, Mac computers with Apple silicon: https://support.apple.com/en-us/116943 (fetched 2026-10-08)
• Apple Support, macOS Sonoma compatibility: https://support.apple.com/en-us/105113 (fetched 2026-10-08)
• Apple Support, free up storage on Mac: https://support.apple.com/en-us/102624 (fetched 2026-10-08)
• free(1), df(1) manual pages: https://man7.org/linux/man-pages/man1/free.1.html and https://man7.org/linux/man-pages/man1/df.1.html (fetched 2026-10-08)
• NVIDIA nvidia-smi documentation: https://docs.nvidia.com/deploy/nvidia-smi/index.html (fetched 2026-10-08)