How to Update Ollama on Windows 11, Mac, Linux (Ubuntu, Kali), WSL and Docker, Update All Your Models, Install a Specific Version, and Fix "Still the Old Version"

There is no ollama update command. How you update Ollama depends on how you installed it. On Windows and Mac, the app downloads new versions by itself: click the Ollama icon in the system tray or menu bar and choose Restart to update, or run the latest installer from ollama.com/download over the old one. On Linux (Ubuntu, Debian, Kali, Fedora and WSL), run the install script again: curl -fsSL https://ollama.com/install.sh | sh. In Docker, pull the new image and recreate the container. Your downloaded models are kept in every case. Models are updated separately, with ollama pull model-name, which downloads only the parts that changed. Check the result with ollama -v; the current release is 0.40.6 (October 17, 2026). Below: each system step by step, PowerShell and winget, Homebrew, installing a specific or older version, updating all your models in one line, and what to do when the version number refuses to change.

Jake's shop runs Ollama on two machines: the front-desk Windows PC and a Linux tower in the back. On Friday, Ethan tried to download a new model for the staff chat and got an error saying the model needed a newer version of Ollama. The front-desk PC had been offering an update in its tray icon for a week, and nobody had clicked it. The Linux tower had never been updated at all, because nobody knew how. Twenty minutes later both were current, and Ethan had written the steps down. Here they are.

New to running AI on your own computer? Our free guide series explains what Ollama and models are in plain English, and the cards below cover the rest.

Why updating Ollama matters more than for most apps

Most apps work fine for months without an update. Ollama is different, because new AI models keep arriving with new internal designs, and each design needs code in Ollama before it can load. In just one week of October 2026:

• 0.40.4 (October 12) added ollama run --ask for decision models, a command that did not exist before. Our decision models guide shows what it does.
• 0.40.5 (October 14) added support for NVIDIA's Nemotron 3.5 models.
• 0.40.6 (October 17) added the file type that PrismML's Bonsai 2 models use. On anything older, ollama pull bonsai-2 simply fails; our Bonsai 2 guide has the details.

So if a model page says "requires Ollama 0.40.6 or later," it means it: an older version cannot read the file at all. Updates also bring speed improvements and support for newer graphics cards, and occasionally they need a newer graphics driver in return. That is why the last section of this page covers what to check afterwards.

Jake: "So every time there's a new model, we update?"

Ethan: "Every time there's a new kind of model. A new size of an old model usually works on what you have. A brand-new family usually doesn't."

Check which version of Ollama you have

In a terminal (Command Prompt, PowerShell, Terminal on a Mac, or any Linux shell):

ollama -v
# ollama version is 0.40.6

ollama --version does the same. Every release, with a list of what changed, is at github.com/ollama/ollama/releases. As of October 19, 2026, the newest full release is 0.40.6, and 0.40.7-rc0 is a release candidate (a test build).

Ollama has two parts: the server, which runs in the background and does the work, and the client, the ollama command you type. Normally they are the same version. If ollama -v prints a warning that the client version differs, an old server is still running from before the update, and the fix is to restart it (covered in update problems). To ask the server directly which version it is, which is also how scripts and apps check:

curl http://localhost:11434/api/version
# {"version":"0.40.6"}

What changed in recent Ollama versions (update notes)

Before you update, it helps to know what you are getting. The last three releases, in plain English:

The pattern is typical: roughly one release every few days, each adding support for whatever models arrived that week, plus fixes. A version ending in -rc0, -rc1 and so on is a release candidate, a test build published before the final one; the Windows and Mac apps only offer final releases.

Should you update the moment a version appears? On your own laptop, yes; if something breaks, going back takes one command (see below). On a machine other people depend on, a short wait is sensible: give a new release two or three days, read its notes for anything about your graphics card, and update when you have a few minutes to check the result. The exception is a release that adds a model you need, in which case the update is the whole point.

Is there an "ollama update" command?

No, and this trips up many people. ollama update gives an "unknown command" error, and ollama --help lists no update command. The command that does exist, ollama pull, updates a model, not Ollama itself. Ollama is updated the way it was installed: by the app's own updater on Windows and Mac, by the install script on Linux, by a new image in Docker, or by Homebrew or winget if you used one of those.

The table is the whole page in one place; the sections after it give each one step by step.

Not sure which one you used? On Windows, if Ollama appears in Settings → Apps with an Uninstall button, it came from the installer or winget. On a Mac, an Ollama app in Applications means the app; brew list ollama printing files means Homebrew. On Linux, systemctl status ollama showing a service means the install script.

Update Ollama on Windows 11 and Windows 10

The easy way: let the app do it. The Windows app checks for new versions and downloads them in the background. When one is ready, the Ollama icon in the system tray (bottom right, near the clock; click the small arrow if you do not see it) offers Restart to update. Click it, and Ollama closes, installs the new version and starts again in a few seconds. Then check:

ollama -v

Open a new PowerShell or Command Prompt window for that check; a window that was open during the update can still point at old settings.

The manual way: run the installer again. Download OllamaSetup.exe from ollama.com/download and run it. It installs over the existing version; your models in C:\Users\YourName\.ollama and your settings stay where they are. Quit Ollama first (right-click the tray icon, then Quit) so no files are in use.

From PowerShell, the same thing in two lines, handy for a PC you reach over remote desktop:

Invoke-WebRequest https://ollama.com/download/OllamaSetup.exe -OutFile "$env:TEMP\OllamaSetup.exe"
Start-Process "$env:TEMP\OllamaSetup.exe"

Add -ArgumentList '/VERYSILENT' to the second line to install without the setup window, for example from a script that updates several PCs. If you installed Ollama to a custom folder with /DIR="D:\Ollama" the first time, pass the same /DIR again.

If you installed with winget:

winget upgrade Ollama.Ollama

winget upgrade on its own lists everything with an update waiting, Ollama included. The winget catalog sometimes lags a day or so behind Ollama's own release; if it says no update is available while a newer version is already out, use the installer.

If you use the standalone zip (ollama-windows-amd64.zip, for people who run ollama serve themselves or as a service), nothing updates automatically. Stop the server, download the new zip, and replace the old files with the new ones, including the lib folder.

Where things live on Windows, in case you need them: the program installs under your user profile (by default in %LOCALAPPDATA%\Programs\Ollama), models and settings are in %HOMEPATH%\.ollama, and logs plus downloaded update files are in %LOCALAPPDATA%\Ollama. Paste any of those into File Explorer's address bar to open it. The newest server log is server.log; older ones are server-1.log and so on.

Jake: "That little 'Restart to update' was sitting there all week?"

Ethan: "All week. Ollama downloads the update quietly and waits for permission, so nothing restarts in the middle of someone's chat."

Update Ollama on a Mac

The Mac app works like the Windows one. It downloads new versions on its own; click the Ollama icon in the menu bar and choose Restart to update. To update by hand, quit Ollama from the menu bar, download the Mac app from ollama.com/download, and drag it into Applications, replacing the old one. Models in ~/.ollama are not touched.

Check with ollama -v in Terminal. Current versions need macOS Sonoma 14 or later, so an older Mac may stay on the last version that supports it.

If you installed with Homebrew, the app's updater is not involved; Homebrew owns it:

brew update
brew upgrade ollama
brew services restart ollama   # if you run it as a Homebrew service

Homebrew's copy updates when its maintainers publish the new version, which can be a little after Ollama's own release. If you need a brand-new version the same day, the app from ollama.com is faster. Running both the app and a Homebrew copy at once leads to version confusion, covered in the problems section; pick one.

Mac logs, if an update misbehaves: ~/.ollama/logs/server.log for the server and ~/.ollama/logs/app.log for the menu bar app.

Update Ollama on Linux: Ubuntu, Debian, Kali and Fedora

On Linux, updating means running the same install script again:

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

That one command works on Ubuntu, Debian, Kali, Fedora, Rocky and most other distributions. It asks for your password through sudo when it needs it, so run it as your normal user with sudo rights. What it does, so nothing surprises you:

• It removes the old Ollama libraries and puts the new version in place, normally under /usr/local, with the ollama command in /usr/local/bin.
• It keeps your models, which the service stores in /usr/share/ollama/.ollama/models.
• It rewrites the systemd service file, /etc/systemd/system/ollama.service, and restarts the service.
• It checks for an NVIDIA or AMD card and fetches the right pieces for it.
• It ends with "Install complete."

Then confirm:

ollama -v
systemctl status ollama
journalctl -e -u ollama     # the latest log lines

The one setting that gets lost. Because the script rewrites ollama.service every time, any change you typed into that file yourself (for example Environment="OLLAMA_HOST=0.0.0.0" so other machines can reach it) is gone after the update. The fix is to keep your settings in an override file, which the script leaves alone:

sudo systemctl edit ollama
# in the editor that opens, add:
[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_KEEP_ALIVE=30m"
# save, then:
sudo systemctl daemon-reload
sudo systemctl restart ollama

That creates /etc/systemd/system/ollama.service.d/override.conf, which survives every future update. If your other computers suddenly "could not connect" after an update, a lost OLLAMA_HOST line is the first suspect; our could not connect to Ollama guide covers the rest.

Updating without the script (air-gapped machines, or if you prefer to see each step). Download the archive for your processor, remove the old libraries, and unpack the new files where your current copy lives (/usr/local for script installs). The archive is compressed with zstd, so install that first (sudo apt install zstd):

sudo systemctl stop ollama
sudo rm -rf /usr/local/lib/ollama
curl -fsSL https://ollama.com/download/ollama-linux-amd64.tar.zst | sudo tar --zstd -x -C /usr/local
sudo systemctl start ollama

Use ollama-linux-arm64.tar.zst on ARM machines. AMD GPU users also unpack ollama-linux-amd64-rocm.tar.zst the same way.

Kali Linux needs nothing special: it is Debian-based and runs systemd, so the script and the steps above work as written. On a Kali live USB session, nothing you install survives a reboot unless you use persistence, so "updating" there just means installing again.

Update Ollama in WSL

If you run Ollama inside WSL (Ubuntu on Windows), update it with the Linux script, run inside the WSL terminal. Two things are specific to WSL:

• Windows Ollama and WSL Ollama are two separate installs. Updating the Windows app does nothing to the copy inside WSL, and the reverse. ollama -v in PowerShell and in the WSL terminal can show different numbers, and both can be right. Many people only need one; if you have both, they also compete for port 11434.
• systemd. On WSL 2 without systemd, the script installs Ollama but cannot set up the service, and it prints a warning with a link explaining how to turn systemd on. Either turn it on (current Ubuntu images for WSL have it on already) or start the server yourself with ollama serve after each update. WSL 1 is not supported at all.

Update Ollama in Docker

A container is updated by replacing it with one made from the newer image. Your models live in the volume, so they stay. With Docker Compose:

docker compose pull
docker compose up -d
docker compose exec ollama ollama -v

With plain docker run, pull the image, remove the container, and run the same command you used before:

docker pull ollama/ollama
docker rm -f ollama
docker run -d --name ollama --restart unless-stopped --gpus=all -v ollama:/root/.ollama -p 127.0.0.1:11434:11434 ollama/ollama

Use the exact same volume name (-v ollama:/root/.ollama), or the new container starts with no models. docker image prune afterwards frees the space the old image used. AMD users pull ollama/ollama:rocm instead.

If you pin a version (recommended on servers), the image tag in your Compose file is the version, and docker compose pull alone changes nothing. Edit the number, then apply it:

services:
  ollama:
    image: ollama/ollama:0.40.6     # was 0.40.5; change the number to update
# then:
docker compose up -d

Going back is the same edit in reverse. To see which image a container is really using, docker compose images lists each service's image and tag, and docker image ls ollama/ollama shows every Ollama image on the machine with its creation date.

Inside a container, the Ollama app's automatic updater does not exist; the image is the version. That is exactly why Docker suits machines that should change only when you decide. Our Ollama in Docker guide covers the full setup, pinning a version tag, and a Compose file with Open WebUI.

Install a specific version, a pre-release, or go back to an older one

Sometimes the newest version is not what you want: a new release has a bug that hits your graphics card, a tool you use has not caught up yet, or a model needs a release candidate that is not final.

On Linux, the install script takes the version you ask for, including release candidates and older versions:

curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION=0.40.5 sh       # go back to 0.40.5
curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION=0.40.7-rc0 sh   # try the release candidate

Any number listed at github.com/ollama/ollama/releases works. To return to the newest release later, run the script without OLLAMA_VERSION.

On Windows, open the GitHub releases page, find the version you want, and download OllamaSetup.exe from that release's Assets list. Quit Ollama, run it, and it replaces whatever version you have, newer or older. Release candidates are marked "Pre-release" on that page.

On a Mac, download the Mac app file from the same release's Assets and replace the app in Applications.

In Docker, use a version tag instead of latest, such as ollama/ollama:0.40.5, and recreate the container.

Keep in mind that on Windows and Mac the app will soon download the newest version again and offer Restart to update. It does not install it until you click, so staying on an older version means simply not clicking until the problem is fixed upstream. Models you downloaded on a newer version may need that newer version; if one stops loading after a downgrade, that is why.

Jake: "And if an update breaks the back-room PC on a Saturday?"

Ethan: "One line with the old version number, and it's back to Friday. Then we wait for the fix."

Update your models with ollama pull

Models are separate from Ollama itself, and they do not update on their own. When a model's publisher improves it (a fixed chat template, better quantization, a new checkpoint under the same tag), you get the new copy by pulling it again:

ollama pull llama3.2

Ollama compares what you have with what the library has, downloads only the parts that changed, and keeps the rest. If nothing changed, it finishes in a second or two with "success." The model's ID in ollama list changes when you actually got a new version.

Update all your models at once. On Linux, Mac or WSL:

ollama list | awk 'NR>1 {print $1}' | xargs -n1 ollama pull

In Windows PowerShell:

ollama list | Select-Object -Skip 1 | ForEach-Object { $name = ($_ -split '\s+') | Select-Object -First 1; ollama pull $name }

Both read the model names from ollama list, skip the header line, and pull each one in turn. Large models take a while even when little changed, because Ollama checks every part; run it when you do not need the PC for a few minutes.

Tags and "versions" of a model. A model name like llama3.2 is short for llama3.2:latest, and latest can move to a newer build. A specific tag such as llama3.2:1b names a size, and usually stays put. If you need a model to stay exactly as it is, for example because your app depends on its answers, copy it to your own name with ollama cp llama3.2 llama3.2-frozen; your copy never changes when you pull the original. ollama show llama3.2 prints a model's details, including its parameters and template, if you want to compare before and after.

Custom models you built with ollama create from a Modelfile are not updated by a pull of their base model. Pull the base, then run your ollama create command again to rebuild on top of it.

Update Ollama and models on a computer without internet

Some machines are offline on purpose: a lab PC, a server on a closed network, a laptop that only connects at the office. You can still update them by downloading on one computer and copying across.

Ollama itself:

1. On a connected computer, download the right file: OllamaSetup.exe for Windows, the Mac app, or ollama-linux-amd64.tar.zst (plus ollama-linux-amd64-rocm.tar.zst for AMD cards) for Linux.
2. Copy it to the offline machine on a USB drive or over the local network.
3. On Windows or Mac, quit Ollama and run or drag in the new copy, as in the sections above.
4. On Linux, stop the service, remove the old libraries and unpack the archive, using the "updating without the script" commands above with the local file in place of the download: sudo tar --zstd -x -C /usr/local -f ollama-linux-amd64.tar.zst.
5. Start Ollama again and check ollama -v.

Models: a model is just files in the models folder, split into blobs (the large data files) and manifests (the small files that name them). Pull the model on the connected computer, then copy the whole models folder, or at least the new blobs and the model's manifest, to the same place on the offline machine. On Linux with the standard service, give the files back to the service account afterwards, or Ollama cannot read them:

sudo chown -R ollama:ollama /usr/share/ollama/.ollama/models
sudo systemctl restart ollama
ollama list

Both machines should run the same Ollama version, or at least the offline one should not be older; a model pulled by a newer version may need that version to load.

Updating the Ollama Python and JavaScript libraries, and Open WebUI

Three things share the Ollama name or sit right on top of it, and updating Ollama does not update any of them.

The Python library (import ollama) is a client that talks to the Ollama server over its API. Installing or updating it does not install or update Ollama itself, which surprises many people who ran pip install ollama and expected the server to appear. Update it inside your project's environment:

pip install -U ollama

The JavaScript library is the same idea for Node.js projects:

npm install ollama@latest

The library and the server have separate version numbers. A new library usually works with an older server for the basics, but a new feature in the library (a new option or endpoint) only does something if the server is new enough to understand it. When something new does not work from code, update the server first.

Open WebUI, the chat page many people put in front of Ollama, has its own releases. In Docker, pull its image and recreate the container, the same way as Ollama:

docker pull ghcr.io/open-webui/open-webui:main
# then recreate the open-webui container with your usual command,
# or with Compose: docker compose pull && docker compose up -d

If you installed it with pip, run pip install -U open-webui in the same environment. Your chats and accounts live in its data volume or folder and are kept. Updating Ollama and Open WebUI together, then sending one test message, catches most surprises in one go.

Does Ollama update automatically?

On a server, "no automatic updates" is a feature: nothing changes under you on a busy day. To keep a Linux machine current without remembering, a weekly scheduled job works. Run sudo crontab -e and add this line, which updates every Sunday at 3 a.m.:

0 3 * * 0 curl -fsSL https://ollama.com/install.sh | sh >> /var/log/ollama-update.log 2>&1

Whether that is wise depends on the machine. For a shop's staff chat, a weekly update is fine. For an app that customers rely on, update by hand, check, and keep the previous version number written down.

After the update: a two-minute check

1. Version: ollama -v shows the new number, with no warning about the client version.
2. Models: ollama list shows the same models as before.
3. GPU: run a model, then ollama ps. The PROCESSOR column should still say 100% GPU (or the same split as before). If it now says 100% CPU, see the next section.
4. Your settings: on Linux, if other machines or containers connect to this one, check that they still can; that is where a lost OLLAMA_HOST shows up.
5. Your apps: open Open WebUI or whatever uses Ollama and send one message.

Was it faster or slower? Updates often change speed, usually for the better, occasionally not for your particular card. To know rather than guess, measure the same model with the same question before and after. The --verbose flag prints timings after each answer:

ollama run llama3.2 --verbose "Explain what a CPU does in three sentences."
# ...
# eval rate:            61.42 tokens/s

The eval rate line is how fast the model writes its answer, in tokens per second. Run it two or three times, because the first run includes loading the model. A drop of a few percent is noise; a drop by half usually means the model moved from the GPU to the processor, which ollama ps confirms. Write the number down before you update, and you have a baseline for every update after.

Update problems and how to fix them

The version number did not change. This is the most common complaint, and it nearly always has one of three causes:

• The old server is still running. The new files are on disk, but the server in memory is the old one, and ollama -v warns that the client and server versions differ. On Windows, right-click the tray icon, Quit, and start Ollama from the Start menu; if the tray icon is gone but the warning stays, end any ollama.exe processes in Task Manager. On a Mac, Quit from the menu bar and open the app again. On Linux, sudo systemctl restart ollama.
• Two copies are installed, and the old one comes first. On Windows, run where.exe ollama; more than one path means an old zip copy or second install is shadowing the new one. On Linux and Mac, which -a ollama does the same. A common case on Linux: an old manual install in /usr/bin and the script's copy in /usr/local/bin, or the reverse. Remove the one you do not use. On a Mac, a Homebrew copy and the app together cause the same confusion.
• You updated a different install. Windows and WSL, or the host and a Docker container, are separate copies. Update the one your apps actually talk to.

A model says it requires a newer version of Ollama. The model uses a format your version cannot read. Update, then pull the model again. If you just updated and still see it, the old-server problem above is why.

The GPU stopped being used after the update. New Ollama versions sometimes need a newer graphics driver: on Windows, NVIDIA driver 551.61 or later, and AMD cards need a driver stack for ROCm 7 (or a current driver for Vulkan). Update the driver, reboot, and check ollama ps again. Our Ollama GPU guide shows how to read the log line that names the problem.

A model that used to fit now says it needs more memory. Defaults such as the context length can change between versions, and a larger context takes more memory. Set a smaller context, or see our "requires more system memory" guide.

The Linux script fails. "This script requires superuser permissions" means your account has no sudo; run it as one that does, or as root. A download that times out behind a company network needs a proxy: export HTTPS_PROXY=http://proxy.example.com:3128 before running the script. On WSL 1, the script refuses to run; convert the distribution to WSL 2 with wsl --set-version Ubuntu 2 in PowerShell.

The Windows update never finishes, or the installer says files are in use. Quit Ollama from the tray, end any remaining ollama processes in Task Manager, and run OllamaSetup.exe again. Antivirus software that holds files open can cause the same message; a reboot before installing clears it.

Settings disappeared on Linux. They were in ollama.service, which the script rewrites. Move them to the override file with sudo systemctl edit ollama, as shown in the Linux section.

Docker models vanished after updating. The new container uses a different volume name, or none. docker volume ls lists the volumes; run the container again with the one that holds your models.

When an update goes wrong: a clean reinstall that keeps your models

If an update leaves Ollama refusing to start, and restarting and the version checks above have not helped, a clean reinstall usually settles it. The one thing to protect is your models, which can be tens of gigabytes you would rather not download again.

Windows. The uninstaller can remove the models in the default folder along with the program; only models you moved elsewhere with OLLAMA_MODELS are certain to survive. So move them out first:

1. Quit Ollama from the tray.
2. Move the models folder from %HOMEPATH%\.ollama to somewhere safe, such as D:\ollama-models.
3. Uninstall Ollama in Settings → Apps → Installed apps.
4. Run the newest OllamaSetup.exe.
5. Either move the folder back into %HOMEPATH%\.ollama, or leave it on D: and set a user environment variable OLLAMA_MODELS to D:\ollama-models, then restart Ollama.

Leaving the models on a second drive with OLLAMA_MODELS has a bonus: future reinstalls never touch them, and your C: drive gets its space back.

Mac. Quit Ollama, then remove the app and the command-line link, but leave ~/.ollama alone, because that is where the models are:

sudo rm -rf /Applications/Ollama.app
sudo rm /usr/local/bin/ollama

Download the app again, drag it into Applications and open it; it recreates the command-line link and finds the existing models.

Linux. Remove the service and the program, keep /usr/share/ollama (the models), and run the script again:

sudo systemctl stop ollama
sudo systemctl disable ollama
sudo rm /etc/systemd/system/ollama.service
sudo rm -rf /usr/local/lib/ollama /usr/lib/ollama
sudo rm -f /usr/local/bin/ollama /usr/bin/ollama
curl -fsSL https://ollama.com/install.sh | sh

Your override file in ollama.service.d is still there, so your settings come back with the service. A full uninstall would also delete /usr/share/ollama and the ollama user; skip those two steps when the goal is a fresh program with the same models.

Updating Ollama on several computers

Jake's shop has two machines; a small office might have ten. Doing each one by hand is fine at two and tedious at ten.

Windows PCs installed through winget can be updated with one line each, without prompts, which also suits a scheduled task:

winget upgrade --id Ollama.Ollama --silent --accept-package-agreements --accept-source-agreements

Linux machines you reach over SSH can be updated in a loop from one terminal. Each machine asks for its sudo password unless you have set up key-based login with passwordless sudo for this:

for host in tower1 tower2 lab-pc; do
  ssh -t "$host" 'curl -fsSL https://ollama.com/install.sh | sh && ollama -v'
done

Docker hosts follow the Compose routine on each: docker compose pull, then docker compose up -d. If all of them use the same Compose file from a shared folder or a Git repository, updating the pinned version number in one place and running up -d everywhere keeps every machine on exactly the same version, which makes problems much easier to compare.

Whatever the method, update one machine first, run the two-minute check, and only then do the rest. A bad surprise on one PC is an inconvenience; on all of them at once, it is the afternoon gone.

Jake: "So next time, the back room first, then the front desk?"

Ethan: "Exactly. The customers never see the back room."

Frequently asked questions

By Friday evening both of Jake's machines said 0.40.6, the new model was on the staff chat, and Ethan had moved the Linux tower's network setting into an override file so the next update would not undo it. He taped a card to the back-room monitor: "Windows: tray, Restart to update. Linux: the curl line. Models: ollama pull." Jake read it twice and asked why nobody had written that down before. "Somebody just did," said Ethan.

Revision note. Written October 19, 2026, with Ollama 0.40.6 as the current release. The fastest update is the one you click when it is offered, not the one you remember on a Saturday.