Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars

Parent: Ollama server ops, scheduling, GPU, sizing and desktop · Published reference · snapshot 2026-10-14 · skill ollama-expert/references/ollama-server-ops-scheduling-gpu-sizing-and-desktop.md

↓ Facts as markdown all context files

OLLAMA_VULKAN=1 GGML_VK_VISIBLE_DEVICES=0 ollama serve (from knightli.com)

These notes link each claim to its source. Some citations identify archived research reports that are no longer hosted on this site. A published reference means the content is available; it does not certify independent review or accuracy.Read the editorial policy and follow the sources before relying on a claim.

Definitions

This typically means the system's AMD GPU driver is too old. Ollama bundles ROCm 7 linux libraries which require a compatible ROCm 7 kernel driver. If the system is running an older driver (ROCm 6.x or earlier), GPU initialization will hang during device discovery and eventually time out, causing Ollama to fall back to CPU. [source]
* If you are using a container, is the container runtime working? Try `docker run --gpus all ubuntu nvidia-smi` - if this doesn't work, Ollama won't be able to see your NVIDIA GPU. * Is the uvm driver loaded? `sudo nvidia-modprobe -u` * Try reloading the nvidia\_uvm driver - `sudo rmmod nvidia_uvm` then `sudo modprobe nvidia_uvm` * Try rebooting * Make sure you're running the latest nvidia drivers [source]
Vulkan itself is a cross-platform graphics API that works across a wide range of GPU manufacturers, including Intel and older AMD cards outside the ROCm compatibility list. [source]

Structure and components

Additional GPU support on Windows and Linux is provided via [Vulkan](https://www.vulkan.org/). Vulkan is enabled by default when the backend is installed. On Windows most GPU vendors drivers come bundled with Vulkan support and require no additional setup steps. Most Linux distributions require installing additional components, and you may have multiple options for Vulkan drivers between Mesa and GPU Vendor specific packages [source]

How it works

Vulkan is the documented path for GPUs that ROCm does not cover. Per the current docs it is enabled by default when the backend is installed. OLLAMA_VULKAN=0 or GGML_VK_VISIBLE_DEVICES=-1 disables all Vulkan GPUs. GGML_VK_VISIBLE_DEVICES takes numeric IDs to select specific Vulkan GPUs. [source]
On a mixed iGPU/dGPU system where the Vulkan iGPU is unstable, keep Vulkan on and set GGML_VK_VISIBLE_DEVICES to the discrete GPU index (for example 1 when Vulkan1 is the discrete GPU). [source]
ROCR_VISIBLE_DEVICES selects AMD ROCm GPUs. List devices with `rocminfo`, and use the Uuid when available. An invalid ID such as -1 forces CPU. [source]
Launching ollama with the OLLAMA_VULKAN=1 environment variable set will now enable Vulkan API support as an alternative to the likes of AMD ROCm and NVIDIA CUDA acceleration. This is great for open-source Vulkan drivers, older AMD graphics cards lacking ROCm support, or even any AMD setup with the RADV driver present but not having installed ROCm. As we've seen when testing Llama.cpp with Vulkan, in some cases using Vulkan can be faster than using the likes of ROCm. [source]
On mixed iGPU/dGPU systems where the Vulkan iGPU is unstable, keep Vulkan enabled and set `GGML_VK_VISIBLE_DEVICES` to the discrete GPU index. For example, use `GGML_VK_VISIBLE_DEVICES=1` when `Vulkan1` is the discrete GPU. [source]
Vulkan is bundled into the `ollama/ollama` image and is enabled by default when the container can access the GPU devices. [source]
If you experience gibberish responses when models load across multiple AMD GPUs on Linux, see the following guide. [source]

How-to and procedures

To resolve this, upgrade to the ROCm v7 driver using the `amdgpu-install` utility from [AMD's ROCm documentation](https://rocm.docs.amd.com/projects/install-on-linux/en/latest/). After upgrading, reboot and restart Ollama. [source]
To select specific Vulkan GPU(s), you can set the environment variable `GGML_VK_VISIBLE_DEVICES` to one or more numeric IDs on the Ollama server as described in the [FAQ](faq#how-do-i-configure-ollama-server). If you encounter any problems with Vulkan based GPUs, you can disable all Vulkan GPUs by setting `OLLAMA_VULKAN=0` or `GGML_VK_VISIBLE_DEVICES=-1`. [source]
Use `OLLAMA_VULKAN=0` to disable Vulkan, or `GGML_VK_VISIBLE_DEVICES=<ids>` to select specific Vulkan devices. [source]
To run Ollama using Docker with AMD GPUs, use the `rocm` tag and the following command: [source]

Examples and snippets

```shell theme={"system"} — `sudo nvidia-ctk runtime configure --runtime=docker` … [source]
```shell theme={"system"} — `docker run -d --device /dev/kfd --device /dev/dri -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/` … [source]

Measurements and reference values

| Compute Capability | Family | Cards | | - | - | - | | 12.1 | NVIDIA | `GB10 (DGX Spark)` | | 12.0 | GeForce RTX 50xx | `RTX 5060` `RTX 5060 Ti` `RTX 5070` `RTX 5070 Ti` `RTX 5080` `RTX 5090` | | | NVIDIA Professional | `RTX PRO 4000 Blackwell` `RTX PRO 4500 Blackwell` `RTX PRO 5000 Blackwell` `RTX PRO 6000 Blackwell` | | 9.0 | NVIDIA | `H200` `H100` | | 8.9 | GeForce RTX 40xx | `RTX 4090` `RTX 4080 SUPER` `RTX 4080` `RTX 4070 Ti SUPER` `RTX 4070 Ti` `RTX 4070 SUPER` `RTX 4070` `RTX 4060 Ti` `RTX 4060` | | | NVIDIA Professional | `L4` `L40` `RTX 6000` | | 8.6 | GeForce RTX 30xx | `RTX 3090 Ti [source]
GPU: NVIDIA RTX 5070 Ti Laptop (Blackwell sm_120, 12 GB VRAM) [source]
===================================== ROCm System Management Interface ===================================== =============================================== Concise Info =============================================== Device [Model : Revision] Temp Power Partitions SCLK MCLK Fan Perf PwrCap VRAM% GPU% Name (20 chars) (Edge) (Avg) (Mem, Compute) ============================================================================================================ 0 [0x5026 : 0xc1] 40.0°C 5.0W N/A, N/A 700Mhz 96Mhz 0% auto 164.0W 10% 5% 0x73ef =============================================================== [source]
Lemonade Fixes AMD APU Model Streaming, Drops OpenMOSS ROCm As ~40x Slower Than Vulkan [source]
time=2024-03-02T00:34:13.785Z level=INFO source=images.go:710 msg="total blobs: 16" time=2024-03-02T00:34:13.785Z level=INFO source=images.go:717 msg="total unused blobs removed: 0" time=2024-03-02T00:34:13.786Z level=INFO source=routes.go:1019 msg="Listening on [::]:11434 (version 0.1.27)" time=2024-03-02T00:34:13.786Z level=INFO source=payload_common.go:107 msg="Extracting dynamic libraries..." time=2024-03-02T00:34:16.164Z level=INFO source=payload_common.go:146 msg="Dynamic LLM libraries [rocm_v6 cuda_v11 cpu cpu_avx rocm_v5 cpu_avx2]" time=2024-03-02T00:34:16.164Z level=INFO source=gpu.go [source]

Problems, failure modes and limitations

CUDA_VISIBLE_DEVICES takes a comma-separated list to limit Ollama to a subset of NVIDIA GPUs. UUIDs (from `nvidia-smi -L`) are more reliable than numeric IDs because ordering may vary. An invalid ID such as -1 forces CPU. [source]
On Linux after a suspend/resume cycle, Ollama can fail to find the NVIDIA GPU and fall back to CPU. Reloading the UVM driver works around it: `sudo rmmod nvidia_uvm && sudo modprobe nvidia_uvm`. [source]
* `AMD_LOG_LEVEL=3` Enable info log levels in the AMD HIP/ROCm libraries. This can help show more detailed error codes that can help troubleshoot problems * `OLLAMA_DEBUG=1` During GPU discovery additional information will be reported * Check dmesg for any errors from amdgpu or kfd drivers `sudo dmesg | grep -i amdgpu` and `sudo dmesg | grep -i kfd` [source]
If you have multiple NVIDIA GPUs in your system and want to limit Ollama to use a subset, you can set `CUDA_VISIBLE_DEVICES` to a comma separated list of GPUs. Numeric IDs may be used, however ordering may vary, so UUIDs are more reliable. You can discover the UUID of your GPUs by running `nvidia-smi -L` If you want to ignore the GPUs and force CPU usage, use an invalid GPU ID (e.g., "-1") [source]
rocBLAS error: Cannot read /opt/rocm/lib/rocblas/library/TensileLibrary.dat: Illegal seek for GPU arch : gfx1032 List of available TensileLibrary Files : "/opt/rocm/lib/rocblas/library/TensileLibrary_lazy_gfx1101.dat" "/opt/rocm/lib/rocblas/library/TensileLibrary_lazy_gfx1030.dat" "/opt/rocm/lib/rocblas/library/TensileLibrary_lazy_gfx90a.dat" "/opt/rocm/lib/rocblas/library/TensileLibrary_lazy_gfx942.dat" "/opt/rocm/lib/rocblas/library/TensileLibrary_lazy_gfx941.dat" "/opt/rocm/lib/rocblas/library/TensileLibrary_lazy_gfx1102.dat" "/opt/rocm/lib/rocblas/library/TensileLibrary_lazy_gfx940.dat" "/ [source]

Comparisons and alternatives

If you have multiple AMD GPUs in your system and want to limit Ollama to use a subset, you can set `ROCR_VISIBLE_DEVICES` to a comma separated list of GPUs. You can see the list of devices with `rocminfo`. If you want to ignore the GPUs and force CPU usage, use an invalid GPU ID (e.g., "-1"). When available, use the `Uuid` to uniquely identify the device instead of numeric value. [source]
Hostinger provides a preconfigured Ollama template that you can deploy with a few clicks, instead of installing Ollama, GPU drivers, and other dependencies yourself from the Linux command line. [source]
ROCm 10 OpenCL vs. Mesa 26.3-dev Rusticl Performance On AMD Strix Halo [source]

Facts and statements

if runtime.GOOS != "darwin" { ret["CUDA_VISIBLE_DEVICES"] = EnvVar{"CUDA_VISIBLE_DEVICES", CudaVisibleDevices(), "Set which NVIDIA devices are visible"} ret["HIP_VISIBLE_DEVICES"] = EnvVar{"HIP_VISIBLE_DEVICES", HipVisibleDevices(), "Set which AMD devices are visible by numeric ID"} ret["ROCR_VISIBLE_DEVICES"] = EnvVar{"ROCR_VISIBLE_DEVICES", RocrVisibleDevices(), "Set which AMD devices are visible by UUID or numeric ID"} ret["GGML_VK_VISIBLE_DEVICES"] = EnvVar{"GGML_VK_VISIBLE_DEVICES", VkVisibleDevices(), "Set which Vulkan devices are visible by numeric ID"} ret["GPU_DEVICE_ORDINAL"] = EnvVa [source]
Vulkan first shipped as experimental. On 2025-11-14 Phoronix reported ollama 0.12.11 with Vulkan enabled by setting OLLAMA_VULKAN=1, aimed at older AMD GPUs without ROCm support and RADV systems without ROCm installed. [source]
NVIDIA support needs compute capability 5.0+ and driver 550 or newer. Cards with compute capability 5.0 through 6.2 need driver 570 or newer. [source]
Without HSA_OVERRIDE_GFX_VERSION, an unsupported gfx1032 card (RX 6650 XT) crashed in rocBLAS with a missing TensileLibrary.dat and a segmentation fault. Setting 10.3.0 in the docker run command fixed it (ollama/ollama:0.1.27-rocm, March 2024). [source]
On Linux, Ollama requires the AMD ROCm v7 driver. On Windows it requires a ROCm v7 / HIP7-capable driver stack. The Windows supported-card list is shorter than the Linux list (Radeon RX 7600 through 7900 XTX and Radeon PRO W7500 through W7900). [source]
HSA_OVERRIDE_GFX_VERSION=x.y.z forces ROCm to use a nearby supported LLVM target for an unsupported AMD GPU, for example 10.3.0 for a gfx1032 or gfx1034 card. With mixed GPUs, append the device number (HSA_OVERRIDE_GFX_VERSION_0, HSA_OVERRIDE_GFX_VERSION_1). The documented override is Linux-only. [source]
With SELinux, containers may be denied access to AMD GPU devices. Run `sudo setsebool container_use_devices=1` on the host. [source]
<Note> Some RDNA2 / Radeon RX 6000 systems, including RX 6800-class cards, may not expose ROCm v7 on current Windows AMD drivers. Vulkan is enabled by default and is the recommended fallback for those systems. If a mixed iGPU/dGPU system selects an unstable Vulkan iGPU, set `GGML_VK_VISIBLE_DEVICES` to the discrete GPU index. </Note> [source]
Ollama v0.32.5 reads 26 OLLAMA_ variables in envconfig/config.go, plus the GPU selection variables (CUDA_VISIBLE_DEVICES, HIP_VISIBLE_DEVICES, ROCR_VISIBLE_DEVICES, GGML_VK_VISIBLE_DEVICES, GPU_DEVICE_ORDINAL, HSA_OVERRIDE_GFX_VERSION) and the standard proxy variables it inherits from the environment. The official FAQ documents roughly half of them. [source]
CudaVisibleDevices = String("CUDA_VISIBLE_DEVICES") HipVisibleDevices = String("HIP_VISIBLE_DEVICES") RocrVisibleDevices = String("ROCR_VISIBLE_DEVICES") VkVisibleDevices = String("GGML_VK_VISIBLE_DEVICES") GpuDeviceOrdinal = String("GPU_DEVICE_ORDINAL") HsaOverrideGfxVersion = String("HSA_OVERRIDE_GFX_VERSION") ) [source]
Ollama supports NVIDIA GPUs with CUDA compute capability 5.0 or higher. This includes many GeForce GTX and RTX cards, as well as data center GPUs such as the A100, H100, and H200. [source]
• AMD: Works on most AMD GPUs with ROCm support, although ROCm in general is not as well supported as CUDA or Metal and performance may vary. [source]
想限制 Ollama 使用哪些 GPU，需要用 CUDA_VISIBLE_DEVICES、ROCR_VISIBLE_DEVICES 或 GGML_VK_VISIBLE_DEVICES。 [source]
llama.cpp GPU 性能怎么比：CUDA、ROCm、Vulkan 复测与选卡方法 [source]
* Linux Intel GPU Instructions - [https://dgpu-docs.intel.com/driver/client/overview.html](https://dgpu-docs.intel.com/driver/client/overview.html) * Linux AMD GPU Instructions - [https://amdgpu-install.readthedocs.io/en/latest/install-script.html#specifying-a-vulkan-implementation](https://amdgpu-install.readthedocs.io/en/latest/install-script.html#specifying-a-vulkan-implementation) [source]
整理 Ollama 多显卡使用中的关键信息：什么时候会跨 GPU 加载模型、如何用 CUDA_VISIBLE_DEVICES / ROCR_VISIBLE_DEVICES 限制显卡、显存是否能叠加、不同 GPU 能不能混用，以及 Docker、PCIe 带宽和性能方面的常见误区。 [source]
OLLAMA_VULKAN=1 GGML_VK_VISIBLE_DEVICES=0 ollama serve [source]
老卡要先确认 CUDA compute capability 或 ROCm 支持。 [source]
The right GPU also depends on Ollama’s hardware compatibility, including NVIDIA CUDA, AMD ROCm, Apple Silicon, and Vulkan-supported devices. [source]
Ollama supports NVIDIA GPUs, selected AMD GPUs, and Apple Silicon Macs, as well as additional GPUs on Windows and Linux through Vulkan. [source]
Ollama supports Vulkan on Windows and Linux, giving it access to GPUs beyond those supported by NVIDIA CUDA and AMD ROCm. [source]
Performance through Vulkan is generally slower than CUDA or ROCm, but still faster than CPU-only. [source]
For AMD GPUs on some Linux distributions, you may need to add the `ollama` user to the `render` group. [source]
* Windows 10 22H2 or newer, Home or Pro * NVIDIA 551.61 or newer Drivers if you have an NVIDIA card * AMD ROCm v7 / HIP7-capable driver stack for ROCm acceleration, or a Vulkan-capable AMD Radeon driver for Vulkan acceleration [source]
AMD ROCm 环境下，用 ROCR_VISIBLE_DEVICES 控制可见 GPU： [source]
Ollama 官方 GPU 文档还提到，如果用实验性的 Vulkan 支持，可以通过 GGML_VK_VISIBLE_DEVICES 选择 Vulkan GPU： [source]
Ollama requires the AMD ROCm v7 driver on Linux. You can install or upgrade using the `amdgpu-install` utility from [AMD's ROCm documentation](https://rocm.docs.amd.com/projects/install-on-linux/en/latest/). [source]
Ollama leverages the AMD ROCm library, which does not support all AMD GPUs. In some cases you can force the system to try to use a similar LLVM target that is close. For example The Radeon RX 5400 is `gfx1034` (also known as 10.3.4) however, ROCm does not currently support this target. The closest support is `gfx1030`. You can use the environment variable `HSA_OVERRIDE_GFX_VERSION` with `x.y.z` syntax. So for example, to force the system to run on the RX 5400, you would set `HSA_OVERRIDE_GFX_VERSION="10.3.0"` as an environment variable for the server. If you have an unsupported AMD GPU you can [source]
On Windows, OllamaSetup.exe installs per-user without Administrator rights (default under %LOCALAPPDATA%\Programs\Ollama, PATH updated for the user); `OllamaSetup.exe /DIR="d:\some\location"` relocates the binaries. Requirements: Windows 10 22H2 or newer and NVIDIA driver 551.61+ for NVIDIA cards. [source]
Sick I was able to figure it out. I found this comment ROCm/Tensile#1936 which suggested setting the environment variable HSA_OVERRIDE_GFX_VERSION=10.3.0. That worked for me. The full command I ran to get it to work is: docker run -d -e HSA_OVERRIDE_GFX_VERSION=10.3.0 --device /dev/kfd --device /dev/dri -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama:0.1.27-rocm [source]
docker run -d \ --gpus=all \ -e CUDA_VISIBLE_DEVICES=0,1 \ -v ollama:/root/.ollama \ -p 11434:11434 \ --name ollama \ ollama/ollama [source]
Ollama requires NVIDIA driver version 550 or newer. For GPUs with compute capability 5.0-6.2, driver version 570 or later is required. [source]
Ollama supports GPU acceleration on Apple Silicon Macs through Metal, so you don’t need to install a separate GPU driver. [source]
• NVIDIA GPUs: Works on all NVIDIA GPUs with CUDA support, Pascal and newer. [source]
<Note> While AMD has contributed the `amdgpu` driver upstream to the official linux kernel source, the version is older and may not support all ROCm features. We recommend you install the latest driver from [https://www.amd.com/en/support/download/linux-drivers.html](https://www.amd.com/en/support/download/linux-drivers.html) for best support of your Radeon GPU. </Note> [source]
The last four rows were never used for fitting. They come from the community scoreboards for CUDA, Vulkan and Apple silicon, and the same 0.82 factor lands within 3 percent on Strix Halo, the M5 Max and the GB10. Three hardware classes needed their own factor, and the calculator applies it automatically: [source]
slog.Info("selecting GPU backend for llama-server model", "library", selected[0].Library, "gpu_count", len(selected), "available_gpu_count", len(all)) } [source]
llama llm.LlamaServer pid int loading bool // True only during initial load, then false forever gpus []ml.DeviceID // Recorded at time of provisioning discreteGPUs bool // True if all devices are discrete GPUs - used to skip VRAM recovery check for iGPUs runner string vramSize uint64 totalSize uint64 [source]
// CPU, Metal and iGPUs don't need checking, so no waiting required if len(runner.gpus) == 0 || !runner.discreteGPUs || (len(runner.gpus) == 1 && runner.gpus[0].Library == "Metal") { finished <- struct{}{} slog.Debug("no need to wait for VRAM recovery", "runner", runner) return finished } start := time.Now() [source]
CUDA_VISIBLE_DEVICES=GPU-xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx ollama serve [source]
Ollama supports AMD GPUs through ROCm on Linux and Windows, although Windows supports fewer cards. Common supported consumer GPUs from the Radeon RX 7000 series include: [source]
NVIDIA's Nova Driver Continues Leading The Way For Linux Rust GPU Drivers [source]
* **AMD GPU**: `ollama-windows-amd64-rocm.zip` * **MLX (CUDA)**: `ollama-windows-amd64-mlx.zip` [source]
RX 7900 XTX on Vulkan: typical runs on the RADV driver sit near 158 tok/s, an efficiency of 0.73. The best proprietary-driver runs on the scoreboard reach about 183, so those users can expect about 15 to 20 percent more. [source]
Dedicated NVIDIA GPUs from German data centres, billed by the hour and ready in minutes. Rent a GPU server → [source]
func hasCUDADevice(gpus []ml.DeviceInfo) bool { return slices.ContainsFunc(gpus, func(gpu ml.DeviceInfo) bool { return gpu.Library == "CUDA" }) } [source]
func disableMmapDefaultReason(goos string, opts api.Options, gpus []ml.DeviceInfo, blockCount, predictedVRAM, availableVRAM uint64) string { if opts.UseMMap != nil { return "" } if opts.NumGPU == 0 || len(gpus) == 0 || allDevicesLibrary(gpus, "cpu") { return "cpu" } if goos == "windows" && hasDeviceLibrary(gpus, "cuda") { return "windows_cuda" } if hasDeviceLibrary(gpus, "metal") { if opts.NumGPU > 0 && blockCount > 0 && uint64(opts.NumGPU) < blockCount+1 { return "metal_partial_offload" } if opts.NumGPU < 0 && predictedVRAM > 0 && availableVRAM > 0 && predictedVRAM > availableVRAM { return "m [source]
This was confirmed in #20866 and by our testing with Gemma 4 12B QAT + MTP (head_size=512, SWA, Blackwell RTX 5070 Ti). [source]
I am running it on Kubuntu 26.04 with Vulkan backend. [source]
Ollama ROCm Docker container crashing on RX 6650 #2870 [source]
Ollama ROCm Docker container crashing on RX 6650#2870 [source]
AMD 多卡比 NVIDIA 更容易遇到驱动、ROCm 版本、GFX 版本支持的问题。官方文档中也提到 Linux 下 ROCm 驱动版本、HSA_OVERRIDE_GFX_VERSION 等兼容性处理。多张不同代 AMD 卡混用时，先确认每张卡是否单独可用，再考虑多卡。 [source]
OLLAMA_VULKANEnable the Vulkan backendon where the backend is installedWindows and Linux [source]
GGML_VK_VISIBLE_DEVICESWhich Vulkan devices are visible, by numeric IDallWindows and Linux [source]
Flash attentionAutomatic where the backend and devices support itAutomatic, resolves on for Metal [source]
> **NOTE:** > Additional AMD GPU support is provided by the Vulkan Library - see below. [source]
Ollama requires an AMD ROCm v7 / HIP7-capable driver stack on Windows. [source]
Ollama supports GPU acceleration on Apple devices via the Metal API. [source]
ollama 0.12.11 Brings Vulkan Acceleration [source]
ollama 0.12.11 released this week as the newest feature update to this easy-to-run method of deploying OpenAI GPT-OSS, DeepSeek-R1, Gemma 3, and other large language models. Exciting with ollama 0.12.11 is that it's now supporting the Vulkan API. [source]
This commit in ollama 0.12.11 lays out all the details on the Vulkan API support for ollama. Over the past few weeks ollama offered the Vulkan support as experimental. [source]
• Apple Silicon (Metal): Works on Apple Silicon devices. [source]
Troubleshooting common issues with AMD ROCm on Windows [source]
var ( LLMLibrary = String("OLLAMA_LLM_LIBRARY") Editor = String("OLLAMA_EDITOR") [source]
NVIDIA 多卡环境下，用 CUDA_VISIBLE_DEVICES 控制 Ollama 能看到哪些卡。 [source]
[Service] Environment="CUDA_VISIBLE_DEVICES=0,1" [source]
Wan 2.2 本地部署指南，说明模型家族、ComfyUI 与 Diffusers 路线、CUDA 环境、显存预算、模型下载、生成参数、性能验证和常见错误。 [source]
You can set OLLAMA\_LLM\_LIBRARY to any of the available LLM libraries to bypass autodetection, so for example, if you have a CUDA card, but want to force the CPU LLM library with AVX2 vector support, use: [source]

Related concepts

GPU — is a related of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
ROCm — is a synonym of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
Vulkan — is a synonym of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
CUDA — is a synonym of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
device — is a related of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
driver — is a related of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
backend — is a related of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
GGML_VK_VISIBLE_DEVICES — is a synonym of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
GPU backend — is a synonym of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
CUDA_VISIBLE_DEVICES — is a synonym of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
docker — is a related of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
AMD GPUs — is a synonym of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
ROCR_VISIBLE_DEVICES — is a synonym of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
Metal — is a synonym of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
NVIDIA GPUs — is a synonym of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
compute capability — is a synonym of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
iGPU — is a synonym of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
ollama/ollama — is a part of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
VRAM — is a synonym of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars
gpu discovery — is a problem of Ollama GPU backends and hardware support: CUDA / ROCm / Vulkan / device selection env vars

Children

No children recorded.

← the whole tree · 3D view· how to read this page