Ai on Linuxize

How to Install Claude Code on Ubuntu and Linux

hello@linuxize.com (Linuxize) — Mon, 06 Jul 2026 09:35:00 +0200

Claude Code is Anthropic’s AI coding agent for the terminal. You start it inside a project directory, describe what you want in plain language, and it reads the code, edits files, and runs commands to get there.

This guide covers the recommended native installer first, then the official Linux package-manager repositories and npm alternative for systems that need them.

Prerequisites

Claude Code runs on Ubuntu 20.04+, Debian 10+, and Alpine 3.19+, on x64 or ARM64, with at least 4 GB of RAM. You also need a Claude account: a Pro, Max, Team, or Enterprise plan, or an Anthropic Console account with API billing. The free Claude.ai plan does not include Claude Code access.

Quick Reference

Task	Command
Install, recommended	`curl -fsSL https://claude.ai/install.sh \| bash`
Install with apt, advanced	`sudo apt install claude-code` (after adding the repository)
Install with dnf, advanced	`sudo dnf install claude-code` (after adding the repository)
Install with apk, advanced	`apk add claude-code` (after adding the repository)
Install with npm, alternative	`npm install -g @anthropic-ai/claude-code`
Verify	`claude --version` or `claude doctor`
Start	`claude` (inside a project directory)
Update	`claude update`
Uninstall (native)	`rm -f ~/.local/bin/claude && rm -rf ~/.local/share/claude`

Option 1: The Native Installer (Recommended)

Anthropic’s native installer works on every supported distribution and keeps itself updated in the background:

Terminal
curl -fsSL https://claude.ai/install.sh | bash

As with any piped installer, you can download the script first and read it before running it. The installer places the claude binary in ~/.local/bin and its version data in ~/.local/share/claude; no root privileges are needed. On Alpine and other musl-based distributions, install libgcc, libstdc++, and ripgrep through the package manager first, then set USE_BUILTIN_RIPGREP=0 in the env section of Claude Code’s settings.json.

By default you get the latest release channel. If you prefer the stable channel, which trails by about a week and skips releases with major regressions, install with:

Terminal
curl -fsSL https://claude.ai/install.sh | bash -s stable

Option 2: Linux Package Managers (Advanced)

The native installer is the recommended path for most Linux workstations. Anthropic also publishes official signed apt, dnf, and apk repositories for managed systems where updates should flow through the operating system package manager.

On Ubuntu, Debian, and Derivatives, add the signing key and the apt repository, then install the package:

Terminal
sudo install -d -m 0755 /etc/apt/keyrings
sudo curl -fsSL https://downloads.claude.ai/keys/claude-code.asc -o /etc/apt/keyrings/claude-code.asc
echo "deb [signed-by=/etc/apt/keyrings/claude-code.asc] https://downloads.claude.ai/claude-code/apt/stable stable main" | sudo tee /etc/apt/sources.list.d/claude-code.list
sudo apt update
sudo apt install claude-code

Before trusting the key, verify its fingerprint:

Terminal
gpg --show-keys /etc/apt/keyrings/claude-code.asc

The reported fingerprint should be 31DD DE24 DDFA B679 F42D 7BD2 BAA9 29FF 1A7E CACE. Package manager installations do not auto-update; new versions arrive through your normal sudo apt update && sudo apt upgrade workflow.

On Fedora, RHEL, and Derivatives, create a dnf repository file and install the package:

Terminal
sudo tee /etc/yum.repos.d/claude-code.repo <<'EOF'
[claude-code]
name=Claude Code
baseurl=https://downloads.claude.ai/claude-code/rpm/stable
enabled=1
gpgcheck=1
gpgkey=https://downloads.claude.ai/keys/claude-code.asc
EOF
sudo dnf install claude-code

When dnf prompts you to accept the signing key, verify that the fingerprint matches 31DD DE24 DDFA B679 F42D 7BD2 BAA9 29FF 1A7E CACE. To upgrade later, run:

Terminal
sudo dnf upgrade claude-code

On Alpine Linux, download the repository key, add the stable repository, and install the package:

Terminal
wget -O /etc/apk/keys/claude-code.rsa.pub https://downloads.claude.ai/keys/claude-code.rsa.pub
echo "https://downloads.claude.ai/claude-code/apk/stable" >> /etc/apk/repositories
apk add claude-code

Verify the downloaded Alpine key before trusting it:

Terminal
sha256sum /etc/apk/keys/claude-code.rsa.pub

The checksum should be 395759c1f7449ef4cdef305a42e820f3c766d6090d142634ebdb049f113168b6. To upgrade later, run apk update && apk upgrade claude-code.

Option 3: npm

If you already manage global tools through npm, Claude Code is available as a package. It requires Node.js 22 or later:

Terminal
npm install -g @anthropic-ai/claude-code

The package downloads the same native binary the standalone installer uses, so the installed claude command does not run through Node.js at runtime.

Warning

Do not run npm install -g with sudo. It creates root-owned files in your npm directory and breaks later updates. If the install fails with permission errors, configure npm to use a user-writable global prefix instead.

To upgrade an npm installation later, run npm install -g @anthropic-ai/claude-code@latest.

Verifying the Installation

Confirm the binary is on your PATH and working:

Terminal
claude --version

output

2.1.201 (Claude Code)

Your version number will differ. For a fuller health check covering the installation type, auto-update status, and configuration, run:

Terminal
claude doctor

Start Claude Code from inside the project you want to work on, since it uses the current directory as its workspace:

Terminal
cd ~/projects/my-app
claude

On the first run it opens a browser window to sign in. Log in with your Claude.ai account (Pro, Max, Team, or Enterprise) or with an Anthropic Console account if you pay per API usage. After authenticating once, the session is stored and you go straight to the prompt on subsequent runs. From there, try something small first, for example explain this project or summarize what app.js does.

Updating Claude Code

Native installations check for updates on startup and install them in the background, so normally there is nothing to do. To force an update immediately:

Terminal
claude update

Package-manager installations update with the system. Use sudo apt update && sudo apt upgrade claude-code on Ubuntu and Debian, sudo dnf upgrade claude-code on Fedora and RHEL, and apk update && apk upgrade claude-code on Alpine. Npm installations update with npm install -g @anthropic-ai/claude-code@latest.

Uninstalling Claude Code

For the native installer, remove the binary and version data:

Terminal
rm -f ~/.local/bin/claude
rm -rf ~/.local/share/claude

For apt, remove the package and repository configuration:

Terminal
sudo apt remove claude-code
sudo rm /etc/apt/sources.list.d/claude-code.list /etc/apt/keyrings/claude-code.asc

For dnf, remove the package and repository file:

Terminal
sudo dnf remove claude-code
sudo rm /etc/yum.repos.d/claude-code.repo

For apk, remove the package, repository entry, and key:

Terminal
apk del claude-code
sed -i '\|downloads.claude.ai/claude-code/apk|d' /etc/apk/repositories
rm /etc/apk/keys/claude-code.rsa.pub

For npm, run npm uninstall -g @anthropic-ai/claude-code. User settings and session history live in ~/.claude and ~/.claude.json; delete those too if you want to remove user-level state. Claude Code can also create project-level .claude directories and .mcp.json files, so remove those from individual projects only when you no longer need their saved settings.

Troubleshooting

claude: command not found after installing
The native installer puts the binary in ~/.local/bin, which some shells do not have on their PATH. Add it to your shell profile and reload:

Terminal
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

npm prints an EBADENGINE warning
Your Node.js is older than version 22. The install usually still completes, since the package ships a native binary, but upgrading Node.js removes the warning and matches the supported configuration.

Sign-in loop or “This account does not have access”
Claude Code is not included in the free Claude.ai plan. Log in with a Pro, Max, Team, or Enterprise account, or use an Anthropic Console account with billing set up.

Conclusion

The one-line native installer is the right choice for most machines, the apt repository fits servers that standardize on package-manager updates, and npm works where Node.js tooling is already in place; all three install the same binary. Once you are set up, Claude Code pairs naturally with the GitHub CLI for turning its changes into commits and pull requests, and if you prefer running models locally, see our guide to Ollama on Ubuntu .

How to Install NVIDIA CUDA Toolkit on Ubuntu 26.04

hello@linuxize.com (Linuxize) — Sat, 27 Jun 2026 09:35:00 +0100

When you want to train models, compile GPU code, or run local AI tools on Ubuntu, the NVIDIA driver alone is not always enough. Development tools and many build workflows also need the NVIDIA CUDA Toolkit, which provides the nvcc compiler, CUDA libraries, profiling tools, and headers used by PyTorch, TensorFlow, llama.cpp, ComfyUI, and other GPU-aware software.

This guide explains how to install the CUDA Toolkit on Ubuntu 26.04 using two methods: the Ubuntu archive package, which is the simplest path for casual use, and the NVIDIA developer repository, which provides the latest CUDA release and matching drivers.

Quick Reference

Task	Command
Check for an NVIDIA GPU	`lspci
Install from Ubuntu archive	`sudo apt install nvidia-cuda-toolkit`
Install Ubuntu-recommended driver	`sudo ubuntu-drivers install`
Download NVIDIA keyring	`wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2604/x86_64/cuda-keyring_1.1-1_all.deb`
Add NVIDIA CUDA repository	`sudo dpkg -i cuda-keyring_1.1-1_all.deb`
Install latest NVIDIA toolkit	`sudo apt install cuda-toolkit`
Pin CUDA 13.3 toolkit	`sudo apt install cuda-toolkit-13-3`
Install NVIDIA repository driver	`sudo apt install cuda-drivers`
Check driver and GPU	`nvidia-smi`
Check toolkit compiler	`nvcc --version`

Prerequisites

Before installing CUDA, make sure you have:

A server or workstation running Ubuntu 26.04 with a user with sudo privileges .
A supported NVIDIA GPU. For CUDA 13.3, use a Turing, Ampere, Ada, Hopper, Blackwell, or newer GPU when you need full library support. Older Maxwell, Pascal, and Volta cards may require an older CUDA release.
Several gigabytes of free disk space. A full Toolkit install uses around 6 to 8 GB.
Secure Boot disabled, or a plan to enroll a Machine Owner Key. The proprietary NVIDIA driver does not load when Secure Boot is enabled and the kernel module is unsigned.

Confirm that the system sees an NVIDIA GPU before going further:

Terminal
lspci | grep -i nvidia

output

01:00.0 VGA compatible controller: NVIDIA Corporation GA106 [GeForce RTX 3060 Lite Hash Rate] (rev a1)
01:00.1 Audio device: NVIDIA Corporation GA106 High Definition Audio Controller (rev a1)

The output should list at least one VGA or 3D controller from NVIDIA. If nothing appears, the GPU is not seated correctly, the slot is disabled in the BIOS, or the card is not supported by the host.

Choosing an Install Method

Ubuntu offers two practical install methods.

The Ubuntu archive ships nvidia-cuda-toolkit as a regular apt package. The version lags behind upstream, but the package integrates with Ubuntu’s update flow and uses the same NVIDIA driver Ubuntu provides.

The NVIDIA repository provides the latest CUDA release, including features and library versions that the Ubuntu archive does not have yet. It can also install the matching driver via the cuda-drivers meta-package. Use this method when you need the newest CUDA release for PyTorch, TensorFlow, or other frameworks pinned to a specific CUDA version.

The two methods are mutually exclusive. Mixing packages from both sources can produce conflicting library paths and broken nvcc lookups. If you switch methods later, remove the old toolkit packages first.

Method 1: Install CUDA from the Ubuntu Archive

Update the package index and install the toolkit:

Terminal
sudo apt update
sudo apt install nvidia-cuda-toolkit

The nvidia-cuda-toolkit package pulls in the compiler, libraries, and headers from the Ubuntu archive. Next, inspect the NVIDIA driver choices for your GPU:

Terminal
ubuntu-drivers devices

The exact driver number depends on your GPU and the Ubuntu archive at install time. Look for the line marked recommended, then install it automatically:

Terminal
sudo ubuntu-drivers install

Reboot once the install finishes so the kernel loads the NVIDIA driver in place of the open-source nouveau driver:

Terminal
sudo reboot

After the system comes back up, jump to the verification section to confirm the driver and toolkit work.

Method 2: Install CUDA from the NVIDIA Repository

The NVIDIA repository is the right choice when you need the latest CUDA release. The setup is two steps: install the repository keyring, then install the toolkit and drivers from the new repository.

Install the CUDA Keyring

NVIDIA distributes a small .deb package that adds the repository definition and signing key to apt. For Ubuntu 26.04 on x86_64, download and install the ubuntu2604 keyring package:

Terminal
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2604/x86_64/cuda-keyring_1.1-1_all.deb
sudo dpkg -i cuda-keyring_1.1-1_all.deb

The keyring package writes /etc/apt/sources.list.d/cuda-ubuntu2604-x86_64.list and installs the GPG key apt uses to verify the repository.

Install the Toolkit and Driver

Refresh the package index and install the toolkit. At publication time, the NVIDIA Ubuntu 26.04 repository publishes CUDA Toolkit 13.3:

Terminal
sudo apt update
sudo apt install cuda-toolkit

The cuda-toolkit meta-package follows the latest CUDA release in the repository. To stay on CUDA 13.3 and avoid automatic movement to the next minor release, install the versioned package instead:

Terminal
sudo apt install cuda-toolkit-13-3

Install the matching driver. The cuda-drivers meta-package always pulls in the version paired with the installed toolkit:

Terminal
sudo apt install cuda-drivers

Reboot so the kernel loads the new driver:

Terminal
sudo reboot

Configure Environment Variables

The NVIDIA repository installs CUDA under /usr/local/cuda. Add the toolkit binaries to your shell PATH so nvcc is available from a new terminal. Append the following line to ~/.bashrc:

~/.bashrcsh
export PATH=/usr/local/cuda/bin${PATH:+:${PATH}}

Reload the shell so the changes take effect:

Terminal
source ~/.bashrc

The Ubuntu archive package places binaries in /usr/bin and libraries in standard system paths, so this step is not needed for Method 1.

Verify the Install

Confirm that the driver loaded and the GPU is visible:

Terminal
nvidia-smi

output

+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 610.43.02 Driver Version: 610.43.02 CUDA Version: 13.3 |
+-----------------------------------------------+----------------------+------------------+
| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |
|=========================================+======================+========================|
| 0 NVIDIA GeForce RTX 3060 Off | 00000000:01:00.0 Off | N/A |
| 0% 38C P8 13W / 170W | 8MiB / 12288MiB | 0% Default |
+-----------------------------------------+----------------------+------------------------+

The output shows the GPU model, driver version, and the CUDA version that the driver supports. The driver-reported CUDA version is the maximum runtime version the driver can load; the installed toolkit can be the same or older.

Check the toolkit compiler:

Terminal
nvcc --version

output

nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2026 NVIDIA Corporation
Cuda compilation tools, release 13.3, V13.3.33

The release line is the toolkit version installed on the system. For CUDA-aware applications, this is the version that matters at compile time.

Run a CUDA Sample

The fastest way to confirm the GPU runs CUDA workloads is the deviceQuery sample. The samples now build with CMake, so install Git, CMake, and build tools, then clone the official samples repository, build the deviceQuery target, and run it from the build tree:

Terminal
sudo apt install git build-essential cmake
git clone --depth 1 https://github.com/NVIDIA/cuda-samples.git
cd cuda-samples
cmake -B build
cmake --build build --target deviceQuery -j$(nproc)
./build/Samples/1_Utilities/deviceQuery/deviceQuery

output

./deviceQuery Starting...
CUDA Device Query (Runtime API) version (CUDART static linking)
Detected 1 CUDA Capable device(s)
Device 0: "NVIDIA GeForce RTX 3060"
CUDA Driver Version / Runtime Version 13.3 / 13.3
CUDA Capability Major/Minor version number: 8.6
Total amount of global memory: 12288 MBytes
...
Result = PASS

A PASS result confirms the toolkit, driver, and GPU work together end-to-end. Frameworks such as PyTorch and TensorFlow rely on the same runtime that this sample exercises, so a passing deviceQuery is a strong signal that machine-learning workloads will run.

Troubleshooting

nvidia-smi reports “No devices were found”
The driver is not loaded. Run lsmod | grep nvidia. If nothing is listed, check the Secure Boot state with mokutil --sb-state. Disable Secure Boot in the BIOS or enroll a Machine Owner Key for the NVIDIA kernel module, then reboot.

nouveau driver still loaded
The open-source nouveau driver conflicts with the NVIDIA driver. Confirm with lsmod | grep nouveau. Blacklist it by creating /etc/modprobe.d/blacklist-nouveau.conf with the lines blacklist nouveau and options nouveau modeset=0, then run sudo update-initramfs -u and reboot.

nvcc not found after install from the NVIDIA repository
The PATH does not include /usr/local/cuda/bin. Add the export line from the environment variables section to ~/.bashrc and run source ~/.bashrc. Verify the binary is on disk with ls /usr/local/cuda/bin/nvcc.

Driver fails to build after a kernel upgrade
The DKMS module needs the matching kernel headers. Install them with sudo apt install linux-headers-$(uname -r), then reinstall the driver package. For the NVIDIA repository method, run sudo apt install --reinstall cuda-drivers. Reboot once the build completes.

CUDA version mismatch errors from PyTorch or TensorFlow
Frameworks ship binaries built against a specific CUDA version. The CUDA version reported by nvidia-smi is the maximum runtime the driver supports. Pick the framework build whose CUDA version is less than or equal to that value.

Out of disk space during install
The full toolkit is large. Free space in /var/cache/apt with sudo apt clean, or install only the components you need by replacing cuda-toolkit with smaller meta-packages such as cuda-compiler-13-3 and cuda-libraries-dev-13-3.

Conclusion

A working CUDA install gives Ubuntu 26.04 the GPU compute stack needed by PyTorch, TensorFlow, llama.cpp, and similar tools. Pin the toolkit version when you build software against a specific CUDA release, and rerun nvidia-smi after every kernel upgrade to make sure the driver still loads.

How to Install and Use Ollama on Ubuntu: Run LLMs Locally

hello@linuxize.com (Linuxize) — Thu, 18 Jun 2026 10:30:00 +0200

Running a large language model does not require sending every prompt to a hosted API. Ollama packages models so you can run them on your Ubuntu machine, use them offline after downloading, and access them from terminal commands or local applications.

When you select a local model, inference and prompt processing stay on your machine. Ollama also supports optional cloud models, which are separate from the local workflow covered here. This guide explains how to install Ollama on Ubuntu, run your first local model, manage downloads, check GPU acceleration, and use the built-in API.

Quick Reference

Command	Description
`ollama run MODEL`	Download a model if needed and start a chat
`ollama pull MODEL`	Download a model without running it
`ollama ls`	List downloaded models
`ollama ps`	Show models currently loaded in memory
`ollama show MODEL`	Display model details
`ollama stop MODEL`	Unload a running model
`ollama rm MODEL`	Remove a downloaded model
`systemctl status ollama`	Check the Ollama service
`journalctl -e -u ollama`	View recent service logs

Step 1: Install Ollama

The official installation script detects the system architecture, installs the Ollama binary, and configures a systemd service. Install curl and zstd first so Ubuntu can download and extract the current package:

Terminal
sudo apt update
sudo apt install curl zstd

You can then run the official installer:

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

The script adds the ollama command to your path, creates a dedicated ollama system user, and enables the background service when systemd is available.

If you prefer to inspect remote scripts before running them, download this one first:

Terminal
curl -fsSL https://ollama.com/install.sh -o ollama-install.sh
less ollama-install.sh
sh ollama-install.sh

Confirm that the command is available:

Terminal
ollama --version

The command prints the installed Ollama version. The number changes as new releases become available.

Step 2: Verify the Ollama Service

Ollama listens on 127.0.0.1:11434 by default. Check that its systemd service is running:

Terminal
systemctl status ollama --no-pager

The relevant part of the output should look similar to this:

output

● ollama.service - Ollama Service
Loaded: loaded (/etc/systemd/system/ollama.service; enabled; preset: enabled)
Active: active (running)

The enabled state means the service starts during boot. active (running) confirms that the local server is ready to accept commands and API requests.

Step 3: Run Your First Model

The ollama run command downloads a model the first time you use it, then opens an interactive chat. Llama 3.2 is a practical first model because its default 3B variant is about 2 GB:

Terminal
ollama run llama3.2

After the download finishes, enter a prompt at the >>> marker:

output

>>> Explain what a reverse proxy does in one sentence.
A reverse proxy receives client requests and forwards them to one or more
backend servers, often handling TLS, caching, or load balancing.
>>> /bye

Type /bye or press Ctrl+D to leave the chat. Enter /? inside the session to see the available interactive commands.

Step 4: Manage Models

The Ollama model library lists available models, variants, file sizes, and context limits. Download another model without opening a chat by using ollama pull:

Terminal
ollama pull mistral

List the models stored on the machine:

Terminal
ollama ls

output

NAME ID SIZE MODIFIED
llama3.2:latest a80c4f17acd5 2.0 GB 5 minutes ago
mistral:latest f974a74358d6 4.1 GB 1 minute ago

Use ollama show to inspect a model and ollama ps to see which models are loaded in memory:

Terminal
ollama show llama3.2
ollama ps

Ollama keeps a recently used model loaded for five minutes by default. Unload it immediately with ollama stop:

Terminal
ollama stop llama3.2

Remove an unused download to recover disk space:

Terminal
ollama rm mistral

Models installed by the system service are stored under /usr/share/ollama/.ollama/models. When you pick a model, match its size to the memory you have. A small 1B to 3B model runs comfortably on a CPU, while larger models want more RAM or GPU memory and feel much faster once a supported GPU handles them.

Step 5: Use the Ollama API

The local API is available at http://localhost:11434/api. Send a prompt to the generate endpoint with curl, setting stream to false so the server returns one completed JSON response:

Terminal
curl http://localhost:11434/api/generate -d '{
 "model": "llama3.2",
 "prompt": "Name three Linux distributions.",
 "stream": false
}'

The JSON response contains the generated text in the response field, along with timing and token-count information. Because the request stays on your machine, local models need no API key or authentication.

The same local service also exposes chat, embeddings, model-management, and OpenAI-compatible endpoints, so most applications and browser front ends can talk to Ollama without any extra setup.

Step 6: Check GPU Acceleration

If no supported GPU is present, Ollama falls back to the CPU and still works, just more slowly. When the Linux installer detects supported NVIDIA or AMD hardware, it pulls in the matching GPU libraries for you. You still need a working GPU driver on the host, since Ollama relies on it to reach the card.

For NVIDIA hardware, verify the installed driver:

Terminal
nvidia-smi

Ollama does not require the full CUDA Toolkit for inference. It supports NVIDIA GPUs with compute capability 5.0 or newer, subject to the driver requirements listed in the official hardware documentation .

For supported AMD hardware on Linux, Ollama uses ROCm and requires a compatible ROCm 7 driver. The installer downloads the additional ROCm package when it detects an AMD GPU.

Run a model, then check which processor it uses:

Terminal
ollama run llama3.2 "Respond with the word ready."
ollama ps

output

NAME ID SIZE PROCESSOR UNTIL
llama3.2:latest a80c4f17acd5 3.5 GB 100% GPU 4 minutes from now

A PROCESSOR value of 100% GPU confirms GPU inference. If it shows 100% CPU, inspect the service logs and verify that the GPU driver can see the card:

Terminal
journalctl -e -u ollama

Step 7: Expose Ollama on the Network

Ollama binds to the loopback address by default, which prevents other devices from reaching it. To use a separate GPU server from a trusted workstation, create a systemd override:

Terminal
sudo systemctl edit ollama

Add the following setting:

ini
[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"

Reload systemd and restart Ollama:

Terminal
sudo systemctl daemon-reload
sudo systemctl restart ollama

Warning

The local Ollama API does not require authentication. Binding it to 0.0.0.0 exposes model execution to every client that can reach port 11434. Allow only trusted source addresses with a firewall, and do not publish the port directly to the internet.

For example, this UFW rule permits a private subnet and blocks unrelated clients:

Terminal
sudo ufw allow from 192.168.1.0/24 to any port 11434 proto tcp

Replace the subnet with the address or network that should have access. See the Ubuntu UFW guide for rule management and verification.

Update Ollama

When a new release lands, you do not need a special upgrade command. Run the same installation script again and it updates Ollama in place:

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

The installer replaces the program files and restarts the service without deleting downloaded models.

Troubleshooting

Ollama cannot connect to the local service
Start the service with sudo systemctl start ollama, then inspect its status with systemctl status ollama --no-pager.

The service starts but model commands fail
Read the recent logs with journalctl -e -u ollama. For live output while reproducing the problem, use journalctl -u ollama --no-pager --follow --pager-end.

A model runs out of memory
Remove other loaded models with ollama stop MODEL, then choose a smaller model or a lower-precision variant from the model library.

Ollama uses the CPU instead of an NVIDIA GPU
Run nvidia-smi and update the NVIDIA driver if it cannot see the card. After a Linux suspend and resume cycle, reloading nvidia_uvm or rebooting may restore GPU detection.

Ollama does not detect an AMD GPU
Confirm that the host uses a supported GPU and ROCm 7 driver. Check /dev/kfd permissions and the Ollama logs for ROCm or GPU-discovery errors.

Conclusion

Ollama provides a direct way to run local language models on Ubuntu through the terminal or an HTTP API. Start with a small model, confirm its memory and processor use with ollama ps, and keep port 11434 restricted to trusted systems.

Ai on Linuxize

How to Install Claude Code on Ubuntu and Linux

Prerequisites #

Quick Reference #

Option 1: The Native Installer (Recommended) #

Option 2: Linux Package Managers (Advanced) #

Option 3: npm #

Verifying the Installation #

First Run and Sign-In #

Updating Claude Code #

Uninstalling Claude Code #

Troubleshooting #

Conclusion #

How to Install NVIDIA CUDA Toolkit on Ubuntu 26.04

Quick Reference #

Prerequisites #

Choosing an Install Method #

Method 1: Install CUDA from the Ubuntu Archive #

Method 2: Install CUDA from the NVIDIA Repository #

Install the CUDA Keyring #

Install the Toolkit and Driver #

Configure Environment Variables #

Verify the Install #

Run a CUDA Sample #

Troubleshooting #

Conclusion #

How to Install and Use Ollama on Ubuntu: Run LLMs Locally

Quick Reference #

Step 1: Install Ollama #

Step 2: Verify the Ollama Service #

Step 3: Run Your First Model #

Step 4: Manage Models #

Step 5: Use the Ollama API #

Step 6: Check GPU Acceleration #

Step 7: Expose Ollama on the Network #

Update Ollama #

Troubleshooting #

Conclusion #

Prerequisites

Quick Reference

Option 1: The Native Installer (Recommended)

Option 2: Linux Package Managers (Advanced)

Option 3: npm

Verifying the Installation

First Run and Sign-In

Updating Claude Code

Uninstalling Claude Code

Troubleshooting

Conclusion

Quick Reference

Prerequisites

Choosing an Install Method

Method 1: Install CUDA from the Ubuntu Archive

Method 2: Install CUDA from the NVIDIA Repository

Install the CUDA Keyring

Install the Toolkit and Driver

Configure Environment Variables

Verify the Install

Run a CUDA Sample

Troubleshooting

Conclusion

Quick Reference

Step 1: Install Ollama

Step 2: Verify the Ollama Service

Step 3: Run Your First Model

Step 4: Manage Models

Step 5: Use the Ollama API

Step 6: Check GPU Acceleration

Step 7: Expose Ollama on the Network

Update Ollama

Troubleshooting

Conclusion