How to Download an AI Model to Your Computer and Run It Locally in 2026

"Download an AI" means two different things in 2026. The first is the DeepSeek or ChatGPT app from the store, which computes nothing itself and just talks to the cloud. The second is a local model: a file of weights that sits on your disk and runs on your CPU or GPU with no internet. This article is about the second one.

If you're reading this, you probably already own something serious: an RTX 4070 or 4090, a fresh 50-series card, or maybe a MacBook Pro with an M4 Max and 64 GB of memory. That hardware sits idle most of the day: a GPU works a couple of hours in games, while 24 GB of VRAM holds a model like Qwen3.8 27B that writes code and reads documents about as well as cloud services did a year ago; 16 GB fits gpt-oss 20B and Gemma 4 12B. Even an RTX 3060 12 GB or an M2 Mac with 16 GB is a working machine for a local model, just with a smaller one.

Below: what exactly you download, how much memory each model size needs, which open models are worth it, how to install Ollama and LM Studio step by step, and what breaks on the first evening. At the end, an honest line: where a local model beats the cloud and where it loses.

What you're actually downloading

A local neural network is two files:

1. A runner: the program that loads the model into memory and exposes it through a chat or an API. Almost every home runner uses the llama.cpp engine inside.
2. Model weights in GGUF format. One file per model, usually in Q4_K_M quantization: weights compressed to 4 bits, a file 3–4 times smaller than the original, with a quality loss of a few percent on typical tasks. Size rule of thumb: about 0.6 GB per billion parameters, plus 1–2 GB for context.

Runners worth installing in 2026:

GPT4All didn't make the table: its last release, 3.10, came out in February 2025, and it doesn't support new models.

How much memory you need

The whole model has to fit in GPU memory (VRAM) or, on Apple Silicon Macs, in unified memory. If it doesn't fit, the runner offloads part of the layers to regular RAM and speed drops several times over. So model selection starts not with benchmarks but with the number on your graphics card's box.

The "memory needed" column assumes an 8–32K token context. A 64–128K context doubles the footprint, which is why "the model loaded fine but crashed on a long document" is the most common mistake.

Hardware notes:

• NVIDIA. Anything from the GTX 750 Ti up works, driver 551.61+. Reference points from public benchmarks: an RTX 5090 does about 140 tokens per second on an 8B Q4 model and 50–60 on a 32B; a 16 GB card does 20–50 on a 14B.
• Apple Silicon. Unified memory counts as VRAM, and Ollama and LM Studio use the MLX engine. From the llama.cpp benchmark table on a 7B Q4 model: M4 gives 24 tokens per second, M4 Max 83, M5 Max 120. Intel Macs: Ollama runs on the CPU only, LM Studio doesn't launch at all.
• AMD and Intel Arc. AMD through ROCm 7 or Vulkan, Intel Arc through Vulkan in Ollama and SYCL builds of llama.cpp. It works, but slower than NVIDIA of the same class and with driver caveats.
• CPU only. An 8B Q4 model on a DDR5 desktop gives roughly 8–15 tokens per second, readable in real time. The bottleneck is memory bandwidth, not cores. MoE models with 3B active parameters (Qwen3.5 35B-A3B, GLM-4.7-Flash) are noticeably faster on a CPU than dense models of the same weight.

If you have a laptop with 8 GB of RAM and no GPU, only 2–4B models really run, and a conversation with them hits the ceiling fast.

Option 1: Ollama in three commands

Ollama installs like a regular program and adds the ollama command to your terminal. Since 2025 it also ships a chat app, so the terminal is only needed for installation.

Windows: the OllamaSetup.exe installer with no admin rights, or:

winget install Ollama.Ollama

macOS: a DMG from the site or Homebrew:

brew install --cask ollama-app

Linux:

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

Now the first model. The command downloads 6.6 GB and opens a chat in the terminal:

ollama run qwen3.5:9b

Useful commands for the first week:

Two settings you'll change almost immediately:

• Context. By default Ollama picks the window by VRAM size: under 24 GB it's only 4K tokens, and a long document simply gets cut off. There's a slider in the app; for the server, set OLLAMA_CONTEXT_LENGTH=32000. Remember the table above: a longer context means more memory.
• Where models live. Windows: %HOMEPATH%\.ollama, macOS: ~/.ollama/models, Linux: /usr/share/ollama. To move them to another drive, set the OLLAMA_MODELS environment variable and restart.

The API is OpenAI-compatible: any client that can talk to api.openai.com can be pointed at http://localhost:11434/v1 with any key. That's also what makes Ollama a backend for Claude Code, opencode and Cline; the ollama launch command wires them up by itself.

Option 2: LM Studio for people who don't want a terminal

LM Studio is an app with three screens: model search, chat and a local server. Free for work use since July 2025, with community translations of the interface.

Requirements: 16 GB of RAM recommended, a GPU with 4 GB or more on Windows, a CPU with AVX2. On Mac, Apple Silicon only, macOS 14+. There's a Windows on ARM build (Snapdragon X).

Steps:

1. Download the installer from lmstudio.ai, or run winget install ElementLabs.LMStudio / brew install --cask lm-studio.
2. Open the search tab and type qwen3.5 or gemma-4. The app shows which quantization fits your memory and flags the ones that won't.
3. Download, switch to the chat, load the model. Context and GPU offload settings are in the right panel.

The Server tab deserves a separate mention: LM Studio starts an OpenAI-compatible API on localhost:1234, supports MCP tools and a headless mode through the lms CLI. Version 0.4.16 added LM Link and the Locally app for iPhone, so the model runs on your home PC while you chat from your phone.

Which to pick: Ollama if you plan to plug the model into other programs and scripts, LM Studio if the main scenario is "open it and ask". Both can live on one computer at the same time.

Which model to download in 2026

There are plenty of open models now, and most of them handle many languages without fine-tuning. The table lists what's actually worth running at home, with Ollama tags:

Every license in the table allows commercial use without royalties.

A practical pick by memory:

• 8 GB VRAM or a 16 GB Mac: qwen3.5:9b or gemma4:e4b.
• 12–16 GB: gemma4:12b, gpt-oss:20b, deepseek-r1:14b.
• 24 GB: qwen3.8:27b for general work, glm-4.7-flash or qwen3.5:35b for agents and speed.
• CPU only, 32 GB RAM: qwen3.5:35b: 3B active parameters, so it runs faster than a dense 9B.

"Download DeepSeek to PC": what's actually possible

DeepSeek is searched for as a download more than any other model, so it gets its own section. The flagship DeepSeek V4 is 1.6 trillion parameters; V4 Flash is 284 billion. V4 Flash weights are open under MIT, but the Q4 file is about 155 GB and running it takes around 180 GB of memory. That doesn't go in a home PC, and in the Ollama library V4 is available only with the :cloud tag, meaning through Ollama's cloud.

Locally, the only things carrying the DeepSeek name are the 2025 R1 distills (deepseek-r1:8b, :14b, :32b). These are Qwen and Llama models fine-tuned on R1's answers: they can reason, but they're far from V4. If you need V4 itself, it's in GPTunneL: 1 million tokens of context, pay per token, no subscription.

Images, video and speech locally

Text is the lightest modality. The rest works too, but asks more of your GPU:

• Images. The 2026 standard is ComfyUI (there's a desktop installer). Models: FLUX.2 [klein] 4B under Apache 2.0 runs on 8–12 GB of VRAM in 4 steps; the 9B version and the full FLUX.2 [dev] 32B are non-commercial only. Stable Diffusion 3.5 (Medium 2.5B / Large 8B) is still relevant, and Stability hasn't released a successor. Qwen-Image 20B is open, but Qwen-Image 2.0 is cloud-only. For artists there's the Krita AI plugin, which sets up ComfyUI itself.
• Video. Open Wan weights stopped at version 2.2 (the 5B variant runs on 8 GB); 2.5 and newer are API-only, with no local option. LTX-2.5 from Lightricks is 22B with audio generation and has quantizations for 12–16 GB. Count minutes per clip, not seconds.
• Speech. Recognition: whisper.cpp, solid across major languages. Text-to-speech: Piper has voices for dozens of languages; Kokoro and Fish Audio S2 are open, but check whether your language is in the official voice list.

What breaks on the first evening

• The model loaded but answers one word per second. It didn't fit in VRAM, and part of the layers went to RAM. Check ollama ps: the processor column should say 100% GPU. The fix is a lower quantization or a smaller model.
• A long document got cut off. Ollama's default 4K context on cards under 24 GB. Raise OLLAMA_CONTEXT_LENGTH, then re-check that the model still fits.
• SmartScreen and Defender. The Ollama installer sometimes stops at a SmartScreen warning: "More info → Run anyway". Windows Defender regularly flags llama.cpp DLLs and KoboldCpp archives as trojans; these are false positives documented in a llama.cpp issue. Download only from official sites and GitHub releases, and an antivirus exception is safe.
• Hugging Face won't download. In some regions large downloads from Hugging Face are flaky: some requests go through, some drop. The Ollama library and the LM Studio downloader work directly; for Hugging Face weights there's the ModelScope mirror, which has every Qwen.
• Out of disk. Three 20 GB models plus cache is already 70 GB. The OLLAMA_MODELS variable moves the library to another drive.
• Intel Mac. Ollama is CPU-only, LM Studio won't install. The realistic option is models up to 4B.

Where a local model ends

A local model wins when three things matter: data never leaves the computer, no internet is needed, and there are no limits or token bills at all. For chatting with documents, drafting emails, code completion and API experiments, a 24 GB card is enough.

It loses where you need flagship-level quality. The strongest thing that fits in a home GPU is 27–32B; 400B–2T models (Qwen3.8 Max, DeepSeek V4, Claude Opus 5, GPT-5.5) don't exist locally in any quantization. And for occasional use the cloud is cheaper: tokens cost cents, while a 24 GB GPU takes years to pay off. The same open models in GPTunneL, price per million tokens:

Prices are indicative; current ones are on the pricing page and in your account. With normal chat use, a million tokens lasts for weeks.

The setup almost everyone lands on: a local Qwen or Gemma for routine and private work, and hard tasks to the cloud with a flagship. Both halves are API-compatible, so the same script switches between localhost:11434 and GPTunneL by changing the address and the key.

FAQ

Does a local model work without internet? Yes. You need internet once, to download the runner and the weights. After that everything runs on your hardware, and you can unplug the network.

Is it free? The runners and weights in the tables above are free for both personal and commercial use (Apache 2.0 and MIT licenses). You only pay for hardware and electricity.

Which model handles languages other than English best? Among general-purpose ones, Qwen3.5 and Qwen3.8 (201 languages) and Gemma 4 (140+). Models under 4B are noticeably weaker outside English.

Can I put an AI model on my phone? Android and iPhone have apps with 1–4B models; quality is lower than on a PC and battery drains fast. It's more practical to keep the model on your home computer and connect from the phone: LM Studio has LM Link and the Locally app for that.

How do I remove Ollama completely? Models first: ollama rm for each entry in ollama list. Then the program: on Windows through Apps, on macOS delete Ollama.app, /usr/local/bin/ollama and the ~/.ollama folder, on Linux follow the docs.

Is there a local ChatGPT or Claude? No. OpenAI has opened only gpt-oss (20B and 120B), and Anthropic doesn't publish its weights. Anything called "download ChatGPT for PC" is either a cloud client or someone else's model under a borrowed name.

Download Ollama, install qwen3.5:9b and see whether a model like that is enough for you. When you hit the ceiling, the same open models plus the flagships from OpenAI, Anthropic and Google are collected in GPTunneL: one balance, pay per token, no subscriptions.